1 // RUN: %clang_cc1 -std=c++11 -triple x86_64-linux-gnu -fms-extensions -ast-dump -ast-dump-filter Test %s | FileCheck -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 '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 TestEmpty {}; 77 // CHECK: CXXRecordDecl{{.*}} class TestEmpty 78 // CHECK-NEXT: DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init 79 // CHECK-NEXT: DefaultConstructor exists trivial constexpr 80 // CHECK-NEXT: CopyConstructor simple trivial has_const_param 81 // CHECK-NEXT: MoveConstructor exists simple trivial 82 // CHECK-NEXT: CopyAssignment trivial has_const_param 83 // CHECK-NEXT: MoveAssignment exists simple trivial 84 // CHECK-NEXT: Destructor simple irrelevant trivial 85 86 class A { }; 87 class B { }; 88 class TestCXXRecordDecl : virtual A, public B { 89 int i; 90 }; 91 } 92 // CHECK: CXXRecordDecl{{.*}} class TestCXXRecordDecl 93 // CHECK-NEXT: DefinitionData{{$}} 94 // CHECK-NEXT: DefaultConstructor exists non_trivial 95 // CHECK-NEXT: CopyConstructor simple non_trivial has_const_param 96 // CHECK-NEXT: MoveConstructor exists simple non_trivial 97 // CHECK-NEXT: CopyAssignment non_trivial has_const_param 98 // CHECK-NEXT: MoveAssignment exists simple non_trivial 99 // CHECK-NEXT: Destructor simple irrelevant trivial 100 // CHECK-NEXT: virtual private 'testCXXRecordDecl::A' 101 // CHECK-NEXT: public 'testCXXRecordDecl::B' 102 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestCXXRecordDecl 103 // CHECK-NEXT: FieldDecl 104 105 template<class...T> 106 class TestCXXRecordDeclPack : public T... { 107 }; 108 // CHECK: CXXRecordDecl{{.*}} class TestCXXRecordDeclPack 109 // CHECK: public 'T'... 110 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestCXXRecordDeclPack 111 112 thread_local int TestThreadLocalInt; 113 // CHECK: TestThreadLocalInt {{.*}} tls_dynamic 114 115 class testCXXMethodDecl { 116 virtual void TestCXXMethodDeclPure() = 0; 117 void TestCXXMethodDeclDelete() = delete; 118 void TestCXXMethodDeclThrow() throw(); 119 void TestCXXMethodDeclThrowType() throw(int); 120 }; 121 // CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclPure 'void ()' virtual pure 122 // CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclDelete 'void ()' delete 123 // CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclThrow 'void () throw()' 124 // CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclThrowType 'void () throw(int)' 125 126 namespace testCXXConstructorDecl { 127 class A { }; 128 class TestCXXConstructorDecl : public A { 129 int I; 130 TestCXXConstructorDecl(A &a, int i) : A(a), I(i) { } 131 TestCXXConstructorDecl(A &a) : TestCXXConstructorDecl(a, 0) { } 132 }; 133 } 134 // CHECK: CXXConstructorDecl{{.*}} TestCXXConstructorDecl 'void {{.*}}' 135 // CHECK-NEXT: ParmVarDecl{{.*}} a 136 // CHECK-NEXT: ParmVarDecl{{.*}} i 137 // CHECK-NEXT: CXXCtorInitializer{{.*}}A 138 // CHECK-NEXT: Expr 139 // CHECK: CXXCtorInitializer{{.*}}I 140 // CHECK-NEXT: Expr 141 // CHECK: CompoundStmt 142 // CHECK: CXXConstructorDecl{{.*}} TestCXXConstructorDecl 'void {{.*}}' 143 // CHECK-NEXT: ParmVarDecl{{.*}} a 144 // CHECK-NEXT: CXXCtorInitializer{{.*}}TestCXXConstructorDecl 145 // CHECK-NEXT: CXXConstructExpr{{.*}}TestCXXConstructorDecl 146 147 class TestCXXDestructorDecl { 148 ~TestCXXDestructorDecl() { } 149 }; 150 // CHECK: CXXDestructorDecl{{.*}} ~TestCXXDestructorDecl 'void () noexcept' 151 // CHECK-NEXT: CompoundStmt 152 153 // Test that the range of a defaulted members is computed correctly. 154 class TestMemberRanges { 155 public: 156 TestMemberRanges() = default; 157 TestMemberRanges(const TestMemberRanges &Other) = default; 158 TestMemberRanges(TestMemberRanges &&Other) = default; 159 ~TestMemberRanges() = default; 160 TestMemberRanges &operator=(const TestMemberRanges &Other) = default; 161 TestMemberRanges &operator=(TestMemberRanges &&Other) = default; 162 }; 163 void SomeFunction() { 164 TestMemberRanges A; 165 TestMemberRanges B(A); 166 B = A; 167 A = static_cast<TestMemberRanges &&>(B); 168 TestMemberRanges C(static_cast<TestMemberRanges &&>(A)); 169 } 170 // CHECK: CXXConstructorDecl{{.*}} <line:{{.*}}:3, col:30> 171 // CHECK: CXXConstructorDecl{{.*}} <line:{{.*}}:3, col:59> 172 // CHECK: CXXConstructorDecl{{.*}} <line:{{.*}}:3, col:54> 173 // CHECK: CXXDestructorDecl{{.*}} <line:{{.*}}:3, col:31> 174 // CHECK: CXXMethodDecl{{.*}} <line:{{.*}}:3, col:70> 175 // CHECK: CXXMethodDecl{{.*}} <line:{{.*}}:3, col:65> 176 177 class TestCXXConversionDecl { 178 operator int() { return 0; } 179 }; 180 // CHECK: CXXConversionDecl{{.*}} operator int 'int ()' 181 // CHECK-NEXT: CompoundStmt 182 183 namespace TestStaticAssertDecl { 184 static_assert(true, "msg"); 185 } 186 // CHECK: NamespaceDecl{{.*}} TestStaticAssertDecl 187 // CHECK-NEXT: StaticAssertDecl{{.*> .*$}} 188 // CHECK-NEXT: CXXBoolLiteralExpr 189 // CHECK-NEXT: StringLiteral 190 191 namespace testFunctionTemplateDecl { 192 class A { }; 193 class B { }; 194 class C { }; 195 class D { }; 196 template<typename T> void TestFunctionTemplate(T) { } 197 198 // implicit instantiation 199 void bar(A a) { TestFunctionTemplate(a); } 200 201 // explicit specialization 202 template<> void TestFunctionTemplate(B); 203 204 // explicit instantiation declaration 205 extern template void TestFunctionTemplate(C); 206 207 // explicit instantiation definition 208 template void TestFunctionTemplate(D); 209 } 210 // CHECK: FunctionTemplateDecl{{.*}} TestFunctionTemplate 211 // CHECK-NEXT: TemplateTypeParmDecl 212 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate 'void (T)' 213 // CHECK-NEXT: ParmVarDecl{{.*}} 'T' 214 // CHECK-NEXT: CompoundStmt 215 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}A 216 // CHECK-NEXT: TemplateArgument 217 // CHECK-NEXT: ParmVarDecl 218 // CHECK-NEXT: CompoundStmt 219 // CHECK-NEXT: Function{{.*}} 'TestFunctionTemplate' {{.*}}B 220 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}C 221 // CHECK-NEXT: TemplateArgument 222 // CHECK-NEXT: ParmVarDecl 223 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}D 224 // CHECK-NEXT: TemplateArgument 225 // CHECK-NEXT: ParmVarDecl 226 // CHECK-NEXT: CompoundStmt 227 // CHECK: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}B 228 // CHECK-NEXT: TemplateArgument 229 // CHECK-NEXT: ParmVarDecl 230 231 namespace testClassTemplateDecl { 232 class A { }; 233 class B { }; 234 class C { }; 235 class D { }; 236 237 template<typename T> class TestClassTemplate { 238 public: 239 TestClassTemplate(); 240 ~TestClassTemplate(); 241 int j(); 242 int i; 243 }; 244 245 // implicit instantiation 246 TestClassTemplate<A> a; 247 248 // explicit specialization 249 template<> class TestClassTemplate<B> { 250 int j; 251 }; 252 253 // explicit instantiation declaration 254 extern template class TestClassTemplate<C>; 255 256 // explicit instantiation definition 257 template class TestClassTemplate<D>; 258 259 // partial explicit specialization 260 template<typename T1, typename T2> class TestClassTemplatePartial { 261 int i; 262 }; 263 template<typename T1> class TestClassTemplatePartial<T1, A> { 264 int j; 265 }; 266 } 267 // CHECK: ClassTemplateDecl{{.*}} TestClassTemplate 268 // CHECK-NEXT: TemplateTypeParmDecl 269 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 270 // CHECK: CXXRecordDecl{{.*}} class TestClassTemplate 271 // CHECK-NEXT: AccessSpecDecl{{.*}} public 272 // CHECK-NEXT: CXXConstructorDecl{{.*}} <line:{{.*}}:5, col:23> 273 // CHECK-NEXT: CXXDestructorDecl{{.*}} <line:{{.*}}:5, col:24> 274 // CHECK-NEXT: CXXMethodDecl{{.*}} <line:{{.*}}:5, col:11> 275 // CHECK-NEXT: FieldDecl{{.*}} i 276 // CHECK-NEXT: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate 277 // CHECK: TemplateArgument{{.*}}A 278 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 279 // CHECK-NEXT: AccessSpecDecl{{.*}} public 280 // CHECK-NEXT: CXXConstructorDecl{{.*}} <line:{{.*}}:5, col:23> 281 // CHECK-NEXT: CXXDestructorDecl{{.*}} <line:{{.*}}:5, col:24> 282 // CHECK-NEXT: CXXMethodDecl{{.*}} <line:{{.*}}:5, col:11> 283 // CHECK-NEXT: FieldDecl{{.*}} i 284 // CHECK: ClassTemplateSpecialization{{.*}} 'TestClassTemplate' 285 // CHECK-NEXT: ClassTemplateSpecialization{{.*}} 'TestClassTemplate' 286 // CHECK-NEXT: ClassTemplateSpecialization{{.*}} 'TestClassTemplate' 287 288 // CHECK: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate 289 // CHECK-NEXT: DefinitionData 290 // CHECK: TemplateArgument{{.*}}B 291 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 292 // CHECK-NEXT: FieldDecl{{.*}} j 293 294 // CHECK: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate 295 // CHECK: TemplateArgument{{.*}}C 296 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 297 // CHECK-NEXT: AccessSpecDecl{{.*}} public 298 // CHECK-NEXT: CXXConstructorDecl{{.*}} <line:{{.*}}:5, col:23> 299 // CHECK-NEXT: CXXDestructorDecl{{.*}} <line:{{.*}}:5, col:24> 300 // CHECK-NEXT: CXXMethodDecl{{.*}} <line:{{.*}}:5, col:11> 301 // CHECK-NEXT: FieldDecl{{.*}} i 302 303 // CHECK: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate 304 // CHECK: TemplateArgument{{.*}}D 305 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 306 // CHECK-NEXT: AccessSpecDecl{{.*}} public 307 // CHECK-NEXT: CXXConstructorDecl{{.*}} <line:{{.*}}:5, col:23> 308 // CHECK-NEXT: CXXDestructorDecl{{.*}} <line:{{.*}}:5, col:24> 309 // CHECK-NEXT: CXXMethodDecl{{.*}} <line:{{.*}}:5, col:11> 310 // CHECK-NEXT: FieldDecl{{.*}} i 311 312 // CHECK: ClassTemplatePartialSpecializationDecl{{.*}} class TestClassTemplatePartial 313 // CHECK: TemplateArgument 314 // CHECK-NEXT: TemplateArgument{{.*}}A 315 // CHECK-NEXT: TemplateTypeParmDecl 316 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplatePartial 317 // CHECK-NEXT: FieldDecl{{.*}} j 318 319 // PR15220 dump instantiation only once 320 namespace testCanonicalTemplate { 321 class A {}; 322 323 template<typename T> void TestFunctionTemplate(T); 324 template<typename T> void TestFunctionTemplate(T); 325 void bar(A a) { TestFunctionTemplate(a); } 326 // CHECK: FunctionTemplateDecl{{.*}} TestFunctionTemplate 327 // CHECK-NEXT: TemplateTypeParmDecl 328 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate 'void (T)' 329 // CHECK-NEXT: ParmVarDecl{{.*}} 'T' 330 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}A 331 // CHECK-NEXT: TemplateArgument 332 // CHECK-NEXT: ParmVarDecl 333 // CHECK: FunctionTemplateDecl{{.*}} TestFunctionTemplate 334 // CHECK-NEXT: TemplateTypeParmDecl 335 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate 'void (T)' 336 // CHECK-NEXT: ParmVarDecl{{.*}} 'T' 337 // CHECK-NEXT: Function{{.*}} 'TestFunctionTemplate' 338 // CHECK-NOT: TemplateArgument 339 340 template<typename T1> class TestClassTemplate { 341 template<typename T2> friend class TestClassTemplate; 342 }; 343 TestClassTemplate<A> a; 344 // CHECK: ClassTemplateDecl{{.*}} TestClassTemplate 345 // CHECK-NEXT: TemplateTypeParmDecl 346 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 347 // CHECK: CXXRecordDecl{{.*}} class TestClassTemplate 348 // CHECK-NEXT: FriendDecl 349 // CHECK-NEXT: ClassTemplateDecl{{.*}} TestClassTemplate 350 // CHECK-NEXT: TemplateTypeParmDecl 351 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 352 // CHECK-NEXT: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate 353 // CHECK: TemplateArgument{{.*}}A 354 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate 355 } 356 357 template <class T> 358 class TestClassScopeFunctionSpecialization { 359 template<class U> void foo(U a) { } 360 template<> void foo<int>(int a) { } 361 }; 362 // CHECK: ClassScopeFunctionSpecializationDecl 363 // CHECK-NEXT: CXXMethod{{.*}} foo 'void (int)' 364 // CHECK-NEXT: ParmVarDecl 365 // CHECK-NEXT: CompoundStmt 366 // CHECK-NEXT: TemplateArgument{{.*}} 'int' 367 368 namespace TestTemplateTypeParmDecl { 369 template<typename ... T, class U = int> void foo(); 370 } 371 // CHECK: NamespaceDecl{{.*}} TestTemplateTypeParmDecl 372 // CHECK-NEXT: FunctionTemplateDecl 373 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename depth 0 index 0 ... T 374 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} class depth 0 index 1 U 375 // CHECK-NEXT: TemplateArgument type 'int' 376 377 namespace TestNonTypeTemplateParmDecl { 378 template<int I = 1, int ... J> void foo(); 379 } 380 // CHECK: NamespaceDecl{{.*}} TestNonTypeTemplateParmDecl 381 // CHECK-NEXT: FunctionTemplateDecl 382 // CHECK-NEXT: NonTypeTemplateParmDecl{{.*}} 'int' depth 0 index 0 I 383 // CHECK-NEXT: TemplateArgument expr 384 // CHECK-NEXT: ConstantExpr{{.*}} 'int' 385 // CHECK-NEXT: IntegerLiteral{{.*}} 'int' 1 386 // CHECK-NEXT: NonTypeTemplateParmDecl{{.*}} 'int' depth 0 index 1 ... J 387 388 namespace TestTemplateTemplateParmDecl { 389 template<typename T> class A; 390 template <template <typename> class T = A, template <typename> class ... U> void foo(); 391 } 392 // CHECK: NamespaceDecl{{.*}} TestTemplateTemplateParmDecl 393 // CHECK: FunctionTemplateDecl 394 // CHECK-NEXT: TemplateTemplateParmDecl{{.*}} T 395 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename 396 // CHECK-NEXT: TemplateArgument{{.*}} template A 397 // CHECK-NEXT: TemplateTemplateParmDecl{{.*}} ... U 398 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename 399 400 namespace TestTemplateArgument { 401 template<typename> class A { }; 402 template<template<typename> class ...> class B { }; 403 int foo(); 404 405 template<typename> class testType { }; 406 template class testType<int>; 407 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testType 408 // CHECK: TemplateArgument{{.*}} type 'int' 409 410 template<int fp(void)> class testDecl { }; 411 template class testDecl<foo>; 412 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testDecl 413 // CHECK: TemplateArgument{{.*}} decl 414 // CHECK-NEXT: Function{{.*}}foo 415 416 template class testDecl<nullptr>; 417 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testDecl 418 // CHECK: TemplateArgument{{.*}} nullptr 419 420 template<int> class testIntegral { }; 421 template class testIntegral<1>; 422 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testIntegral 423 // CHECK: TemplateArgument{{.*}} integral 1 424 425 template<template<typename> class> class testTemplate { }; 426 template class testTemplate<A>; 427 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testTemplate 428 // CHECK: TemplateArgument{{.*}} A 429 430 template<template<typename> class ...T> class C { 431 B<T...> testTemplateExpansion; 432 }; 433 // FIXME: Need TemplateSpecializationType dumping to test TemplateExpansion. 434 435 template<int, int = 0> class testExpr; 436 template<int I> class testExpr<I> { }; 437 // CHECK: ClassTemplatePartialSpecializationDecl{{.*}} class testExpr 438 // CHECK: TemplateArgument{{.*}} expr 439 // CHECK-NEXT: DeclRefExpr{{.*}}I 440 441 template<int, int ...> class testPack { }; 442 template class testPack<0, 1, 2>; 443 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testPack 444 // CHECK: TemplateArgument{{.*}} integral 0 445 // CHECK-NEXT: TemplateArgument{{.*}} pack 446 // CHECK-NEXT: TemplateArgument{{.*}} integral 1 447 // CHECK-NEXT: TemplateArgument{{.*}} integral 2 448 } 449 450 namespace testUsingDecl { 451 int i; 452 } 453 namespace TestUsingDecl { 454 using testUsingDecl::i; 455 } 456 // CHECK: NamespaceDecl{{.*}} TestUsingDecl 457 // CHECK-NEXT: UsingDecl{{.*}} testUsingDecl::i 458 // CHECK-NEXT: UsingShadowDecl{{.*}} Var{{.*}} 'i' 'int' 459 460 namespace testUnresolvedUsing { 461 class A { }; 462 template<class T> class B { 463 public: 464 A a; 465 }; 466 template<class T> class TestUnresolvedUsing : public B<T> { 467 using typename B<T>::a; 468 using B<T>::a; 469 }; 470 } 471 // CHECK: CXXRecordDecl{{.*}} TestUnresolvedUsing 472 // CHECK: UnresolvedUsingTypenameDecl{{.*}} B<T>::a 473 // CHECK: UnresolvedUsingValueDecl{{.*}} B<T>::a 474 475 namespace TestLinkageSpecDecl { 476 extern "C" void test1(); 477 extern "C++" void test2(); 478 } 479 // CHECK: NamespaceDecl{{.*}} TestLinkageSpecDecl 480 // CHECK-NEXT: LinkageSpecDecl{{.*}} C 481 // CHECK-NEXT: FunctionDecl 482 // CHECK-NEXT: LinkageSpecDecl{{.*}} C++ 483 // CHECK-NEXT: FunctionDecl 484 485 class TestAccessSpecDecl { 486 public: 487 private: 488 protected: 489 }; 490 // CHECK: CXXRecordDecl{{.*}} class TestAccessSpecDecl 491 // CHECK: CXXRecordDecl{{.*}} class TestAccessSpecDecl 492 // CHECK-NEXT: AccessSpecDecl{{.*}} public 493 // CHECK-NEXT: AccessSpecDecl{{.*}} private 494 // CHECK-NEXT: AccessSpecDecl{{.*}} protected 495 496 template<typename T> class TestFriendDecl { 497 friend int foo(); 498 friend class A; 499 friend T; 500 }; 501 // CHECK: CXXRecord{{.*}} TestFriendDecl 502 // CHECK: CXXRecord{{.*}} TestFriendDecl 503 // CHECK-NEXT: FriendDecl 504 // CHECK-NEXT: FunctionDecl{{.*}} foo 505 // CHECK-NEXT: FriendDecl{{.*}} 'class A':'A' 506 // CHECK-NEXT: FriendDecl{{.*}} 'T' 507 508 namespace TestFileScopeAsmDecl { 509 asm("ret"); 510 } 511 // CHECK: NamespaceDecl{{.*}} TestFileScopeAsmDecl{{$}} 512 // CHECK: FileScopeAsmDecl{{.*> .*$}} 513 // CHECK-NEXT: StringLiteral 514 515 namespace TestFriendDecl2 { 516 void f(); 517 struct S { 518 friend void f(); 519 }; 520 } 521 // CHECK: NamespaceDecl [[TestFriendDecl2:0x.*]] <{{.*}}> {{.*}} TestFriendDecl2 522 // CHECK: |-FunctionDecl [[TestFriendDecl2_f:0x.*]] <{{.*}}> {{.*}} f 'void ()' 523 // CHECK: `-CXXRecordDecl {{.*}} struct S 524 // CHECK: |-CXXRecordDecl {{.*}} struct S 525 // CHECK: `-FriendDecl 526 // CHECK: `-FunctionDecl {{.*}} parent [[TestFriendDecl2]] prev [[TestFriendDecl2_f]] <{{.*}}> {{.*}} f 'void ()' 527 528 namespace Comment { 529 extern int Test; 530 /// Something here. 531 extern int Test; 532 extern int Test; 533 } 534 535 // CHECK: VarDecl {{.*}} Test 'int' extern 536 // CHECK-NOT: FullComment 537 // CHECK: VarDecl {{.*}} Test 'int' extern 538 // CHECK: `-FullComment 539 // CHECK: `-ParagraphComment 540 // CHECK: `-TextComment 541 // CHECK: VarDecl {{.*}} Test 'int' extern 542 // CHECK-NOT: FullComment 543