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