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   template<typename T = int> struct TestTemplateDefaultType;
268   template<typename T> struct TestTemplateDefaultType { };
269 
270   template<int I = 42> struct TestTemplateDefaultNonType;
271   template<int I> struct TestTemplateDefaultNonType { };
272 
273   template<template<typename> class TT = TestClassTemplate> struct TestTemplateTemplateDefaultType;
274   template<template<typename> class TT> struct TestTemplateTemplateDefaultType { };
275 }
276 // CHECK:      ClassTemplateDecl{{.*}} TestClassTemplate
277 // CHECK-NEXT:   TemplateTypeParmDecl
278 // CHECK-NEXT:   CXXRecordDecl{{.*}} class TestClassTemplate
279 // CHECK:          CXXRecordDecl{{.*}} class TestClassTemplate
280 // CHECK-NEXT:     AccessSpecDecl{{.*}} public
281 // CHECK-NEXT:     CXXConstructorDecl{{.*}} <line:{{.*}}:5, col:23>
282 // CHECK-NEXT:     CXXDestructorDecl{{.*}} <line:{{.*}}:5, col:24>
283 // CHECK-NEXT:     CXXMethodDecl{{.*}} <line:{{.*}}:5, col:11>
284 // CHECK-NEXT:     FieldDecl{{.*}} i
285 // CHECK-NEXT:   ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate
286 // CHECK:          TemplateArgument{{.*}}A
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 // CHECK:        ClassTemplateSpecialization{{.*}} 'TestClassTemplate'
294 // CHECK-NEXT:   ClassTemplateSpecialization{{.*}} 'TestClassTemplate'
295 // CHECK-NEXT:   ClassTemplateSpecialization{{.*}} 'TestClassTemplate'
296 
297 // CHECK:      ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate
298 // CHECK-NEXT:   DefinitionData
299 // CHECK:        TemplateArgument{{.*}}B
300 // CHECK-NEXT:   CXXRecordDecl{{.*}} class TestClassTemplate
301 // CHECK-NEXT:   FieldDecl{{.*}} j
302 
303 // CHECK:      ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate
304 // CHECK:        TemplateArgument{{.*}}C
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:      ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate
313 // CHECK:        TemplateArgument{{.*}}D
314 // CHECK-NEXT:   CXXRecordDecl{{.*}} class TestClassTemplate
315 // CHECK-NEXT:   AccessSpecDecl{{.*}} public
316 // CHECK-NEXT:   CXXConstructorDecl{{.*}} <line:{{.*}}:5, col:23>
317 // CHECK-NEXT:   CXXDestructorDecl{{.*}} <line:{{.*}}:5, col:24>
318 // CHECK-NEXT:   CXXMethodDecl{{.*}} <line:{{.*}}:5, col:11>
319 // CHECK-NEXT:   FieldDecl{{.*}} i
320 
321 // CHECK:      ClassTemplatePartialSpecializationDecl{{.*}} class TestClassTemplatePartial
322 // CHECK:        TemplateArgument
323 // CHECK-NEXT:   TemplateArgument{{.*}}A
324 // CHECK-NEXT:   TemplateTypeParmDecl
325 // CHECK-NEXT:   CXXRecordDecl{{.*}} class TestClassTemplatePartial
326 // CHECK-NEXT:   FieldDecl{{.*}} j
327 
328 // CHECK:      ClassTemplateDecl 0x{{[^ ]*}} prev 0x{{[^ ]*}} {{.*}} TestTemplateDefaultType
329 // CHECK-NEXT:   TemplateTypeParmDecl
330 // CHECK-NEXT:     TemplateArgument type 'int'
331 // CHECK-NEXT:       inherited from TemplateTypeParm 0x{{[^ ]*}} 'T'
332 
333 // CHECK:      ClassTemplateDecl 0x{{[^ ]*}} prev 0x{{[^ ]*}} {{.*}} TestTemplateDefaultNonType
334 // CHECK-NEXT:   NonTypeTemplateParmDecl
335 // CHECK-NEXT:     TemplateArgument expr
336 // CHECK-NEXT:       inherited from NonTypeTemplateParm 0x{{[^ ]*}} 'I' 'int'
337 // CHECK-NEXT:       ConstantExpr
338 // CHECK-NEXT:         IntegerLiteral
339 
340 // CHECK:      ClassTemplateDecl 0x{{[^ ]*}} prev 0x{{[^ ]*}} {{.*}} TestTemplateTemplateDefaultType
341 // CHECK-NEXT:   TemplateTemplateParmDecl
342 // CHECK-NEXT:     TemplateTypeParmDecl
343 // CHECK-NEXT:     TemplateArgument
344 // CHECK-NEXT:       inherited from TemplateTemplateParm 0x{{[^ ]*}} 'TT'
345 
346 // PR15220 dump instantiation only once
347 namespace testCanonicalTemplate {
348   class A {};
349 
350   template<typename T> void TestFunctionTemplate(T);
351   template<typename T> void TestFunctionTemplate(T);
352   void bar(A a) { TestFunctionTemplate(a); }
353   // CHECK:      FunctionTemplateDecl{{.*}} TestFunctionTemplate
354   // CHECK-NEXT:   TemplateTypeParmDecl
355   // CHECK-NEXT:   FunctionDecl{{.*}} TestFunctionTemplate 'void (T)'
356   // CHECK-NEXT:     ParmVarDecl{{.*}} 'T'
357   // CHECK-NEXT:   FunctionDecl{{.*}} TestFunctionTemplate {{.*}}A
358   // CHECK-NEXT:     TemplateArgument
359   // CHECK-NEXT:     ParmVarDecl
360   // CHECK:      FunctionTemplateDecl{{.*}} TestFunctionTemplate
361   // CHECK-NEXT:   TemplateTypeParmDecl
362   // CHECK-NEXT:   FunctionDecl{{.*}} TestFunctionTemplate 'void (T)'
363   // CHECK-NEXT:     ParmVarDecl{{.*}} 'T'
364   // CHECK-NEXT:   Function{{.*}} 'TestFunctionTemplate'
365   // CHECK-NOT:      TemplateArgument
366 
367   template<typename T1> class TestClassTemplate {
368     template<typename T2> friend class TestClassTemplate;
369   };
370   TestClassTemplate<A> a;
371   // CHECK:      ClassTemplateDecl{{.*}} TestClassTemplate
372   // CHECK-NEXT:   TemplateTypeParmDecl
373   // CHECK-NEXT:   CXXRecordDecl{{.*}} class TestClassTemplate
374   // CHECK:          CXXRecordDecl{{.*}} class TestClassTemplate
375   // CHECK-NEXT:     FriendDecl
376   // CHECK-NEXT:       ClassTemplateDecl{{.*}} TestClassTemplate
377   // CHECK-NEXT:         TemplateTypeParmDecl
378   // CHECK-NEXT:         CXXRecordDecl{{.*}} class TestClassTemplate
379   // CHECK-NEXT:   ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate
380   // CHECK:          TemplateArgument{{.*}}A
381   // CHECK-NEXT:     CXXRecordDecl{{.*}} class TestClassTemplate
382 }
383 
384 template <class T>
385 class TestClassScopeFunctionSpecialization {
386   template<class U> void foo(U a) { }
387   template<> void foo<int>(int a) { }
388 };
389 // CHECK:      ClassScopeFunctionSpecializationDecl
390 // CHECK-NEXT:   CXXMethod{{.*}} foo 'void (int)'
391 // CHECK-NEXT:     ParmVarDecl
392 // CHECK-NEXT:     CompoundStmt
393 // CHECK-NEXT:   TemplateArgument{{.*}} 'int'
394 
395 namespace TestTemplateTypeParmDecl {
396   template<typename ... T, class U = int> void foo();
397 }
398 // CHECK:      NamespaceDecl{{.*}} TestTemplateTypeParmDecl
399 // CHECK-NEXT:   FunctionTemplateDecl
400 // CHECK-NEXT:     TemplateTypeParmDecl{{.*}} typename depth 0 index 0 ... T
401 // CHECK-NEXT:     TemplateTypeParmDecl{{.*}} class depth 0 index 1 U
402 // CHECK-NEXT:       TemplateArgument type 'int'
403 
404 namespace TestNonTypeTemplateParmDecl {
405   template<int I = 1, int ... J> void foo();
406 }
407 // CHECK:      NamespaceDecl{{.*}} TestNonTypeTemplateParmDecl
408 // CHECK-NEXT:   FunctionTemplateDecl
409 // CHECK-NEXT:     NonTypeTemplateParmDecl{{.*}} 'int' depth 0 index 0 I
410 // CHECK-NEXT:       TemplateArgument expr
411 // CHECK-NEXT:         ConstantExpr{{.*}} 'int'
412 // CHECK-NEXT:           IntegerLiteral{{.*}} 'int' 1
413 // CHECK-NEXT:     NonTypeTemplateParmDecl{{.*}} 'int' depth 0 index 1 ... J
414 
415 namespace TestTemplateTemplateParmDecl {
416   template<typename T> class A;
417   template <template <typename> class T = A, template <typename> class ... U> void foo();
418 }
419 // CHECK:      NamespaceDecl{{.*}} TestTemplateTemplateParmDecl
420 // CHECK:        FunctionTemplateDecl
421 // CHECK-NEXT:     TemplateTemplateParmDecl{{.*}} T
422 // CHECK-NEXT:       TemplateTypeParmDecl{{.*}} typename
423 // CHECK-NEXT:       TemplateArgument{{.*}} template A
424 // CHECK-NEXT:     TemplateTemplateParmDecl{{.*}} ... U
425 // CHECK-NEXT:       TemplateTypeParmDecl{{.*}} typename
426 
427 namespace TestTemplateArgument {
428   template<typename> class A { };
429   template<template<typename> class ...> class B { };
430   int foo();
431 
432   template<typename> class testType { };
433   template class testType<int>;
434   // CHECK:      ClassTemplateSpecializationDecl{{.*}} class testType
435   // CHECK:        TemplateArgument{{.*}} type 'int'
436 
437   template<int fp(void)> class testDecl { };
438   template class testDecl<foo>;
439   // CHECK:      ClassTemplateSpecializationDecl{{.*}} class testDecl
440   // CHECK:        TemplateArgument{{.*}} decl
441   // CHECK-NEXT:     Function{{.*}}foo
442 
443   template class testDecl<nullptr>;
444   // CHECK:      ClassTemplateSpecializationDecl{{.*}} class testDecl
445   // CHECK:        TemplateArgument{{.*}} nullptr
446 
447   template<int> class testIntegral { };
448   template class testIntegral<1>;
449   // CHECK:      ClassTemplateSpecializationDecl{{.*}} class testIntegral
450   // CHECK:        TemplateArgument{{.*}} integral 1
451 
452   template<template<typename> class> class testTemplate { };
453   template class testTemplate<A>;
454   // CHECK:      ClassTemplateSpecializationDecl{{.*}} class testTemplate
455   // CHECK:        TemplateArgument{{.*}} A
456 
457   template<template<typename> class ...T> class C {
458     B<T...> testTemplateExpansion;
459   };
460   // FIXME: Need TemplateSpecializationType dumping to test TemplateExpansion.
461 
462   template<int, int = 0> class testExpr;
463   template<int I> class testExpr<I> { };
464   // CHECK:      ClassTemplatePartialSpecializationDecl{{.*}} class testExpr
465   // CHECK:        TemplateArgument{{.*}} expr
466   // CHECK-NEXT:     DeclRefExpr{{.*}}I
467 
468   template<int, int ...> class testPack { };
469   template class testPack<0, 1, 2>;
470   // CHECK:      ClassTemplateSpecializationDecl{{.*}} class testPack
471   // CHECK:        TemplateArgument{{.*}} integral 0
472   // CHECK-NEXT:   TemplateArgument{{.*}} pack
473   // CHECK-NEXT:     TemplateArgument{{.*}} integral 1
474   // CHECK-NEXT:     TemplateArgument{{.*}} integral 2
475 }
476 
477 namespace testUsingDecl {
478   int i;
479 }
480 namespace TestUsingDecl {
481   using testUsingDecl::i;
482 }
483 // CHECK:      NamespaceDecl{{.*}} TestUsingDecl
484 // CHECK-NEXT:   UsingDecl{{.*}} testUsingDecl::i
485 // CHECK-NEXT:   UsingShadowDecl{{.*}} Var{{.*}} 'i' 'int'
486 
487 namespace testUnresolvedUsing {
488   class A { };
489   template<class T> class B {
490   public:
491     A a;
492   };
493   template<class T> class TestUnresolvedUsing : public B<T> {
494     using typename B<T>::a;
495     using B<T>::a;
496   };
497 }
498 // CHECK: CXXRecordDecl{{.*}} TestUnresolvedUsing
499 // CHECK:   UnresolvedUsingTypenameDecl{{.*}} B<T>::a
500 // CHECK:   UnresolvedUsingValueDecl{{.*}} B<T>::a
501 
502 namespace TestLinkageSpecDecl {
503   extern "C" void test1();
504   extern "C++" void test2();
505 }
506 // CHECK:      NamespaceDecl{{.*}} TestLinkageSpecDecl
507 // CHECK-NEXT:   LinkageSpecDecl{{.*}} C
508 // CHECK-NEXT:     FunctionDecl
509 // CHECK-NEXT:   LinkageSpecDecl{{.*}} C++
510 // CHECK-NEXT:     FunctionDecl
511 
512 class TestAccessSpecDecl {
513 public:
514 private:
515 protected:
516 };
517 // CHECK:      CXXRecordDecl{{.*}} class TestAccessSpecDecl
518 // CHECK:         CXXRecordDecl{{.*}} class TestAccessSpecDecl
519 // CHECK-NEXT:    AccessSpecDecl{{.*}} public
520 // CHECK-NEXT:    AccessSpecDecl{{.*}} private
521 // CHECK-NEXT:    AccessSpecDecl{{.*}} protected
522 
523 template<typename T> class TestFriendDecl {
524   friend int foo();
525   friend class A;
526   friend T;
527 };
528 // CHECK:      CXXRecord{{.*}} TestFriendDecl
529 // CHECK:        CXXRecord{{.*}} TestFriendDecl
530 // CHECK-NEXT:   FriendDecl
531 // CHECK-NEXT:     FunctionDecl{{.*}} foo
532 // CHECK-NEXT:   FriendDecl{{.*}} 'class A':'A'
533 // CHECK-NEXT:   FriendDecl{{.*}} 'T'
534 
535 namespace TestFileScopeAsmDecl {
536   asm("ret");
537 }
538 // CHECK:      NamespaceDecl{{.*}} TestFileScopeAsmDecl{{$}}
539 // CHECK:        FileScopeAsmDecl{{.*> .*$}}
540 // CHECK-NEXT:     StringLiteral
541 
542 namespace TestFriendDecl2 {
543   void f();
544   struct S {
545     friend void f();
546   };
547 }
548 // CHECK: NamespaceDecl [[TestFriendDecl2:0x.*]] <{{.*}}> {{.*}} TestFriendDecl2
549 // CHECK: |-FunctionDecl [[TestFriendDecl2_f:0x.*]] <{{.*}}> {{.*}} f 'void ()'
550 // CHECK: `-CXXRecordDecl {{.*}} struct S
551 // CHECK:   |-CXXRecordDecl {{.*}} struct S
552 // CHECK:   `-FriendDecl
553 // CHECK:     `-FunctionDecl {{.*}} parent [[TestFriendDecl2]] prev [[TestFriendDecl2_f]] <{{.*}}> {{.*}} f 'void ()'
554 
555 namespace Comment {
556   extern int Test;
557   /// Something here.
558   extern int Test;
559   extern int Test;
560 }
561 
562 // CHECK: VarDecl {{.*}} Test 'int' extern
563 // CHECK-NOT: FullComment
564 // CHECK: VarDecl {{.*}} Test 'int' extern
565 // CHECK: `-FullComment
566 // CHECK:   `-ParagraphComment
567 // CHECK:       `-TextComment
568 // CHECK: VarDecl {{.*}} Test 'int' extern
569 // CHECK-NOT: FullComment
570