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 class TestCXXConversionDecl { 137 operator int() { return 0; } 138 }; 139 // CHECK: CXXConversionDecl{{.*}} operator int 'int (void)' 140 // CHECK-NEXT: CompoundStmt 141 142 namespace TestStaticAssertDecl { 143 static_assert(true, "msg"); 144 } 145 // CHECK: NamespaceDecl{{.*}} TestStaticAssertDecl 146 // CHECK-NEXT: StaticAssertDecl{{.*>$}} 147 // CHECK-NEXT: CXXBoolLiteralExpr 148 // CHECK-NEXT: StringLiteral 149 150 namespace testFunctionTemplateDecl { 151 class A { }; 152 class B { }; 153 class C { }; 154 class D { }; 155 template<typename T> void TestFunctionTemplate(T) { } 156 157 // implicit instantiation 158 void bar(A a) { TestFunctionTemplate(a); } 159 160 // explicit specialization 161 template<> void TestFunctionTemplate(B); 162 163 // explicit instantiation declaration 164 extern template void TestFunctionTemplate(C); 165 166 // explicit instantiation definition 167 template void TestFunctionTemplate(D); 168 } 169 // CHECK: FunctionTemplateDecl{{.*}} TestFunctionTemplate 170 // CHECK-NEXT: TemplateTypeParmDecl 171 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate 'void (T)' 172 // CHECK-NEXT: ParmVarDecl{{.*}} 'T' 173 // CHECK-NEXT: CompoundStmt 174 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}A 175 // CHECK-NEXT: TemplateArgument 176 // CHECK-NEXT: ParmVarDecl 177 // CHECK-NEXT: CompoundStmt 178 // CHECK-NEXT: Function{{.*}} 'TestFunctionTemplate' {{.*}}B 179 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}C 180 // CHECK-NEXT: TemplateArgument 181 // CHECK-NEXT: ParmVarDecl 182 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}D 183 // CHECK-NEXT: TemplateArgument 184 // CHECK-NEXT: ParmVarDecl 185 // CHECK-NEXT: CompoundStmt 186 // CHECK: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}B 187 // CHECK-NEXT: TemplateArgument 188 // CHECK-NEXT: ParmVarDecl 189 190 namespace testClassTemplateDecl { 191 class A { }; 192 class B { }; 193 class C { }; 194 class D { }; 195 196 template<typename T> class TestClassTemplate { 197 int i; 198 }; 199 200 // implicit instantiation 201 TestClassTemplate<A> a; 202 203 // explicit specialization 204 template<> class TestClassTemplate<B> { 205 int j; 206 }; 207 208 // explicit instantiation declaration 209 extern template class TestClassTemplate<C>; 210 211 // explicit instantiation definition 212 template class TestClassTemplate<D>; 213 214 // partial explicit specialization 215 template<typename T1, typename T2> class TestClassTemplatePartial { 216 int i; 217 }; 218 template<typename T1> class TestClassTemplatePartial<T1, A> { 219 int j; 220 }; 221 } 222 // CHECK: ClassTemplateDecl{{.*}} TestClassTemplate 223 // CHECK-NEXT: TemplateTypeParmDecl 224 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 225 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 226 // CHECK-NEXT: FieldDecl{{.*}} i 227 // CHECK-NEXT: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate 228 // CHECK-NEXT: TemplateArgument{{.*}}A 229 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 230 // CHECK-NEXT: FieldDecl{{.*}} i 231 // CHECK: ClassTemplateSpecialization{{.*}} 'TestClassTemplate' 232 // CHECK-NEXT: ClassTemplateSpecialization{{.*}} 'TestClassTemplate' 233 // CHECK-NEXT: ClassTemplateSpecialization{{.*}} 'TestClassTemplate' 234 235 // CHECK: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate 236 // CHECK-NEXT: TemplateArgument{{.*}}B 237 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 238 // CHECK-NEXT: FieldDecl{{.*}} j 239 240 // CHECK: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate 241 // CHECK-NEXT: TemplateArgument{{.*}}C 242 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 243 // CHECK-NEXT: FieldDecl{{.*}} i 244 245 // CHECK: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate 246 // CHECK-NEXT: TemplateArgument{{.*}}D 247 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 248 // CHECK-NEXT: FieldDecl{{.*}} i 249 250 // CHECK: ClassTemplatePartialSpecializationDecl{{.*}} class TestClassTemplatePartial 251 // CHECK-NEXT: TemplateArgument 252 // CHECK-NEXT: TemplateArgument{{.*}}A 253 // CHECK-NEXT: TemplateTypeParmDecl 254 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplatePartial 255 // CHECK-NEXT: FieldDecl{{.*}} j 256 257 // PR15220 dump instantiation only once 258 namespace testCanonicalTemplate { 259 class A {}; 260 261 template<typename T> void TestFunctionTemplate(T); 262 template<typename T> void TestFunctionTemplate(T); 263 void bar(A a) { TestFunctionTemplate(a); } 264 // CHECK: FunctionTemplateDecl{{.*}} TestFunctionTemplate 265 // CHECK-NEXT: TemplateTypeParmDecl 266 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate 'void (T)' 267 // CHECK-NEXT: ParmVarDecl{{.*}} 'T' 268 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}A 269 // CHECK-NEXT: TemplateArgument 270 // CHECK-NEXT: ParmVarDecl 271 // CHECK: FunctionTemplateDecl{{.*}} TestFunctionTemplate 272 // CHECK-NEXT: TemplateTypeParmDecl 273 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate 'void (T)' 274 // CHECK-NEXT: ParmVarDecl{{.*}} 'T' 275 // CHECK-NEXT: Function{{.*}} 'TestFunctionTemplate' 276 // CHECK-NEXT-NOT: TemplateArgument 277 278 template<typename T1> class TestClassTemplate { 279 template<typename T2> friend class TestClassTemplate; 280 }; 281 TestClassTemplate<A> a; 282 // CHECK: ClassTemplateDecl{{.*}} TestClassTemplate 283 // CHECK-NEXT: TemplateTypeParmDecl 284 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 285 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 286 // CHECK-NEXT: FriendDecl 287 // CHECK-NEXT: ClassTemplateDecl{{.*}} TestClassTemplate 288 // CHECK-NEXT: TemplateTypeParmDecl 289 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 290 // CHECK-NEXT: ClassTemplateSpecialization{{.*}} 'TestClassTemplate' 291 // CHECK-NEXT: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate 292 // CHECK-NEXT: TemplateArgument{{.*}}A 293 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 294 } 295 296 template <class T> 297 class TestClassScopeFunctionSpecialization { 298 template<class U> void foo(U a) { } 299 template<> void foo<int>(int a) { } 300 }; 301 // CHECK: ClassScopeFunctionSpecializationDecl 302 // CHECK-NEXT: CXXMethod{{.*}} 'foo' 'void (int)' 303 // CHECK-NEXT: TemplateArgument{{.*}} 'int' 304 305 namespace TestTemplateTypeParmDecl { 306 template<typename ... T, class U = int> void foo(); 307 } 308 // CHECK: NamespaceDecl{{.*}} TestTemplateTypeParmDecl 309 // CHECK-NEXT: FunctionTemplateDecl 310 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename ... T 311 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} class U 'int' 312 313 namespace TestNonTypeTemplateParmDecl { 314 template<int I = 1, int ... J> void foo(); 315 } 316 // CHECK: NamespaceDecl{{.*}} TestNonTypeTemplateParmDecl 317 // CHECK-NEXT: FunctionTemplateDecl 318 // CHECK-NEXT: NonTypeTemplateParmDecl{{.*}} 'int' I 319 // CHECK-NEXT: IntegerLiteral{{.*}} 'int' 1 320 // CHECK-NEXT: NonTypeTemplateParmDecl{{.*}} 'int' ... J 321 322 namespace TestTemplateTemplateParmDecl { 323 template<typename T> class A; 324 template <template <typename> class T = A, template <typename> class ... U> void foo(); 325 } 326 // CHECK: NamespaceDecl{{.*}} TestTemplateTemplateParmDecl 327 // CHECK: FunctionTemplateDecl 328 // CHECK-NEXT: TemplateTemplateParmDecl{{.*}} T 329 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename 330 // CHECK-NEXT: TemplateArgument{{.*}} template A 331 // CHECK-NEXT: TemplateTemplateParmDecl{{.*}} ... U 332 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename 333 334 namespace TestTemplateArgument { 335 template<typename> class A { }; 336 template<template<typename> class ...> class B { }; 337 int foo(); 338 339 template<typename> class testType { }; 340 template class testType<int>; 341 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testType 342 // CHECK-NEXT: TemplateArgument{{.*}} type 'int' 343 344 template<int fp(void)> class testDecl { }; 345 template class testDecl<foo>; 346 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testDecl 347 // CHECK-NEXT: TemplateArgument{{.*}} decl 348 // CHECK-NEXT: Function{{.*}}foo 349 350 template class testDecl<nullptr>; 351 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testDecl 352 // CHECK-NEXT: TemplateArgument{{.*}} nullptr 353 354 template<int> class testIntegral { }; 355 template class testIntegral<1>; 356 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testIntegral 357 // CHECK-NEXT: TemplateArgument{{.*}} integral 1 358 359 template<template<typename> class> class testTemplate { }; 360 template class testTemplate<A>; 361 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testTemplate 362 // CHECK-NEXT: TemplateArgument{{.*}} A 363 364 template<template<typename> class ...T> class C { 365 B<T...> testTemplateExpansion; 366 }; 367 // FIXME: Need TemplateSpecializationType dumping to test TemplateExpansion. 368 369 template<int, int = 0> class testExpr; 370 template<int I> class testExpr<I> { }; 371 // CHECK: ClassTemplatePartialSpecializationDecl{{.*}} class testExpr 372 // CHECK-NEXT: TemplateArgument{{.*}} expr 373 // CHECK-NEXT: DeclRefExpr{{.*}}I 374 375 template<int, int ...> class testPack { }; 376 template class testPack<0, 1, 2>; 377 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testPack 378 // CHECK-NEXT: TemplateArgument{{.*}} integral 0 379 // CHECK-NEXT: TemplateArgument{{.*}} pack 380 // CHECK-NEXT: TemplateArgument{{.*}} integral 1 381 // CHECK-NEXT: TemplateArgument{{.*}} integral 2 382 } 383 384 namespace testUsingDecl { 385 int i; 386 } 387 namespace TestUsingDecl { 388 using testUsingDecl::i; 389 } 390 // CHECK: NamespaceDecl{{.*}} TestUsingDecl 391 // CHECK-NEXT: UsingDecl{{.*}} testUsingDecl::i 392 // CHECK-NEXT: UsingShadowDecl{{.*}} Var{{.*}} 'i' 'int' 393 394 namespace testUnresolvedUsing { 395 class A { }; 396 template<class T> class B { 397 public: 398 A a; 399 }; 400 template<class T> class TestUnresolvedUsing : public B<T> { 401 using typename B<T>::a; 402 using B<T>::a; 403 }; 404 } 405 // CHECK: CXXRecordDecl{{.*}} TestUnresolvedUsing 406 // CHECK: UnresolvedUsingTypenameDecl{{.*}} B<T>::a 407 // CHECK: UnresolvedUsingValueDecl{{.*}} B<T>::a 408 409 namespace TestLinkageSpecDecl { 410 extern "C" void test1(); 411 extern "C++" void test2(); 412 } 413 // CHECK: NamespaceDecl{{.*}} TestLinkageSpecDecl 414 // CHECK-NEXT: LinkageSpecDecl{{.*}} C 415 // CHECK-NEXT: FunctionDecl 416 // CHECK-NEXT: LinkageSpecDecl{{.*}} C++ 417 // CHECK-NEXT: FunctionDecl 418 419 class TestAccessSpecDecl { 420 public: 421 private: 422 protected: 423 }; 424 // CHECK: CXXRecordDecl{{.*}} class TestAccessSpecDecl 425 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestAccessSpecDecl 426 // CHECK-NEXT: AccessSpecDecl{{.*}} public 427 // CHECK-NEXT: AccessSpecDecl{{.*}} private 428 // CHECK-NEXT: AccessSpecDecl{{.*}} protected 429 430 template<typename T> class TestFriendDecl { 431 friend int foo(); 432 friend class A; 433 friend T; 434 }; 435 // CHECK: CXXRecord{{.*}} TestFriendDecl 436 // CHECK-NEXT: CXXRecord{{.*}} TestFriendDecl 437 // CHECK-NEXT: FriendDecl 438 // CHECK-NEXT: FunctionDecl{{.*}} foo 439 // CHECK-NEXT: FriendDecl{{.*}} 'class A':'class A' 440 // CHECK-NEXT: FriendDecl{{.*}} 'T' 441 442 namespace TestFileScopeAsmDecl { 443 asm("ret"); 444 } 445 // CHECK: NamespaceDecl{{.*}} TestFileScopeAsmDecl{{$}} 446 // CHECK: FileScopeAsmDecl{{.*>$}} 447 // CHECK-NEXT: StringLiteral 448 449 namespace TestFriendDecl2 { 450 void f(); 451 struct S { 452 friend void f(); 453 }; 454 } 455 // CHECK: NamespaceDecl [[TestFriendDecl2:0x.*]] <{{.*}}> TestFriendDecl2 456 // CHECK: |-FunctionDecl [[TestFriendDecl2_f:0x.*]] <{{.*}}> f 'void (void)' 457 // CHECK: `-CXXRecordDecl {{.*}} struct S 458 // CHECK: |-CXXRecordDecl {{.*}} struct S 459 // CHECK: `-FriendDecl 460 // CHECK: `-FunctionDecl {{.*}} parent [[TestFriendDecl2]] prev [[TestFriendDecl2_f]] <{{.*}}> f 'void (void)' 461 462 namespace Comment { 463 extern int Test; 464 /// Something here. 465 extern int Test; 466 extern int Test; 467 } 468 469 // CHECK: VarDecl {{.*}} Test 'int' extern 470 // CHECK-NOT: FullComment 471 // CHECK: VarDecl {{.*}} Test 'int' extern 472 // CHECK: `-FullComment 473 // CHECK: `-ParagraphComment 474 // CHECK: `-TextComment 475 // CHECK: VarDecl {{.*}} Test 'int' extern 476 // CHECK-NOT: FullComment 477
