blob: d98bdb56d5bdcf3ee1ec5fea8486ae31816d423e [file] [log] [blame]
Richard Smith231dbd22013-04-15 08:02:05 +00001// 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
Alexander Kornienkod538ed92012-12-20 02:09:13 +00002
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
Richard Smith38afbc72013-04-13 02:43:54 +000095thread_local int TestThreadLocalInt;
96// CHECK: TestThreadLocalInt {{.*}} tls_dynamic
97
Alexander Kornienkod538ed92012-12-20 02:09:13 +000098__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
136class TestCXXConversionDecl {
137 operator int() { return 0; }
138};
139// CHECK: CXXConversionDecl{{.*}} operator int 'int (void)'
140// CHECK-NEXT: CompoundStmt
141
142namespace TestStaticAssertDecl {
143 static_assert(true, "msg");
144}
145// CHECK: NamespaceDecl{{.*}} TestStaticAssertDecl
146// CHECK-NEXT: StaticAssertDecl{{.*>$}}
147// CHECK-NEXT: CXXBoolLiteralExpr
148// CHECK-NEXT: StringLiteral
149
150namespace testFunctionTemplateDecl {
151 class A { };
152 class B { };
153 class C { };
154 class D { };
155 template<typename T> void TestFunctionTemplate(T) { }
156
157 // implicit instantiation
158 void bar(A a) { TestFunctionTemplate(a); }
159
160 // explicit specialization
161 template<> void TestFunctionTemplate(B);
162
163 // explicit instantiation declaration
164 extern template void TestFunctionTemplate(C);
165
166 // explicit instantiation definition
167 template void TestFunctionTemplate(D);
168}
169// CHECK: FunctionTemplateDecl{{.*}} TestFunctionTemplate
170// CHECK-NEXT: TemplateTypeParmDecl
171// CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate 'void (T)'
172// CHECK-NEXT: ParmVarDecl{{.*}} 'T'
173// CHECK-NEXT: CompoundStmt
174// CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}A
175// CHECK-NEXT: TemplateArgument
176// CHECK-NEXT: ParmVarDecl
177// CHECK-NEXT: CompoundStmt
178// CHECK-NEXT: Function{{.*}} 'TestFunctionTemplate' {{.*}}B
179// CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}C
180// CHECK-NEXT: TemplateArgument
181// CHECK-NEXT: ParmVarDecl
182// CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}D
183// CHECK-NEXT: TemplateArgument
184// CHECK-NEXT: ParmVarDecl
185// CHECK-NEXT: CompoundStmt
186// CHECK: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}B
187// CHECK-NEXT: TemplateArgument
188// CHECK-NEXT: ParmVarDecl
189
190namespace testClassTemplateDecl {
191 class A { };
192 class B { };
193 class C { };
194 class D { };
195
196 template<typename T> class TestClassTemplate {
197 int i;
198 };
199
200 // implicit instantiation
201 TestClassTemplate<A> a;
202
203 // explicit specialization
204 template<> class TestClassTemplate<B> {
205 int j;
206 };
207
208 // explicit instantiation declaration
209 extern template class TestClassTemplate<C>;
210
211 // explicit instantiation definition
212 template class TestClassTemplate<D>;
213
214 // partial explicit specialization
215 template<typename T1, typename T2> class TestClassTemplatePartial {
216 int i;
217 };
218 template<typename T1> class TestClassTemplatePartial<T1, A> {
219 int j;
220 };
221}
222// CHECK: ClassTemplateDecl{{.*}} TestClassTemplate
223// CHECK-NEXT: TemplateTypeParmDecl
224// CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate
225// CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate
226// CHECK-NEXT: FieldDecl{{.*}} i
227// CHECK-NEXT: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate
228// CHECK-NEXT: TemplateArgument{{.*}}A
229// CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate
230// CHECK-NEXT: FieldDecl{{.*}} i
231// CHECK: ClassTemplateSpecialization{{.*}} 'TestClassTemplate'
232// CHECK-NEXT: ClassTemplateSpecialization{{.*}} 'TestClassTemplate'
233// CHECK-NEXT: ClassTemplateSpecialization{{.*}} 'TestClassTemplate'
234
235// CHECK: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate
236// CHECK-NEXT: TemplateArgument{{.*}}B
237// CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate
238// CHECK-NEXT: FieldDecl{{.*}} j
239
240// CHECK: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate
241// CHECK-NEXT: TemplateArgument{{.*}}C
242// CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate
243// CHECK-NEXT: FieldDecl{{.*}} i
244
245// CHECK: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate
246// CHECK-NEXT: TemplateArgument{{.*}}D
247// CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate
248// CHECK-NEXT: FieldDecl{{.*}} i
249
250// CHECK: ClassTemplatePartialSpecializationDecl{{.*}} class TestClassTemplatePartial
251// CHECK-NEXT: TemplateArgument
252// CHECK-NEXT: TemplateArgument{{.*}}A
253// CHECK-NEXT: TemplateTypeParmDecl
254// CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplatePartial
255// CHECK-NEXT: FieldDecl{{.*}} j
256
Dmitri Gribenko4216ee12013-02-21 22:01:10 +0000257// PR15220 dump instantiation only once
258namespace testCanonicalTemplate {
259 class A {};
260
261 template<typename T> void TestFunctionTemplate(T);
262 template<typename T> void TestFunctionTemplate(T);
263 void bar(A a) { TestFunctionTemplate(a); }
264 // CHECK: FunctionTemplateDecl{{.*}} TestFunctionTemplate
265 // CHECK-NEXT: TemplateTypeParmDecl
266 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate 'void (T)'
267 // CHECK-NEXT: ParmVarDecl{{.*}} 'T'
268 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}A
269 // CHECK-NEXT: TemplateArgument
270 // CHECK-NEXT: ParmVarDecl
271 // CHECK: FunctionTemplateDecl{{.*}} TestFunctionTemplate
272 // CHECK-NEXT: TemplateTypeParmDecl
273 // CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate 'void (T)'
274 // CHECK-NEXT: ParmVarDecl{{.*}} 'T'
275 // CHECK-NEXT: Function{{.*}} 'TestFunctionTemplate'
276 // CHECK-NEXT-NOT: TemplateArgument
277
278 template<typename T1> class TestClassTemplate {
279 template<typename T2> friend class TestClassTemplate;
280 };
281 TestClassTemplate<A> a;
282 // CHECK: ClassTemplateDecl{{.*}} TestClassTemplate
283 // CHECK-NEXT: TemplateTypeParmDecl
284 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate
285 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate
286 // CHECK-NEXT: FriendDecl
287 // CHECK-NEXT: ClassTemplateDecl{{.*}} TestClassTemplate
288 // CHECK-NEXT: TemplateTypeParmDecl
289 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate
290 // CHECK-NEXT: ClassTemplateSpecialization{{.*}} 'TestClassTemplate'
291 // CHECK-NEXT: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate
292 // CHECK-NEXT: TemplateArgument{{.*}}A
293 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate
294}
295
Alexander Kornienkod538ed92012-12-20 02:09:13 +0000296template <class T>
297class TestClassScopeFunctionSpecialization {
298 template<class U> void foo(U a) { }
299 template<> void foo<int>(int a) { }
300};
301// CHECK: ClassScopeFunctionSpecializationDecl
302// CHECK-NEXT: CXXMethod{{.*}} 'foo' 'void (int)'
303// CHECK-NEXT: TemplateArgument{{.*}} 'int'
304
305namespace TestTemplateTypeParmDecl {
306 template<typename ... T, class U = int> void foo();
307}
308// CHECK: NamespaceDecl{{.*}} TestTemplateTypeParmDecl
309// CHECK-NEXT: FunctionTemplateDecl
310// CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename ... T
311// CHECK-NEXT: TemplateTypeParmDecl{{.*}} class U 'int'
312
313namespace TestNonTypeTemplateParmDecl {
314 template<int I = 1, int ... J> void foo();
315}
316// CHECK: NamespaceDecl{{.*}} TestNonTypeTemplateParmDecl
317// CHECK-NEXT: FunctionTemplateDecl
318// CHECK-NEXT: NonTypeTemplateParmDecl{{.*}} 'int' I
319// CHECK-NEXT: IntegerLiteral{{.*}} 'int' 1
320// CHECK-NEXT: NonTypeTemplateParmDecl{{.*}} 'int' ... J
321
322namespace TestTemplateTemplateParmDecl {
323 template<typename T> class A;
324 template <template <typename> class T = A, template <typename> class ... U> void foo();
325}
326// CHECK: NamespaceDecl{{.*}} TestTemplateTemplateParmDecl
327// CHECK: FunctionTemplateDecl
328// CHECK-NEXT: TemplateTemplateParmDecl{{.*}} T
329// CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename
330// CHECK-NEXT: TemplateArgument{{.*}} template A
331// CHECK-NEXT: TemplateTemplateParmDecl{{.*}} ... U
332// CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename
333
334namespace TestTemplateArgument {
335 template<typename> class A { };
336 template<template<typename> class ...> class B { };
337 int foo();
338
339 template<typename> class testType { };
340 template class testType<int>;
341 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testType
342 // CHECK-NEXT: TemplateArgument{{.*}} type 'int'
343
344 template<int fp(void)> class testDecl { };
345 template class testDecl<foo>;
346 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testDecl
347 // CHECK-NEXT: TemplateArgument{{.*}} decl
348 // CHECK-NEXT: Function{{.*}}foo
349
350 template class testDecl<nullptr>;
351 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testDecl
352 // CHECK-NEXT: TemplateArgument{{.*}} nullptr
353
354 template<int> class testIntegral { };
355 template class testIntegral<1>;
356 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testIntegral
357 // CHECK-NEXT: TemplateArgument{{.*}} integral 1
358
359 template<template<typename> class> class testTemplate { };
360 template class testTemplate<A>;
361 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testTemplate
362 // CHECK-NEXT: TemplateArgument{{.*}} A
363
364 template<template<typename> class ...T> class C {
365 B<T...> testTemplateExpansion;
366 };
367 // FIXME: Need TemplateSpecializationType dumping to test TemplateExpansion.
368
369 template<int, int = 0> class testExpr;
370 template<int I> class testExpr<I> { };
371 // CHECK: ClassTemplatePartialSpecializationDecl{{.*}} class testExpr
372 // CHECK-NEXT: TemplateArgument{{.*}} expr
373 // CHECK-NEXT: DeclRefExpr{{.*}}I
374
375 template<int, int ...> class testPack { };
376 template class testPack<0, 1, 2>;
377 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testPack
378 // CHECK-NEXT: TemplateArgument{{.*}} integral 0
379 // CHECK-NEXT: TemplateArgument{{.*}} pack
380 // CHECK-NEXT: TemplateArgument{{.*}} integral 1
381 // CHECK-NEXT: TemplateArgument{{.*}} integral 2
382}
383
384namespace testUsingDecl {
385 int i;
386}
387namespace TestUsingDecl {
388 using testUsingDecl::i;
389}
390// CHECK: NamespaceDecl{{.*}} TestUsingDecl
391// CHECK-NEXT: UsingDecl{{.*}} testUsingDecl::i
392// CHECK-NEXT: UsingShadowDecl{{.*}} Var{{.*}} 'i' 'int'
393
394namespace testUnresolvedUsing {
395 class A { };
396 template<class T> class B {
397 public:
398 A a;
399 };
400 template<class T> class TestUnresolvedUsing : public B<T> {
401 using typename B<T>::a;
402 using B<T>::a;
403 };
404}
405// CHECK: CXXRecordDecl{{.*}} TestUnresolvedUsing
406// CHECK: UnresolvedUsingTypenameDecl{{.*}} B<T>::a
407// CHECK: UnresolvedUsingValueDecl{{.*}} B<T>::a
408
409namespace TestLinkageSpecDecl {
410 extern "C" void test1();
411 extern "C++" void test2();
412}
413// CHECK: NamespaceDecl{{.*}} TestLinkageSpecDecl
414// CHECK-NEXT: LinkageSpecDecl{{.*}} C
415// CHECK-NEXT: FunctionDecl
416// CHECK-NEXT: LinkageSpecDecl{{.*}} C++
417// CHECK-NEXT: FunctionDecl
418
419class TestAccessSpecDecl {
420public:
421private:
422protected:
423};
424// CHECK: CXXRecordDecl{{.*}} class TestAccessSpecDecl
425// CHECK-NEXT: CXXRecordDecl{{.*}} class TestAccessSpecDecl
426// CHECK-NEXT: AccessSpecDecl{{.*}} public
427// CHECK-NEXT: AccessSpecDecl{{.*}} private
428// CHECK-NEXT: AccessSpecDecl{{.*}} protected
429
430template<typename T> class TestFriendDecl {
431 friend int foo();
432 friend class A;
433 friend T;
434};
435// CHECK: CXXRecord{{.*}} TestFriendDecl
436// CHECK-NEXT: CXXRecord{{.*}} TestFriendDecl
437// CHECK-NEXT: FriendDecl
438// CHECK-NEXT: FunctionDecl{{.*}} foo
439// CHECK-NEXT: FriendDecl{{.*}} 'class A':'class A'
440// CHECK-NEXT: FriendDecl{{.*}} 'T'
441
442namespace TestFileScopeAsmDecl {
443 asm("ret");
444}
445// CHECK: NamespaceDecl{{.*}} TestFileScopeAsmDecl{{$}}
446// CHECK: FileScopeAsmDecl{{.*>$}}
447// CHECK-NEXT: StringLiteral
Richard Smith4a190522013-02-07 01:35:44 +0000448
449namespace TestFriendDecl2 {
450 void f();
451 struct S {
452 friend void f();
453 };
454}
455// CHECK: NamespaceDecl [[TestFriendDecl2:0x.*]] <{{.*}}> TestFriendDecl2
456// CHECK: |-FunctionDecl [[TestFriendDecl2_f:0x.*]] <{{.*}}> f 'void (void)'
457// CHECK: `-CXXRecordDecl {{.*}} struct S
458// CHECK: |-CXXRecordDecl {{.*}} struct S
459// CHECK: `-FriendDecl
460// CHECK: `-FunctionDecl {{.*}} parent [[TestFriendDecl2]] prev [[TestFriendDecl2_f]] <{{.*}}> f 'void (void)'
Richard Smith0a74a4c2013-05-21 05:24:00 +0000461
462namespace Comment {
463 extern int Test;
464 /// Something here.
465 extern int Test;
466 extern int Test;
467}
468
469// CHECK: VarDecl {{.*}} Test 'int' extern
470// CHECK-NOT: FullComment
471// CHECK: VarDecl {{.*}} Test 'int' extern
472// CHECK: `-FullComment
473// CHECK: `-ParagraphComment
474// CHECK: `-TextComment
475// CHECK: VarDecl {{.*}} Test 'int' extern
476// CHECK-NOT: FullComment