Clang Project

clang_source_code/test/AST/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
2
3class testEnumDecl {
4  enum class TestEnumDeclScoped;
5  enum TestEnumDeclFixed : int;
6};
7// CHECK: EnumDecl{{.*}} class TestEnumDeclScoped 'int'
8// CHECK: EnumDecl{{.*}} TestEnumDeclFixed 'int'
9
10class testFieldDecl {
11  int TestFieldDeclInit = 0;
12};
13// CHECK:      FieldDecl{{.*}} TestFieldDeclInit 'int'
14// CHECK-NEXT:   IntegerLiteral
15
16namespace testVarDeclNRVO {
17  class A { };
18  A foo() {
19    A TestVarDeclNRVO;
20    return TestVarDeclNRVO;
21  }
22}
23// CHECK: VarDecl{{.*}} TestVarDeclNRVO 'testVarDeclNRVO::A' nrvo
24
25void testParmVarDeclInit(int TestParmVarDeclInit = 0);
26// CHECK:      ParmVarDecl{{.*}} TestParmVarDeclInit 'int'
27// CHECK-NEXT:   IntegerLiteral{{.*}}
28
29namespace TestNamespaceDecl {
30  int i;
31}
32// CHECK:      NamespaceDecl{{.*}} TestNamespaceDecl
33// CHECK-NEXT:   VarDecl
34
35namespace TestNamespaceDecl {
36  int j;
37}
38// CHECK:      NamespaceDecl{{.*}} TestNamespaceDecl
39// CHECK-NEXT:   original Namespace
40// CHECK-NEXT:   VarDecl
41
42inline namespace TestNamespaceDeclInline {
43}
44// CHECK:      NamespaceDecl{{.*}} TestNamespaceDeclInline inline
45
46namespace testUsingDirectiveDecl {
47  namespace A {
48  }
49}
50namespace TestUsingDirectiveDecl {
51  using namespace testUsingDirectiveDecl::A;
52}
53// CHECK:      NamespaceDecl{{.*}} TestUsingDirectiveDecl
54// CHECK-NEXT:   UsingDirectiveDecl{{.*}} Namespace{{.*}} 'A'
55
56namespace testNamespaceAlias {
57  namespace A {
58  }
59}
60namespace TestNamespaceAlias = testNamespaceAlias::A;
61// CHECK:      NamespaceAliasDecl{{.*}} TestNamespaceAlias
62// CHECK-NEXT:   Namespace{{.*}} 'A'
63
64using TestTypeAliasDecl = int;
65// CHECK: TypeAliasDecl{{.*}} TestTypeAliasDecl 'int'
66
67namespace 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
75namespace 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
105template<class...T>
106class TestCXXRecordDeclPack : public T... {
107};
108// CHECK:      CXXRecordDecl{{.*}} class TestCXXRecordDeclPack
109// CHECK:        public 'T'...
110// CHECK-NEXT:   CXXRecordDecl{{.*}} class TestCXXRecordDeclPack
111
112thread_local int TestThreadLocalInt;
113// CHECK: TestThreadLocalInt {{.*}} tls_dynamic
114
115class 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
126namespace 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
147class 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.
154class TestMemberRanges {
155public:
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};
163void 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
177class TestCXXConversionDecl {
178  operator int() { return 0; }
179};
180// CHECK:      CXXConversionDecl{{.*}} operator int 'int ()'
181// CHECK-NEXT:   CompoundStmt
182
183namespace TestStaticAssertDecl {
184  static_assert(true, "msg");
185}
186// CHECK:      NamespaceDecl{{.*}} TestStaticAssertDecl
187// CHECK-NEXT:   StaticAssertDecl{{.*> .*$}}
188// CHECK-NEXT:     CXXBoolLiteralExpr
189// CHECK-NEXT:     StringLiteral
190
191namespace 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 0x{{.+}} <{{.+}}:[[@LINE-14]]:3, col:55> col:29 TestFunctionTemplate
211  // CHECK-NEXT:  |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 referenced typename depth 0 index 0 T
212  // CHECK-NEXT:  |-FunctionDecl 0x{{.+}} <col:24, col:55> col:29 TestFunctionTemplate 'void (T)'
213  // CHECK-NEXT:  | |-ParmVarDecl 0x{{.+}} <col:50> col:51 'T'
214  // CHECK-NEXT:  | `-CompoundStmt 0x{{.+}} <col:53, col:55>
215  // CHECK-NEXT:  |-FunctionDecl 0x{{.+}} <col:24, col:55> col:29 used TestFunctionTemplate 'void (testFunctionTemplateDecl::A)'
216  // CHECK-NEXT:  | |-TemplateArgument type 'testFunctionTemplateDecl::A'
217  // CHECK-NEXT:  | |-ParmVarDecl 0x{{.+}} <col:50> col:51 'testFunctionTemplateDecl::A':'testFunctionTemplateDecl::A'
218  // CHECK-NEXT:  | `-CompoundStmt 0x{{.+}} <col:53, col:55>
219  // CHECK-NEXT:  |-Function 0x{{.+}} 'TestFunctionTemplate' 'void (testFunctionTemplateDecl::B)'
220  // CHECK-NEXT:  |-FunctionDecl 0x{{.+}} <col:24, col:55> col:29 TestFunctionTemplate 'void (testFunctionTemplateDecl::C)'
221  // CHECK-NEXT:  | |-TemplateArgument type 'testFunctionTemplateDecl::C'
222  // CHECK-NEXT:  | `-ParmVarDecl 0x{{.+}} <col:50> col:51 'testFunctionTemplateDecl::C':'testFunctionTemplateDecl::C'
223  // CHECK-NEXT:  `-FunctionDecl 0x{{.+}} <col:24, col:55> col:29 TestFunctionTemplate 'void (testFunctionTemplateDecl::D)'
224  // CHECK-NEXT:    |-TemplateArgument type 'testFunctionTemplateDecl::D'
225  // CHECK-NEXT:    |-ParmVarDecl 0x{{.+}} <col:50> col:51 'testFunctionTemplateDecl::D':'testFunctionTemplateDecl::D'
226  // CHECK-NEXT:    `-CompoundStmt 0x{{.+}} <col:53, col:55>
227
228  // CHECK:       FunctionDecl 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-26]]:3, col:41> col:19 TestFunctionTemplate 'void (testFunctionTemplateDecl::B)'
229  // CHECK-NEXT:  |-TemplateArgument type 'testFunctionTemplateDecl::B'
230  // CHECK-NEXT:  `-ParmVarDecl 0x{{.+}} <col:40> col:41 'testFunctionTemplateDecl::B'
231
232
233namespace testClassTemplateDecl {
234  class A { };
235  class B { };
236  class C { };
237  class D { };
238
239  template<typename T> class TestClassTemplate {
240  public:
241    TestClassTemplate();
242    ~TestClassTemplate();
243    int j();
244    int i;
245  };
246
247  // implicit instantiation
248  TestClassTemplate<A> a;
249
250  // explicit specialization
251  template<> class TestClassTemplate<B> {
252    int j;
253  };
254
255  // explicit instantiation declaration
256  extern template class TestClassTemplate<C>;
257
258  // explicit instantiation definition
259  template class TestClassTemplate<D>;
260
261  // partial explicit specialization
262  template<typename T1, typename T2> class TestClassTemplatePartial {
263    int i;
264  };
265  template<typename T1> class TestClassTemplatePartial<T1, A> {
266    int j;
267  };
268
269  template<typename T = int> struct TestTemplateDefaultType;
270  template<typename T> struct TestTemplateDefaultType { };
271
272  template<int I = 42> struct TestTemplateDefaultNonType;
273  template<int I> struct TestTemplateDefaultNonType { };
274
275  template<template<typename> class TT = TestClassTemplate> struct TestTemplateTemplateDefaultType;
276  template<template<typename> class TT> struct TestTemplateTemplateDefaultType { };
277}
278
279// CHECK:       ClassTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-40]]:3, line:[[@LINE-34]]:3> line:[[@LINE-40]]:30 TestClassTemplate
280// CHECK-NEXT:  |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T
281// CHECK-NEXT:  |-CXXRecordDecl 0x{{.+}} <col:24, line:[[@LINE-36]]:3> line:[[@LINE-42]]:30 class TestClassTemplate definition
282// CHECK-NEXT:  | |-DefinitionData standard_layout has_user_declared_ctor can_const_default_init
283// CHECK-NEXT:  | | |-DefaultConstructor exists non_trivial user_provided
284// CHECK-NEXT:  | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
285// CHECK-NEXT:  | | |-MoveConstructor
286// CHECK-NEXT:  | | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
287// CHECK-NEXT:  | | |-MoveAssignment
288// CHECK-NEXT:  | | `-Destructor non_trivial user_declared
289// CHECK-NEXT:  | |-CXXRecordDecl 0x{{.+}} <col:24, col:30> col:30 implicit referenced class TestClassTemplate
290// CHECK-NEXT:  | |-AccessSpecDecl 0x{{.+}} <line:[[@LINE-50]]:3, col:9> col:3 public
291// CHECK-NEXT:  | |-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-50]]:5, col:23> col:5 TestClassTemplate<T> 'void ()'
292// CHECK-NEXT:  | |-CXXDestructorDecl 0x{{.+}} <line:[[@LINE-50]]:5, col:24> col:5 ~TestClassTemplate<T> 'void ()'
293// CHECK-NEXT:  | |-CXXMethodDecl 0x{{.+}} <line:[[@LINE-50]]:5, col:11> col:9 j 'int ()'
294// CHECK-NEXT:  | `-FieldDecl 0x{{.+}} <line:[[@LINE-50]]:5, col:9> col:9 i 'int'
295// CHECK-NEXT:  |-ClassTemplateSpecializationDecl 0x{{.+}} <line:[[@LINE-56]]:3, line:[[@LINE-50]]:3> line:[[@LINE-56]]:30 class TestClassTemplate definition
296// CHECK-NEXT:  | |-DefinitionData standard_layout has_user_declared_ctor can_const_default_init
297// CHECK-NEXT:  | | |-DefaultConstructor exists non_trivial user_provided
298// CHECK-NEXT:  | | |-CopyConstructor simple trivial has_const_param implicit_has_const_param
299// CHECK-NEXT:  | | |-MoveConstructor
300// CHECK-NEXT:  | | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
301// CHECK-NEXT:  | | |-MoveAssignment
302// CHECK-NEXT:  | | `-Destructor non_trivial user_declared
303// CHECK-NEXT:  | |-TemplateArgument type 'testClassTemplateDecl::A'
304// CHECK-NEXT:  | |-CXXRecordDecl 0x{{.+}} prev 0x{{.+}} <col:24, col:30> col:30 implicit class TestClassTemplate
305// CHECK-NEXT:  | |-AccessSpecDecl 0x{{.+}} <line:[[@LINE-65]]:3, col:9> col:3 public
306// CHECK-NEXT:  | |-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-65]]:5, col:23> col:5 used TestClassTemplate 'void ()'
307// CHECK-NEXT:  | |-CXXDestructorDecl 0x{{.+}} <line:[[@LINE-65]]:5, col:24> col:5 used ~TestClassTemplate 'void () noexcept'
308// CHECK-NEXT:  | |-CXXMethodDecl 0x{{.+}} <line:[[@LINE-65]]:5, col:11> col:9 j 'int ()'
309// CHECK-NEXT:  | |-FieldDecl 0x{{.+}} <line:[[@LINE-65]]:5, col:9> col:9 i 'int'
310// CHECK-NEXT:  | `-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-71]]:30> col:30 implicit constexpr TestClassTemplate 'void (const testClassTemplateDecl::TestClassTemplate<testClassTemplateDecl::A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}
311// CHECK-NEXT:  |   `-ParmVarDecl 0x{{.+}} <col:30> col:30 'const testClassTemplateDecl::TestClassTemplate<testClassTemplateDecl::A> &'
312// CHECK-NEXT:  |-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate'
313// CHECK-NEXT:  |-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate'
314// CHECK-NEXT:  `-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate'
315
316// CHECK:       ClassTemplateSpecializationDecl 0x{{.+}} <{{.+}}:[[@LINE-65]]:3, line:[[@LINE-63]]:3> line:[[@LINE-65]]:20 class TestClassTemplate definition
317// CHECK-NEXT:  |-DefinitionData pass_in_registers standard_layout trivially_copyable trivial literal
318// CHECK-NEXT:  | |-DefaultConstructor exists trivial needs_implicit
319// CHECK-NEXT:  | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
320// CHECK-NEXT:  | |-MoveConstructor exists simple trivial needs_implicit
321// CHECK-NEXT:  | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
322// CHECK-NEXT:  | |-MoveAssignment exists simple trivial needs_implicit
323// CHECK-NEXT:  | `-Destructor simple irrelevant trivial needs_implicit
324// CHECK-NEXT:  |-TemplateArgument type 'testClassTemplateDecl::B'
325// CHECK-NEXT:  |-CXXRecordDecl 0x{{.+}} <col:14, col:20> col:20 implicit class TestClassTemplate
326// CHECK-NEXT:  `-FieldDecl 0x{{.+}} <line:[[@LINE-74]]:5, col:9> col:9 j 'int'
327
328// CHECK:       ClassTemplateSpecializationDecl 0x{{.+}} <{{.+}}:256:3, col:44> col:25 class TestClassTemplate definition
329// CHECK-NEXT:  |-DefinitionData standard_layout has_user_declared_ctor can_const_default_init
330// CHECK-NEXT:  | |-DefaultConstructor exists non_trivial user_provided
331// CHECK-NEXT:  | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
332// CHECK-NEXT:  | |-MoveConstructor
333// CHECK-NEXT:  | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
334// CHECK-NEXT:  | |-MoveAssignment
335// CHECK-NEXT:  | `-Destructor non_trivial user_declared
336// CHECK-NEXT:  |-TemplateArgument type 'testClassTemplateDecl::C'
337// CHECK-NEXT:  |-CXXRecordDecl 0x{{.+}} prev 0x{{.+}} <line:[[@LINE-98]]:24, col:30> col:30 implicit class TestClassTemplate
338// CHECK-NEXT:  |-AccessSpecDecl 0x{{.+}} <line:[[@LINE-98]]:3, col:9> col:3 public
339// CHECK-NEXT:  |-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-98]]:5, col:23> col:5 TestClassTemplate 'void ()'
340// CHECK-NEXT:  |-CXXDestructorDecl 0x{{.+}} <line:[[@LINE-98]]:5, col:24> col:5 ~TestClassTemplate 'void ()' noexcept-unevaluated 0x{{.+}}
341// CHECK-NEXT:  |-CXXMethodDecl 0x{{.+}} <line:[[@LINE-98]]:5, col:11> col:9 j 'int ()'
342// CHECK-NEXT:  `-FieldDecl 0x{{.+}} <line:[[@LINE-98]]:5, col:9> col:9 i 'int'
343
344// CHECK:       ClassTemplateSpecializationDecl 0x{{.+}} <{{.+}}:[[@LINE-85]]:3, col:37> col:18 class TestClassTemplate definition
345// CHECK-NEXT:  |-DefinitionData standard_layout has_user_declared_ctor can_const_default_init
346// CHECK-NEXT:  | |-DefaultConstructor exists non_trivial user_provided
347// CHECK-NEXT:  | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
348// CHECK-NEXT:  | |-MoveConstructor
349// CHECK-NEXT:  | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
350// CHECK-NEXT:  | |-MoveAssignment
351// CHECK-NEXT:  | `-Destructor non_trivial user_declared
352// CHECK-NEXT:  |-TemplateArgument type 'testClassTemplateDecl::D'
353// CHECK-NEXT:  |-CXXRecordDecl 0x{{.+}} prev 0x{{.+}} <line:[[@LINE-114]]:24, col:30> col:30 implicit class TestClassTemplate
354// CHECK-NEXT:  |-AccessSpecDecl 0x{{.+}} <line:[[@LINE-114]]:3, col:9> col:3 public
355// CHECK-NEXT:  |-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-114]]:5, col:23> col:5 TestClassTemplate 'void ()'
356// CHECK-NEXT:  |-CXXDestructorDecl 0x{{.+}} <line:[[@LINE-114]]:5, col:24> col:5 ~TestClassTemplate 'void ()' noexcept-unevaluated 0x{{.+}}
357// CHECK-NEXT:  |-CXXMethodDecl 0x{{.+}} <line:[[@LINE-114]]:5, col:11> col:9 j 'int ()'
358// CHECK-NEXT:  `-FieldDecl 0x{{.+}} <line:[[@LINE-114]]:5, col:9> col:9 i 'int'
359
360// CHECK:      ClassTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-98]]:3, line:[[@LINE-96]]:3> line:[[@LINE-98]]:44 TestClassTemplatePartial
361// CHECK-NEXT:  |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T1
362// CHECK-NEXT:  |-TemplateTypeParmDecl 0x{{.+}} <col:25, col:34> col:34 typename depth 0 index 1 T2
363// CHECK-NEXT:  `-CXXRecordDecl 0x{{.+}} <col:38, line:[[@LINE-99]]:3> line:[[@LINE-101]]:44 class TestClassTemplatePartial definition
364// CHECK-NEXT:    |-DefinitionData standard_layout trivially_copyable trivial literal
365// CHECK-NEXT:    | |-DefaultConstructor exists trivial needs_implicit
366// CHECK-NEXT:    | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
367// CHECK-NEXT:    | |-MoveConstructor exists simple trivial needs_implicit
368// CHECK-NEXT:    | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
369// CHECK-NEXT:    | |-MoveAssignment exists simple trivial needs_implicit
370// CHECK-NEXT:    | `-Destructor simple irrelevant trivial needs_implicit
371// CHECK-NEXT:    |-CXXRecordDecl 0x{{.+}} <col:38, col:44> col:44 implicit class TestClassTemplatePartial
372// CHECK-NEXT:    `-FieldDecl 0x{{.+}} <line:[[@LINE-109]]:5, col:9> col:9 i 'int'
373
374// CHECK:       ClassTemplatePartialSpecializationDecl 0x{{.+}} <{{.+}}:[[@LINE-109]]:3, line:[[@LINE-107]]:3> line:[[@LINE-109]]:31 class TestClassTemplatePartial definition
375// CHECK-NEXT:  |-DefinitionData standard_layout trivially_copyable trivial literal
376// CHECK-NEXT:  | |-DefaultConstructor exists trivial needs_implicit
377// CHECK-NEXT:  | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
378// CHECK-NEXT:  | |-MoveConstructor exists simple trivial needs_implicit
379// CHECK-NEXT:  | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
380// CHECK-NEXT:  | |-MoveAssignment exists simple trivial needs_implicit
381// CHECK-NEXT:  | `-Destructor simple irrelevant trivial needs_implicit
382// CHECK-NEXT:  |-TemplateArgument type 'type-parameter-0-0'
383// CHECK-NEXT:  |-TemplateArgument type 'testClassTemplateDecl::A'
384// CHECK-NEXT:  |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 referenced typename depth 0 index 0 T1
385// CHECK-NEXT:  |-CXXRecordDecl 0x{{.+}} <col:25, col:31> col:31 implicit class TestClassTemplatePartial
386// CHECK-NEXT:  `-FieldDecl 0x{{.+}} <line:[[@LINE-120]]:5, col:9> col:9 j 'int'
387
388// CHECK:       ClassTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-119]]:3, col:37> col:37 TestTemplateDefaultType
389// CHECK-NEXT:  |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:25> col:21 typename depth 0 index 0 T
390// CHECK-NEXT:  | `-TemplateArgument type 'int'
391// CHECK-NEXT:  `-CXXRecordDecl 0x{{.+}} <col:30, col:37> col:37 struct TestTemplateDefaultType
392
393// CHECK:       ClassTemplateDecl 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-123]]:3, col:57> col:31 TestTemplateDefaultType
394// CHECK-NEXT:  |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T
395// CHECK-NEXT:  | `-TemplateArgument type 'int'
396// CHECK-NEXT:  |   `-inherited from TemplateTypeParm 0x{{.+}} 'T'
397// CHECK-NEXT:  `-CXXRecordDecl 0x{{.+}} prev 0x{{.+}} <col:24, col:57> col:31 struct TestTemplateDefaultType definition
398// CHECK-NEXT:    |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
399// CHECK-NEXT:    | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
400// CHECK-NEXT:    | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
401// CHECK-NEXT:    | |-MoveConstructor exists simple trivial needs_implicit
402// CHECK-NEXT:    | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
403// CHECK-NEXT:    | |-MoveAssignment exists simple trivial needs_implicit
404// CHECK-NEXT:    | `-Destructor simple irrelevant trivial needs_implicit
405// CHECK-NEXT:    `-CXXRecordDecl 0x{{.+}} <col:24, col:31> col:31 implicit struct TestTemplateDefaultType
406
407// CHECK:       ClassTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-135]]:3, col:31> col:31 TestTemplateDefaultNonType
408// CHECK-NEXT:  |-NonTypeTemplateParmDecl 0x{{.+}} <col:12, col:20> col:16 'int' depth 0 index 0 I
409// CHECK-NEXT:  | `-TemplateArgument expr
410// CHECK-NEXT:  |   `-ConstantExpr 0x{{.+}} <col:20> 'int'
411// CHECK-NEXT:  |     `-IntegerLiteral 0x{{.+}} <col:20> 'int' 42
412// CHECK-NEXT:  `-CXXRecordDecl 0x{{.+}} <col:24, col:31> col:31 struct TestTemplateDefaultNonType
413
414// CHECK:       ClassTemplateDecl 0x{{.+}} <{{.+}}:275:3, col:68> col:68 TestTemplateTemplateDefaultType
415// CHECK-NEXT:  |-TemplateTemplateParmDecl 0x{{.+}} <col:12, col:42> col:37 depth 0 index 0 TT
416// CHECK-NEXT:  | |-TemplateTypeParmDecl 0x{{.+}} <col:21> col:21 typename depth 1 index 0
417// CHECK-NEXT:  | `-TemplateArgument <col:42> template TestClassTemplate
418// CHECK-NEXT:  `-CXXRecordDecl 0x{{.+}} <col:61, col:68> col:68 struct TestTemplateTemplateDefaultType
419
420// CHECK:       ClassTemplateDecl 0x{{.+}} prev 0x{{.+}} <{{.+}}:276:3, col:82> col:48 TestTemplateTemplateDefaultType
421// CHECK-NEXT:  |-TemplateTemplateParmDecl 0x{{.+}} <col:12, col:37> col:37 depth 0 index 0 TT
422// CHECK-NEXT:  | |-TemplateTypeParmDecl 0x{{.+}} <col:21> col:21 typename depth 1 index 0
423// CHECK-NEXT:  | `-TemplateArgument <line:275:42> template TestClassTemplate
424// CHECK-NEXT:  |   `-inherited from TemplateTemplateParm 0x{{.+}} 'TT'
425// CHECK-NEXT:  `-CXXRecordDecl 0x{{.+}} prev 0x{{.+}} <line:276:41, col:82> col:48 struct TestTemplateTemplateDefaultType definition
426// CHECK-NEXT:    |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
427// CHECK-NEXT:    | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
428// CHECK-NEXT:    | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
429// CHECK-NEXT:    | |-MoveConstructor exists simple trivial needs_implicit
430// CHECK-NEXT:    | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
431// CHECK-NEXT:    | |-MoveAssignment exists simple trivial needs_implicit
432// CHECK-NEXT:    | `-Destructor simple irrelevant trivial needs_implicit
433// CHECK-NEXT:    `-CXXRecordDecl 0x{{.+}} <col:41, col:48> col:48 implicit struct TestTemplateTemplateDefaultType
434
435
436// PR15220 dump instantiation only once
437namespace testCanonicalTemplate {
438  class A {};
439
440  template<typename T> void TestFunctionTemplate(T);
441  template<typename T> void TestFunctionTemplate(T);
442  void bar(A a) { TestFunctionTemplate(a); }
443  // CHECK:      FunctionTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-3]]:3, col:51> col:29 TestFunctionTemplate
444  // CHECK-NEXT:   |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 referenced typename depth 0 index 0 T
445  // CHECK-NEXT:   |-FunctionDecl 0x{{.*}} <col:24, col:51> col:29 TestFunctionTemplate 'void (T)'
446  // CHECK-NEXT:   | `-ParmVarDecl 0x{{.*}} <col:50> col:51 'T'
447  // CHECK-NEXT:   `-FunctionDecl 0x{{.*}} <line:[[@LINE-6]]:24, col:51> col:29 used TestFunctionTemplate 'void (testCanonicalTemplate::A)'
448  // CHECK-NEXT:     |-TemplateArgument type 'testCanonicalTemplate::A'
449  // CHECK-NEXT:     `-ParmVarDecl 0x{{.*}} <col:50> col:51 'testCanonicalTemplate::A':'testCanonicalTemplate::A'
450
451  // CHECK:      FunctionTemplateDecl 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-10]]:3, col:51> col:29 TestFunctionTemplate
452  // CHECK-NEXT:   |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 referenced typename depth 0 index 0 T
453  // CHECK-NEXT:   |-FunctionDecl{{.*}} 0x{{.+}} prev 0x{{.+}} <col:24, col:51> col:29 TestFunctionTemplate 'void (T)'
454  // CHECK-NEXT:   | `-ParmVarDecl 0x{{.+}} <col:50> col:51 'T'
455  // CHECK-NEXT:   `-Function 0x{{.+}} 'TestFunctionTemplate' 'void (testCanonicalTemplate::A)'
456  // CHECK-NOT:      TemplateArgument
457
458  template<typename T1> class TestClassTemplate {
459    template<typename T2> friend class TestClassTemplate;
460  };
461  TestClassTemplate<A> a;
462  // CHECK:      ClassTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-4]]:3, line:[[@LINE-2]]:3> line:[[@LINE-4]]:31 TestClassTemplate
463  // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T1
464  // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} <col:25, line:[[@LINE-4]]:3> line:[[@LINE-6]]:31 class TestClassTemplate definition
465  // CHECK-NEXT: | |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
466  // CHECK-NEXT: | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
467  // CHECK-NEXT: | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
468  // CHECK-NEXT: | | |-MoveConstructor exists simple trivial needs_implicit
469  // CHECK-NEXT: | | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
470  // CHECK-NEXT: | | |-MoveAssignment exists simple trivial needs_implicit
471  // CHECK-NEXT: | | `-Destructor simple irrelevant trivial needs_implicit
472  // CHECK-NEXT: | |-CXXRecordDecl 0x{{.+}} <col:25, col:31> col:31 implicit class TestClassTemplate
473  // CHECK-NEXT: | `-FriendDecl 0x{{.+}} <line:[[@LINE-14]]:5, col:40> col:40
474  // CHECK-NEXT: |   `-ClassTemplateDecl 0x{{.+}} parent 0x{{.+}} <col:5, col:40> col:40 TestClassTemplate
475  // CHECK-NEXT: |     |-TemplateTypeParmDecl 0x{{.+}} <col:14, col:23> col:23 typename depth 1 index 0 T2
476  // CHECK-NEXT: |     `-CXXRecordDecl 0x{{.+}} parent 0x{{.+}} <col:34, col:40> col:40 class TestClassTemplate
477  // CHECK-NEXT: `-ClassTemplateSpecializationDecl 0x{{.+}} <line:[[@LINE-19]]:3, line:[[@LINE-17]]:3> line:[[@LINE-19]]:31 class TestClassTemplate definition
478  // 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
479  // CHECK-NEXT:   | |-DefaultConstructor exists trivial constexpr defaulted_is_constexpr
480  // CHECK-NEXT:   | |-CopyConstructor simple trivial has_const_param implicit_has_const_param
481  // CHECK-NEXT:   | |-MoveConstructor exists simple trivial
482  // CHECK-NEXT:   | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
483  // CHECK-NEXT:   | |-MoveAssignment exists simple trivial needs_implicit
484  // CHECK-NEXT:   | `-Destructor simple irrelevant trivial needs_implicit
485  // CHECK-NEXT:   |-TemplateArgument type 'testCanonicalTemplate::A'
486  // CHECK-NEXT:   |-CXXRecordDecl 0x{{.+}} prev 0x{{.+}} <col:25, col:31> col:31 implicit class TestClassTemplate
487  // CHECK-NEXT:   |-FriendDecl 0x{{.+}} <line:[[@LINE-28]]:5, col:40> col:40
488  // CHECK-NEXT:   | `-ClassTemplateDecl 0x{{.+}} parent 0x{{.+}} prev 0x{{.+}} <col:5, col:40> col:40 TestClassTemplate
489  // CHECK-NEXT:   |   |-TemplateTypeParmDecl 0x{{.+}} <col:14, col:23> col:23 typename depth 0 index 0 T2
490  // CHECK-NEXT:   |   |-CXXRecordDecl 0x{{.+}} parent 0x{{.+}} prev 0x{{.+}} <col:34, col:40> col:40 class TestClassTemplate
491  // CHECK-NEXT:   |   `-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate'
492  // CHECK-NEXT:   |-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-34]]:31> col:31 implicit used constexpr TestClassTemplate 'void () noexcept' inline default trivial
493  // CHECK-NEXT:   | `-CompoundStmt 0x{{.+}} <col:31>
494  // CHECK-NEXT:   |-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate 'void (const testCanonicalTemplate::TestClassTemplate<testCanonicalTemplate::A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}
495  // CHECK-NEXT:   | `-ParmVarDecl 0x{{.+}} <col:31> col:31 'const testCanonicalTemplate::TestClassTemplate<testCanonicalTemplate::A> &'
496  // CHECK-NEXT:   `-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate 'void (testCanonicalTemplate::TestClassTemplate<testCanonicalTemplate::A> &&)' inline default trivial noexcept-unevaluated 0x{{.+}}
497  // CHECK-NEXT:     `-ParmVarDecl 0x{{.+}} <col:31> col:31 'testCanonicalTemplate::TestClassTemplate<testCanonicalTemplate::A> &&'
498
499
500  template<typename T1> class TestClassTemplate2;
501  template<typename T1> class TestClassTemplate2;
502  template<typename T1> class TestClassTemplate2 {
503  };
504  TestClassTemplate2<A> a2;
505  // CHECK:      ClassTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-5]]:3, col:31> col:31 TestClassTemplate2
506  // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T1
507  // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} <col:25, col:31> col:31 class TestClassTemplate2
508  // CHECK-NEXT: `-ClassTemplateSpecializationDecl 0x{{.+}} <line:[[@LINE-6]]:3, line:[[@LINE-5]]:3> line:[[@LINE-6]]:31 class TestClassTemplate2 definition
509  // 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
510  // CHECK-NEXT:   | |-DefaultConstructor exists trivial constexpr defaulted_is_constexpr
511  // CHECK-NEXT:   | |-CopyConstructor simple trivial has_const_param implicit_has_const_param
512  // CHECK-NEXT:   | |-MoveConstructor exists simple trivial
513  // CHECK-NEXT:   | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
514  // CHECK-NEXT:   | |-MoveAssignment exists simple trivial needs_implicit
515  // CHECK-NEXT:   | `-Destructor simple irrelevant trivial needs_implicit
516  // CHECK-NEXT:   |-TemplateArgument type 'testCanonicalTemplate::A'
517  // CHECK-NEXT:   |-CXXRecordDecl 0x{{.+}} prev 0x{{.+}} <col:25, col:31> col:31 implicit class TestClassTemplate2
518  // CHECK-NEXT:   |-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit used constexpr TestClassTemplate2 'void () noexcept' inline default trivial
519  // CHECK-NEXT:   | `-CompoundStmt 0x{{.+}} <col:31>
520  // CHECK-NEXT:   |-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate2 'void (const testCanonicalTemplate::TestClassTemplate2<testCanonicalTemplate::A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}
521  // CHECK-NEXT:   | `-ParmVarDecl 0x{{.+}} <col:31> col:31 'const testCanonicalTemplate::TestClassTemplate2<testCanonicalTemplate::A> &'
522  // CHECK-NEXT:   `-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate2 'void (testCanonicalTemplate::TestClassTemplate2<testCanonicalTemplate::A> &&)' inline default trivial noexcept-unevaluated 0x{{.+}}
523  // CHECK-NEXT:     `-ParmVarDecl 0x{{.+}} <col:31> col:31 'testCanonicalTemplate::TestClassTemplate2<testCanonicalTemplate::A> &&'
524
525  // CHECK:      ClassTemplateDecl 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-24]]:3, col:31> col:31 TestClassTemplate2
526  // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T1
527  // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} prev 0x{{.+}} <col:25, col:31> col:31 class TestClassTemplate2
528  // CHECK-NEXT: `-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate2'
529
530  // CHECK:      ClassTemplateDecl 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-28]]:3, line:[[@LINE-27]]:3> line:[[@LINE-28]]:31 TestClassTemplate2
531  // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T1
532  // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} prev 0x{{.+}} <col:25, line:[[@LINE-29]]:3> line:[[@LINE-30]]:31 class TestClassTemplate2 definition
533  // CHECK-NEXT: | |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
534  // CHECK-NEXT: | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
535  // CHECK-NEXT: | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
536  // CHECK-NEXT: | | |-MoveConstructor exists simple trivial needs_implicit
537  // CHECK-NEXT: | | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
538  // CHECK-NEXT: | | |-MoveAssignment exists simple trivial needs_implicit
539  // CHECK-NEXT: | | `-Destructor simple irrelevant trivial needs_implicit
540  // CHECK-NEXT: | `-CXXRecordDecl 0x{{.+}} <col:25, col:31> col:31 implicit class TestClassTemplate2
541  // CHECK-NEXT: `-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate2'
542
543  struct S {
544      template<typename T> static const T TestVarTemplate; // declaration of a static data member template
545  };
546  template<typename T>
547  const T S::TestVarTemplate = { }; // definition of a static data member template
548
549  void f()
550  {
551    int i = S::TestVarTemplate<int>;
552    int j = S::TestVarTemplate<int>;
553  }
554
555  // CHECK:      VarTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-11]]:7, col:43> col:43 TestVarTemplate
556  // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:16, col:25> col:25 referenced typename depth 0 index 0 T
557  // CHECK-NEXT: |-VarDecl 0x{{.+}} <col:28, col:43> col:43 TestVarTemplate 'const T' static
558  // CHECK-NEXT: |-VarTemplateSpecializationDecl 0x{{.+}} parent 0x{{.+}} prev 0x{{.+}} <line:[[@LINE-11]]:3, col:34> col:14 referenced TestVarTemplate 'const int':'const int' cinit
559  // CHECK-NEXT: | |-TemplateArgument type 'int'
560  // CHECK-NEXT: | `-InitListExpr 0x{{.+}} <col:32, col:34> 'int':'int'
561  // CHECK-NEXT: `-VarTemplateSpecializationDecl 0x{{.+}} <line:[[@LINE-17]]:28, col:43> col:43 referenced TestVarTemplate 'const int':'const int' static
562  // CHECK-NEXT:   `-TemplateArgument type 'int'
563
564  // CHECK:     VarTemplateSpecializationDecl 0x{{.+}} <{{.+}}:[[@LINE-20]]:28, col:43> col:43 referenced TestVarTemplate 'const int':'const int' static
565  // CHECK-NEXT:`-TemplateArgument type 'int'
566
567  // CHECK:      VarTemplateDecl 0x{{.+}} parent 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-21]]:3, line:[[@LINE-20]]:34> col:14 TestVarTemplate
568  // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <line:[[@LINE-22]]:12, col:21> col:21 referenced typename depth 0 index 0 T
569  // CHECK-NEXT: |-VarDecl 0x{{.+}} parent 0x{{.+}} prev 0x{{.+}} <line:[[@LINE-22]]:3, col:34> col:14 TestVarTemplate 'const T' cinit
570  // CHECK-NEXT: | `-InitListExpr 0x{{.+}} <col:32, col:34> 'void'
571  // CHECK-NEXT: |-VarTemplateSpecialization 0x{{.+}} 'TestVarTemplate' 'const int':'const int'
572  // CHECK-NEXT: `-VarTemplateSpecialization 0x{{.+}} 'TestVarTemplate' 'const int':'const int'
573    
574  // CHECK:      VarTemplateSpecializationDecl 0x{{.+}} parent 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-27]]:3, col:34> col:14 referenced TestVarTemplate 'const int':'const int' cinit
575  // CHECK-NEXT: |-TemplateArgument type 'int'
576  // CHECK-NEXT: `-InitListExpr 0x{{.+}} <col:32, col:34> 'int':'int'
577} 
578
579template <class T>
580class TestClassScopeFunctionSpecialization {
581  template<class U> void foo(U a) { }
582  template<> void foo<int>(int a) { }
583};
584// CHECK:      ClassScopeFunctionSpecializationDecl
585// CHECK-NEXT:   CXXMethod{{.*}} foo 'void (int)'
586// CHECK-NEXT:     ParmVarDecl
587// CHECK-NEXT:     CompoundStmt
588// CHECK-NEXT:   TemplateArgument{{.*}} 'int'
589
590namespace TestTemplateTypeParmDecl {
591  template<typename ... T, class U = int> void foo();
592}
593// CHECK:      NamespaceDecl{{.*}} TestTemplateTypeParmDecl
594// CHECK-NEXT:   FunctionTemplateDecl
595// CHECK-NEXT:     TemplateTypeParmDecl{{.*}} typename depth 0 index 0 ... T
596// CHECK-NEXT:     TemplateTypeParmDecl{{.*}} class depth 0 index 1 U
597// CHECK-NEXT:       TemplateArgument type 'int'
598
599namespace TestNonTypeTemplateParmDecl {
600  template<int I = 1, int ... J> void foo();
601}
602// CHECK:      NamespaceDecl{{.*}} TestNonTypeTemplateParmDecl
603// CHECK-NEXT:   FunctionTemplateDecl
604// CHECK-NEXT:     NonTypeTemplateParmDecl{{.*}} 'int' depth 0 index 0 I
605// CHECK-NEXT:       TemplateArgument expr
606// CHECK-NEXT:         ConstantExpr{{.*}} 'int'
607// CHECK-NEXT:           IntegerLiteral{{.*}} 'int' 1
608// CHECK-NEXT:     NonTypeTemplateParmDecl{{.*}} 'int' depth 0 index 1 ... J
609
610namespace TestTemplateTemplateParmDecl {
611  template<typename T> class A;
612  template <template <typename> class T = A, template <typename> class ... U> void foo();
613}
614// CHECK:      NamespaceDecl{{.*}} TestTemplateTemplateParmDecl
615// CHECK:        FunctionTemplateDecl
616// CHECK-NEXT:     TemplateTemplateParmDecl{{.*}} T
617// CHECK-NEXT:       TemplateTypeParmDecl{{.*}} typename
618// CHECK-NEXT:       TemplateArgument{{.*}} template A
619// CHECK-NEXT:     TemplateTemplateParmDecl{{.*}} ... U
620// CHECK-NEXT:       TemplateTypeParmDecl{{.*}} typename
621
622namespace TestTemplateArgument {
623  template<typename> class A { };
624  template<template<typename> class ...> class B { };
625  int foo();
626
627  template<typename> class testType { };
628  template class testType<int>;
629  // CHECK:      ClassTemplateSpecializationDecl{{.*}} class testType
630  // CHECK:        TemplateArgument{{.*}} type 'int'
631
632  template<int fp(void)> class testDecl { };
633  template class testDecl<foo>;
634  // CHECK:      ClassTemplateSpecializationDecl{{.*}} class testDecl
635  // CHECK:        TemplateArgument{{.*}} decl
636  // CHECK-NEXT:     Function{{.*}}foo
637
638  template class testDecl<nullptr>;
639  // CHECK:      ClassTemplateSpecializationDecl{{.*}} class testDecl
640  // CHECK:        TemplateArgument{{.*}} nullptr
641
642  template<int> class testIntegral { };
643  template class testIntegral<1>;
644  // CHECK:      ClassTemplateSpecializationDecl{{.*}} class testIntegral
645  // CHECK:        TemplateArgument{{.*}} integral 1
646
647  template<template<typename> class> class testTemplate { };
648  template class testTemplate<A>;
649  // CHECK:      ClassTemplateSpecializationDecl{{.*}} class testTemplate
650  // CHECK:        TemplateArgument{{.*}} A
651
652  template<template<typename> class ...T> class C {
653    B<T...> testTemplateExpansion;
654  };
655  // FIXME: Need TemplateSpecializationType dumping to test TemplateExpansion.
656
657  template<int, int = 0> class testExpr;
658  template<int I> class testExpr<I> { };
659  // CHECK:      ClassTemplatePartialSpecializationDecl{{.*}} class testExpr
660  // CHECK:        TemplateArgument{{.*}} expr
661  // CHECK-NEXT:     DeclRefExpr{{.*}}I
662
663  template<int, int ...> class testPack { };
664  template class testPack<0, 1, 2>;
665  // CHECK:      ClassTemplateSpecializationDecl{{.*}} class testPack
666  // CHECK:        TemplateArgument{{.*}} integral 0
667  // CHECK-NEXT:   TemplateArgument{{.*}} pack
668  // CHECK-NEXT:     TemplateArgument{{.*}} integral 1
669  // CHECK-NEXT:     TemplateArgument{{.*}} integral 2
670}
671
672namespace testUsingDecl {
673  int i;
674}
675namespace TestUsingDecl {
676  using testUsingDecl::i;
677}
678// CHECK:      NamespaceDecl{{.*}} TestUsingDecl
679// CHECK-NEXT:   UsingDecl{{.*}} testUsingDecl::i
680// CHECK-NEXT:   UsingShadowDecl{{.*}} Var{{.*}} 'i' 'int'
681
682namespace testUnresolvedUsing {
683  class A { };
684  template<class T> class B {
685  public:
686    A a;
687  };
688  template<class T> class TestUnresolvedUsing : public B<T> {
689    using typename B<T>::a;
690    using B<T>::a;
691  };
692}
693// CHECK: CXXRecordDecl{{.*}} TestUnresolvedUsing
694// CHECK:   UnresolvedUsingTypenameDecl{{.*}} B<T>::a
695// CHECK:   UnresolvedUsingValueDecl{{.*}} B<T>::a
696
697namespace TestLinkageSpecDecl {
698  extern "C" void test1();
699  extern "C++" void test2();
700}
701// CHECK:      NamespaceDecl{{.*}} TestLinkageSpecDecl
702// CHECK-NEXT:   LinkageSpecDecl{{.*}} C
703// CHECK-NEXT:     FunctionDecl
704// CHECK-NEXT:   LinkageSpecDecl{{.*}} C++
705// CHECK-NEXT:     FunctionDecl
706
707class TestAccessSpecDecl {
708public:
709private:
710protected:
711};
712// CHECK:      CXXRecordDecl{{.*}} class TestAccessSpecDecl
713// CHECK:         CXXRecordDecl{{.*}} class TestAccessSpecDecl
714// CHECK-NEXT:    AccessSpecDecl{{.*}} public
715// CHECK-NEXT:    AccessSpecDecl{{.*}} private
716// CHECK-NEXT:    AccessSpecDecl{{.*}} protected
717
718template<typename T> class TestFriendDecl {
719  friend int foo();
720  friend class A;
721  friend T;
722};
723// CHECK:      CXXRecord{{.*}} TestFriendDecl
724// CHECK:        CXXRecord{{.*}} TestFriendDecl
725// CHECK-NEXT:   FriendDecl
726// CHECK-NEXT:     FunctionDecl{{.*}} foo
727// CHECK-NEXT:   FriendDecl{{.*}} 'class A':'A'
728// CHECK-NEXT:   FriendDecl{{.*}} 'T'
729
730namespace TestFileScopeAsmDecl {
731  asm("ret");
732}
733// CHECK:      NamespaceDecl{{.*}} TestFileScopeAsmDecl{{$}}
734// CHECK:        FileScopeAsmDecl{{.*> .*$}}
735// CHECK-NEXT:     StringLiteral
736
737namespace TestFriendDecl2 {
738  void f();
739  struct S {
740    friend void f();
741  };
742}
743// CHECK: NamespaceDecl [[TestFriendDecl2:0x.*]] <{{.*}}> {{.*}} TestFriendDecl2
744// CHECK: |-FunctionDecl [[TestFriendDecl2_f:0x.*]] <{{.*}}> {{.*}} f 'void ()'
745// CHECK: `-CXXRecordDecl {{.*}} struct S
746// CHECK:   |-CXXRecordDecl {{.*}} struct S
747// CHECK:   `-FriendDecl
748// CHECK:     `-FunctionDecl {{.*}} parent [[TestFriendDecl2]] prev [[TestFriendDecl2_f]] <{{.*}}> {{.*}} f 'void ()'
749
750namespace Comment {
751  extern int Test;
752  /// Something here.
753  extern int Test;
754  extern int Test;
755}
756
757// CHECK: VarDecl {{.*}} Test 'int' extern
758// CHECK-NOT: FullComment
759// CHECK: VarDecl {{.*}} Test 'int' extern
760// CHECK: `-FullComment
761// CHECK:   `-ParagraphComment
762// CHECK:       `-TextComment
763// CHECK: VarDecl {{.*}} Test 'int' extern
764// CHECK-NOT: FullComment
765
CodeThinker, Enjoy your reading code