test/Misc/ast-dump-decl.cpp

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