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 3class testEnumDecl { 4 enum class TestEnumDeclScoped; 5 enum TestEnumDeclFixed : int; 6}; 7// CHECK: EnumDecl{{.*}} class TestEnumDeclScoped 'int' 8// CHECK: EnumDecl{{.*}} TestEnumDeclFixed 'int' 9 10class testFieldDecl { 11 int TestFieldDeclInit = 0; 12}; 13// CHECK: FieldDecl{{.*}} TestFieldDeclInit 'int' 14// CHECK-NEXT: IntegerLiteral 15 16namespace testVarDeclNRVO { 17 class A { }; 18 A foo() { 19 A TestVarDeclNRVO; 20 return TestVarDeclNRVO; 21 } 22} 23// CHECK: VarDecl{{.*}} TestVarDeclNRVO 'class testVarDeclNRVO::A' nrvo 24 25void testParmVarDeclInit(int TestParmVarDeclInit = 0); 26// CHECK: ParmVarDecl{{.*}} TestParmVarDeclInit 'int' 27// CHECK-NEXT: IntegerLiteral{{.*}} 28 29namespace TestNamespaceDecl { 30 int i; 31} 32// CHECK: NamespaceDecl{{.*}} TestNamespaceDecl 33// CHECK-NEXT: VarDecl 34 35namespace TestNamespaceDecl { 36 int j; 37} 38// CHECK: NamespaceDecl{{.*}} TestNamespaceDecl 39// CHECK-NEXT: original Namespace 40// CHECK-NEXT: VarDecl 41 42inline namespace TestNamespaceDeclInline { 43} 44// CHECK: NamespaceDecl{{.*}} TestNamespaceDeclInline inline 45 46namespace testUsingDirectiveDecl { 47 namespace A { 48 } 49} 50namespace TestUsingDirectiveDecl { 51 using namespace testUsingDirectiveDecl::A; 52} 53// CHECK: NamespaceDecl{{.*}} TestUsingDirectiveDecl 54// CHECK-NEXT: UsingDirectiveDecl{{.*}} Namespace{{.*}} 'A' 55 56namespace testNamespaceAlias { 57 namespace A { 58 } 59} 60namespace TestNamespaceAlias = testNamespaceAlias::A; 61// CHECK: NamespaceAliasDecl{{.*}} TestNamespaceAlias 62// CHECK-NEXT: Namespace{{.*}} 'A' 63 64using TestTypeAliasDecl = int; 65// CHECK: TypeAliasDecl{{.*}} TestTypeAliasDecl 'int' 66 67namespace 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 75namespace 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 88template<class...T> 89class TestCXXRecordDeclPack : public T... { 90}; 91// CHECK: CXXRecordDecl{{.*}} class TestCXXRecordDeclPack 92// CHECK-NEXT: public 'T'... 93// CHECK-NEXT: CXXRecordDecl{{.*}} class TestCXXRecordDeclPack 94 95thread_local int TestThreadLocalInt; 96// CHECK: TestThreadLocalInt {{.*}} tls_dynamic 97 98__module_private__ class TestCXXRecordDeclPrivate; 99// CHECK: CXXRecordDecl{{.*}} class TestCXXRecordDeclPrivate __module_private__ 100 101class 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 114namespace 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 130class 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". 138class TestMemberRanges { 139public: 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}; 147void 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 161class TestCXXConversionDecl { 162 operator int() { return 0; } 163}; 164// CHECK: CXXConversionDecl{{.*}} operator int 'int (void)' 165// CHECK-NEXT: CompoundStmt 166 167namespace TestStaticAssertDecl { 168 static_assert(true, "msg"); 169} 170// CHECK: NamespaceDecl{{.*}} TestStaticAssertDecl 171// CHECK-NEXT: StaticAssertDecl{{.*> .*$}} 172// CHECK-NEXT: CXXBoolLiteralExpr 173// CHECK-NEXT: StringLiteral 174 175namespace 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 215namespace 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 283namespace 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 321template <class T> 322class 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 330namespace 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 339namespace 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 349namespace 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 361namespace 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 411namespace testUsingDecl { 412 int i; 413} 414namespace TestUsingDecl { 415 using testUsingDecl::i; 416} 417// CHECK: NamespaceDecl{{.*}} TestUsingDecl 418// CHECK-NEXT: UsingDecl{{.*}} testUsingDecl::i 419// CHECK-NEXT: UsingShadowDecl{{.*}} Var{{.*}} 'i' 'int' 420 421namespace 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 436namespace 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 446class TestAccessSpecDecl { 447public: 448private: 449protected: 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 457template<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 469namespace TestFileScopeAsmDecl { 470 asm("ret"); 471} 472// CHECK: NamespaceDecl{{.*}} TestFileScopeAsmDecl{{$}} 473// CHECK: FileScopeAsmDecl{{.*> .*$}} 474// CHECK-NEXT: StringLiteral 475 476namespace 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 489namespace 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