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