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