1 // RUN: %clang_cc1 -std=c++11 -triple x86_64-linux-gnu -fms-extensions -ast-dump -ast-dump-filter Test %s | FileCheck -check-prefix CHECK -strict-whitespace %s 2 3 class testEnumDecl { 4 enum class TestEnumDeclScoped; 5 enum TestEnumDeclFixed : int; 6 }; 7 // CHECK: EnumDecl{{.*}} class TestEnumDeclScoped 'int' 8 // CHECK: EnumDecl{{.*}} TestEnumDeclFixed 'int' 9 10 class testFieldDecl { 11 int TestFieldDeclInit = 0; 12 }; 13 // CHECK: FieldDecl{{.*}} TestFieldDeclInit 'int' 14 // CHECK-NEXT: IntegerLiteral 15 16 namespace testVarDeclNRVO { 17 class A { }; 18 A foo() { 19 A TestVarDeclNRVO; 20 return TestVarDeclNRVO; 21 } 22 } 23 // CHECK: VarDecl{{.*}} TestVarDeclNRVO 'class testVarDeclNRVO::A' nrvo 24 25 void testParmVarDeclInit(int TestParmVarDeclInit = 0); 26 // CHECK: ParmVarDecl{{.*}} TestParmVarDeclInit 'int' 27 // CHECK-NEXT: IntegerLiteral{{.*}} 28 29 namespace TestNamespaceDecl { 30 int i; 31 } 32 // CHECK: NamespaceDecl{{.*}} TestNamespaceDecl 33 // CHECK-NEXT: VarDecl 34 35 namespace TestNamespaceDecl { 36 int j; 37 } 38 // CHECK: NamespaceDecl{{.*}} TestNamespaceDecl 39 // CHECK-NEXT: original Namespace 40 // CHECK-NEXT: VarDecl 41 42 inline namespace TestNamespaceDeclInline { 43 } 44 // CHECK: NamespaceDecl{{.*}} TestNamespaceDeclInline inline 45 46 namespace testUsingDirectiveDecl { 47 namespace A { 48 } 49 } 50 namespace TestUsingDirectiveDecl { 51 using namespace testUsingDirectiveDecl::A; 52 } 53 // CHECK: NamespaceDecl{{.*}} TestUsingDirectiveDecl 54 // CHECK-NEXT: UsingDirectiveDecl{{.*}} Namespace{{.*}} 'A' 55 56 namespace testNamespaceAlias { 57 namespace A { 58 } 59 } 60 namespace TestNamespaceAlias = testNamespaceAlias::A; 61 // CHECK: NamespaceAliasDecl{{.*}} TestNamespaceAlias 62 // CHECK-NEXT: Namespace{{.*}} 'A' 63 64 using TestTypeAliasDecl = int; 65 // CHECK: TypeAliasDecl{{.*}} TestTypeAliasDecl 'int' 66 67 namespace testTypeAliasTemplateDecl { 68 template<typename T> class A; 69 template<typename T> using TestTypeAliasTemplateDecl = A<T>; 70 } 71 // CHECK: TypeAliasTemplateDecl{{.*}} TestTypeAliasTemplateDecl 72 // CHECK-NEXT: TemplateTypeParmDecl 73 // CHECK-NEXT: TypeAliasDecl{{.*}} TestTypeAliasTemplateDecl 'A<T>' 74 75 namespace testCXXRecordDecl { 76 class A { }; 77 class B { }; 78 class TestCXXRecordDecl : virtual A, public B { 79 int i; 80 }; 81 } 82 // CHECK: CXXRecordDecl{{.*}} class TestCXXRecordDecl 83 // CHECK-NEXT: virtual private 'class testCXXRecordDecl::A' 84 // CHECK-NEXT: public 'class testCXXRecordDecl::B' 85 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestCXXRecordDecl 86 // CHECK-NEXT: FieldDecl 87 88 template<class...T> 89 class TestCXXRecordDeclPack : public T... { 90 }; 91 // CHECK: CXXRecordDecl{{.*}} class TestCXXRecordDeclPack 92 // CHECK-NEXT: public 'T'... 93 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestCXXRecordDeclPack 94 95 thread_local int TestThreadLocalInt; 96 // CHECK: TestThreadLocalInt {{.*}} tls_dynamic 97 98 __module_private__ class TestCXXRecordDeclPrivate; 99 // CHECK: CXXRecordDecl{{.*}} class TestCXXRecordDeclPrivate __module_private__ 100 101 class testCXXMethodDecl { 102 __module_private__ void TestCXXMethodDeclPrivate(); 103 virtual void TestCXXMethodDeclPure() = 0; 104 void TestCXXMethodDeclDelete() = delete; 105 void TestCXXMethodDeclThrow() throw(); 106 void TestCXXMethodDeclThrowType() throw(int); 107 }; 108 // CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclPrivate 'void (void)' __module_private__ 109 // CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclPure 'void (void)' virtual pure 110 // CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclDelete 'void (void)' delete 111 // CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclThrow 'void (void) throw()' 112 // CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclThrowType 'void (void) throw(int)' 113 114 namespace testCXXConstructorDecl { 115 class A { }; 116 class TestCXXConstructorDecl : public A { 117 int I; 118 TestCXXConstructorDecl(A &a, int i) : A(a), I(i) { } 119 }; 120 } 121 // CHECK: CXXConstructorDecl{{.*}} TestCXXConstructorDecl 'void {{.*}}' 122 // CHECK-NEXT: ParmVarDecl{{.*}} a 123 // CHECK-NEXT: ParmVarDecl{{.*}} i 124 // CHECK-NEXT: CXXCtorInitializer{{.*}}A 125 // CHECK-NEXT: Expr 126 // CHECK: CXXCtorInitializer{{.*}}I 127 // CHECK-NEXT: Expr 128 // CHECK: CompoundStmt 129 130 class TestCXXDestructorDecl { 131 ~TestCXXDestructorDecl() { } 132 }; 133 // CHECK: CXXDestructorDecl{{.*}} ~TestCXXDestructorDecl 'void (void) noexcept' 134 // CHECK-NEXT: CompoundStmt 135 136 // Test that the range of a defaulted members is computed correctly. 137 // FIXME: This should include the "= default". 138 class TestMemberRanges { 139 public: 140 TestMemberRanges() = default; 141 TestMemberRanges(const TestMemberRanges &Other) = default; 142 TestMemberRanges(TestMemberRanges &&Other) = default; 143 ~TestMemberRanges() = default; 144 TestMemberRanges &operator=(const TestMemberRanges &Other) = default; 145 TestMemberRanges &operator=(TestMemberRanges &&Other) = default; 146 }; 147 void SomeFunction() { 148 TestMemberRanges A; 149 TestMemberRanges B(A); 150 B = A; 151 A = static_cast<TestMemberRanges &&>(B); 152 TestMemberRanges C(static_cast<TestMemberRanges &&>(A)); 153 } 154 // CHECK: CXXConstructorDecl{{.*}} <line:{{.*}}:3, col:20> 155 // CHECK: CXXConstructorDecl{{.*}} <line:{{.*}}:3, col:49> 156 // CHECK: CXXConstructorDecl{{.*}} <line:{{.*}}:3, col:44> 157 // CHECK: CXXDestructorDecl{{.*}} <line:{{.*}}:3, col:21> 158 // CHECK: CXXMethodDecl{{.*}} <line:{{.*}}:3, col:60> 159 // CHECK: CXXMethodDecl{{.*}} <line:{{.*}}:3, col:55> 160 161 class TestCXXConversionDecl { 162 operator int() { return 0; } 163 }; 164 // CHECK: CXXConversionDecl{{.*}} operator int 'int (void)' 165 // CHECK-NEXT: CompoundStmt 166 167 namespace TestStaticAssertDecl { 168 static_assert(true, "msg"); 169 } 170 // CHECK: NamespaceDecl{{.*}} TestStaticAssertDecl 171 // CHECK-NEXT: StaticAssertDecl{{.*> .*$}} 172 // CHECK-NEXT: CXXBoolLiteralExpr 173 // CHECK-NEXT: StringLiteral 174 175 namespace testFunctionTemplateDecl { 176 class A { }; 177 class B { }; 178 class C { }; 179 class D { }; 180 template<typename T> void TestFunctionTemplate(T) { } 181 182 // implicit instantiation 183 void bar(A a) { TestFunctionTemplate(a); } 184 185 // explicit specialization 186 template<> void TestFunctionTemplate(B); 187 188 // explicit instantiation declaration 189 extern template void TestFunctionTemplate(C); 190 191 // explicit instantiation definition 192 template void TestFunctionTemplate(D); 193 } 194 // CHECK: FunctionTemplateDecl{{.*}} TestFunctionTemplate 195 // CHECK-NEXT: TemplateTypeParmDecl 196 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate 'void (T)' 197 // CHECK-NEXT: ParmVarDecl{{.*}} 'T' 198 // CHECK-NEXT: CompoundStmt 199 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}A 200 // CHECK-NEXT: TemplateArgument 201 // CHECK-NEXT: ParmVarDecl 202 // CHECK-NEXT: CompoundStmt 203 // CHECK-NEXT: Function{{.*}} 'TestFunctionTemplate' {{.*}}B 204 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}C 205 // CHECK-NEXT: TemplateArgument 206 // CHECK-NEXT: ParmVarDecl 207 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}D 208 // CHECK-NEXT: TemplateArgument 209 // CHECK-NEXT: ParmVarDecl 210 // CHECK-NEXT: CompoundStmt 211 // CHECK: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}B 212 // CHECK-NEXT: TemplateArgument 213 // CHECK-NEXT: ParmVarDecl 214 215 namespace testClassTemplateDecl { 216 class A { }; 217 class B { }; 218 class C { }; 219 class D { }; 220 221 template<typename T> class TestClassTemplate { 222 int i; 223 }; 224 225 // implicit instantiation 226 TestClassTemplate<A> a; 227 228 // explicit specialization 229 template<> class TestClassTemplate<B> { 230 int j; 231 }; 232 233 // explicit instantiation declaration 234 extern template class TestClassTemplate<C>; 235 236 // explicit instantiation definition 237 template class TestClassTemplate<D>; 238 239 // partial explicit specialization 240 template<typename T1, typename T2> class TestClassTemplatePartial { 241 int i; 242 }; 243 template<typename T1> class TestClassTemplatePartial<T1, A> { 244 int j; 245 }; 246 } 247 // CHECK: ClassTemplateDecl{{.*}} TestClassTemplate 248 // CHECK-NEXT: TemplateTypeParmDecl 249 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 250 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 251 // CHECK-NEXT: FieldDecl{{.*}} i 252 // CHECK-NEXT: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate 253 // CHECK-NEXT: TemplateArgument{{.*}}A 254 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 255 // CHECK-NEXT: FieldDecl{{.*}} i 256 // CHECK: ClassTemplateSpecialization{{.*}} 'TestClassTemplate' 257 // CHECK-NEXT: ClassTemplateSpecialization{{.*}} 'TestClassTemplate' 258 // CHECK-NEXT: ClassTemplateSpecialization{{.*}} 'TestClassTemplate' 259 260 // CHECK: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate 261 // CHECK-NEXT: TemplateArgument{{.*}}B 262 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 263 // CHECK-NEXT: FieldDecl{{.*}} j 264 265 // CHECK: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate 266 // CHECK-NEXT: TemplateArgument{{.*}}C 267 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 268 // CHECK-NEXT: FieldDecl{{.*}} i 269 270 // CHECK: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate 271 // CHECK-NEXT: TemplateArgument{{.*}}D 272 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 273 // CHECK-NEXT: FieldDecl{{.*}} i 274 275 // CHECK: ClassTemplatePartialSpecializationDecl{{.*}} class TestClassTemplatePartial 276 // CHECK-NEXT: TemplateArgument 277 // CHECK-NEXT: TemplateArgument{{.*}}A 278 // CHECK-NEXT: TemplateTypeParmDecl 279 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplatePartial 280 // CHECK-NEXT: FieldDecl{{.*}} j 281 282 // PR15220 dump instantiation only once 283 namespace testCanonicalTemplate { 284 class A {}; 285 286 template<typename T> void TestFunctionTemplate(T); 287 template<typename T> void TestFunctionTemplate(T); 288 void bar(A a) { TestFunctionTemplate(a); } 289 // CHECK: FunctionTemplateDecl{{.*}} TestFunctionTemplate 290 // CHECK-NEXT: TemplateTypeParmDecl 291 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate 'void (T)' 292 // CHECK-NEXT: ParmVarDecl{{.*}} 'T' 293 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}A 294 // CHECK-NEXT: TemplateArgument 295 // CHECK-NEXT: ParmVarDecl 296 // CHECK: FunctionTemplateDecl{{.*}} TestFunctionTemplate 297 // CHECK-NEXT: TemplateTypeParmDecl 298 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate 'void (T)' 299 // CHECK-NEXT: ParmVarDecl{{.*}} 'T' 300 // CHECK-NEXT: Function{{.*}} 'TestFunctionTemplate' 301 // CHECK-NOT: TemplateArgument 302 303 template<typename T1> class TestClassTemplate { 304 template<typename T2> friend class TestClassTemplate; 305 }; 306 TestClassTemplate<A> a; 307 // CHECK: ClassTemplateDecl{{.*}} TestClassTemplate 308 // CHECK-NEXT: TemplateTypeParmDecl 309 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 310 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 311 // CHECK-NEXT: FriendDecl 312 // CHECK-NEXT: ClassTemplateDecl{{.*}} TestClassTemplate 313 // CHECK-NEXT: TemplateTypeParmDecl 314 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 315 // CHECK-NEXT: ClassTemplateSpecialization{{.*}} 'TestClassTemplate' 316 // CHECK-NEXT: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate 317 // CHECK-NEXT: TemplateArgument{{.*}}A 318 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 319 } 320 321 template <class T> 322 class TestClassScopeFunctionSpecialization { 323 template<class U> void foo(U a) { } 324 template<> void foo<int>(int a) { } 325 }; 326 // CHECK: ClassScopeFunctionSpecializationDecl 327 // CHECK-NEXT: CXXMethod{{.*}} 'foo' 'void (int)' 328 // CHECK-NEXT: TemplateArgument{{.*}} 'int' 329 330 namespace TestTemplateTypeParmDecl { 331 template<typename ... T, class U = int> void foo(); 332 } 333 // CHECK: NamespaceDecl{{.*}} TestTemplateTypeParmDecl 334 // CHECK-NEXT: FunctionTemplateDecl 335 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename ... T 336 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} class U 337 // CHECK-NEXT: TemplateArgument type 'int' 338 339 namespace TestNonTypeTemplateParmDecl { 340 template<int I = 1, int ... J> void foo(); 341 } 342 // CHECK: NamespaceDecl{{.*}} TestNonTypeTemplateParmDecl 343 // CHECK-NEXT: FunctionTemplateDecl 344 // CHECK-NEXT: NonTypeTemplateParmDecl{{.*}} 'int' I 345 // CHECK-NEXT: TemplateArgument expr 346 // CHECK-NEXT: IntegerLiteral{{.*}} 'int' 1 347 // CHECK-NEXT: NonTypeTemplateParmDecl{{.*}} 'int' ... J 348 349 namespace TestTemplateTemplateParmDecl { 350 template<typename T> class A; 351 template <template <typename> class T = A, template <typename> class ... U> void foo(); 352 } 353 // CHECK: NamespaceDecl{{.*}} TestTemplateTemplateParmDecl 354 // CHECK: FunctionTemplateDecl 355 // CHECK-NEXT: TemplateTemplateParmDecl{{.*}} T 356 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename 357 // CHECK-NEXT: TemplateArgument{{.*}} template A 358 // CHECK-NEXT: TemplateTemplateParmDecl{{.*}} ... U 359 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename 360 361 namespace TestTemplateArgument { 362 template<typename> class A { }; 363 template<template<typename> class ...> class B { }; 364 int foo(); 365 366 template<typename> class testType { }; 367 template class testType<int>; 368 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testType 369 // CHECK-NEXT: TemplateArgument{{.*}} type 'int' 370 371 template<int fp(void)> class testDecl { }; 372 template class testDecl<foo>; 373 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testDecl 374 // CHECK-NEXT: TemplateArgument{{.*}} decl 375 // CHECK-NEXT: Function{{.*}}foo 376 377 template class testDecl<nullptr>; 378 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testDecl 379 // CHECK-NEXT: TemplateArgument{{.*}} nullptr 380 381 template<int> class testIntegral { }; 382 template class testIntegral<1>; 383 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testIntegral 384 // CHECK-NEXT: TemplateArgument{{.*}} integral 1 385 386 template<template<typename> class> class testTemplate { }; 387 template class testTemplate<A>; 388 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testTemplate 389 // CHECK-NEXT: TemplateArgument{{.*}} A 390 391 template<template<typename> class ...T> class C { 392 B<T...> testTemplateExpansion; 393 }; 394 // FIXME: Need TemplateSpecializationType dumping to test TemplateExpansion. 395 396 template<int, int = 0> class testExpr; 397 template<int I> class testExpr<I> { }; 398 // CHECK: ClassTemplatePartialSpecializationDecl{{.*}} class testExpr 399 // CHECK-NEXT: TemplateArgument{{.*}} expr 400 // CHECK-NEXT: DeclRefExpr{{.*}}I 401 402 template<int, int ...> class testPack { }; 403 template class testPack<0, 1, 2>; 404 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testPack 405 // CHECK-NEXT: TemplateArgument{{.*}} integral 0 406 // CHECK-NEXT: TemplateArgument{{.*}} pack 407 // CHECK-NEXT: TemplateArgument{{.*}} integral 1 408 // CHECK-NEXT: TemplateArgument{{.*}} integral 2 409 } 410 411 namespace testUsingDecl { 412 int i; 413 } 414 namespace TestUsingDecl { 415 using testUsingDecl::i; 416 } 417 // CHECK: NamespaceDecl{{.*}} TestUsingDecl 418 // CHECK-NEXT: UsingDecl{{.*}} testUsingDecl::i 419 // CHECK-NEXT: UsingShadowDecl{{.*}} Var{{.*}} 'i' 'int' 420 421 namespace testUnresolvedUsing { 422 class A { }; 423 template<class T> class B { 424 public: 425 A a; 426 }; 427 template<class T> class TestUnresolvedUsing : public B<T> { 428 using typename B<T>::a; 429 using B<T>::a; 430 }; 431 } 432 // CHECK: CXXRecordDecl{{.*}} TestUnresolvedUsing 433 // CHECK: UnresolvedUsingTypenameDecl{{.*}} B<T>::a 434 // CHECK: UnresolvedUsingValueDecl{{.*}} B<T>::a 435 436 namespace TestLinkageSpecDecl { 437 extern "C" void test1(); 438 extern "C++" void test2(); 439 } 440 // CHECK: NamespaceDecl{{.*}} TestLinkageSpecDecl 441 // CHECK-NEXT: LinkageSpecDecl{{.*}} C 442 // CHECK-NEXT: FunctionDecl 443 // CHECK-NEXT: LinkageSpecDecl{{.*}} C++ 444 // CHECK-NEXT: FunctionDecl 445 446 class TestAccessSpecDecl { 447 public: 448 private: 449 protected: 450 }; 451 // CHECK: CXXRecordDecl{{.*}} class TestAccessSpecDecl 452 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestAccessSpecDecl 453 // CHECK-NEXT: AccessSpecDecl{{.*}} public 454 // CHECK-NEXT: AccessSpecDecl{{.*}} private 455 // CHECK-NEXT: AccessSpecDecl{{.*}} protected 456 457 template<typename T> class TestFriendDecl { 458 friend int foo(); 459 friend class A; 460 friend T; 461 }; 462 // CHECK: CXXRecord{{.*}} TestFriendDecl 463 // CHECK-NEXT: CXXRecord{{.*}} TestFriendDecl 464 // CHECK-NEXT: FriendDecl 465 // CHECK-NEXT: FunctionDecl{{.*}} foo 466 // CHECK-NEXT: FriendDecl{{.*}} 'class A':'class A' 467 // CHECK-NEXT: FriendDecl{{.*}} 'T' 468 469 namespace TestFileScopeAsmDecl { 470 asm("ret"); 471 } 472 // CHECK: NamespaceDecl{{.*}} TestFileScopeAsmDecl{{$}} 473 // CHECK: FileScopeAsmDecl{{.*> .*$}} 474 // CHECK-NEXT: StringLiteral 475 476 namespace TestFriendDecl2 { 477 void f(); 478 struct S { 479 friend void f(); 480 }; 481 } 482 // CHECK: NamespaceDecl [[TestFriendDecl2:0x.*]] <{{.*}}> {{.*}} TestFriendDecl2 483 // CHECK: |-FunctionDecl [[TestFriendDecl2_f:0x.*]] <{{.*}}> {{.*}} f 'void (void)' 484 // CHECK: `-CXXRecordDecl {{.*}} struct S 485 // CHECK: |-CXXRecordDecl {{.*}} struct S 486 // CHECK: `-FriendDecl 487 // CHECK: `-FunctionDecl {{.*}} parent [[TestFriendDecl2]] prev [[TestFriendDecl2_f]] <{{.*}}> {{.*}} f 'void (void)' 488 489 namespace Comment { 490 extern int Test; 491 /// Something here. 492 extern int Test; 493 extern int Test; 494 } 495 496 // CHECK: VarDecl {{.*}} Test 'int' extern 497 // CHECK-NOT: FullComment 498 // CHECK: VarDecl {{.*}} Test 'int' extern 499 // CHECK: `-FullComment 500 // CHECK: `-ParagraphComment 501 // CHECK: `-TextComment 502 // CHECK: VarDecl {{.*}} Test 'int' extern 503 // CHECK-NOT: FullComment 504
