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
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 { };
foo()18 A foo() {
19 A TestVarDeclNRVO;
20 return TestVarDeclNRVO;
21 }
22 }
23 // CHECK: VarDecl{{.*}} TestVarDeclNRVO 'class 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 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
88 template<class...T>
89 class TestCXXRecordDeclPack : public T... {
90 };
91 // CHECK: CXXRecordDecl{{.*}} class TestCXXRecordDeclPack
92 // CHECK-NEXT: public 'T'...
93 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestCXXRecordDeclPack
94
95 thread_local int TestThreadLocalInt;
96 // CHECK: TestThreadLocalInt {{.*}} tls_dynamic
97
98 __module_private__ class TestCXXRecordDeclPrivate;
99 // CHECK: CXXRecordDecl{{.*}} class TestCXXRecordDeclPrivate __module_private__
100
101 class 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
114 namespace testCXXConstructorDecl {
115 class A { };
116 class TestCXXConstructorDecl : public A {
117 int I;
TestCXXConstructorDecl(A & a,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
130 class TestCXXDestructorDecl {
~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".
138 class TestMemberRanges {
139 public:
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 };
SomeFunction()147 void 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
161 class TestCXXConversionDecl {
operator int()162 operator int() { return 0; }
163 };
164 // CHECK: CXXConversionDecl{{.*}} operator int 'int (void)'
165 // CHECK-NEXT: CompoundStmt
166
167 namespace TestStaticAssertDecl {
168 static_assert(true, "msg");
169 }
170 // CHECK: NamespaceDecl{{.*}} TestStaticAssertDecl
171 // CHECK-NEXT: StaticAssertDecl{{.*> .*$}}
172 // CHECK-NEXT: CXXBoolLiteralExpr
173 // CHECK-NEXT: StringLiteral
174
175 namespace testFunctionTemplateDecl {
176 class A { };
177 class B { };
178 class C { };
179 class D { };
TestFunctionTemplate(T)180 template<typename T> void TestFunctionTemplate(T) { }
181
182 // implicit instantiation
bar(A a)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
215 namespace 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
283 namespace testCanonicalTemplate {
284 class A {};
285
286 template<typename T> void TestFunctionTemplate(T);
287 template<typename T> void TestFunctionTemplate(T);
bar(A a)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
321 template <class T>
322 class TestClassScopeFunctionSpecialization {
foo(U a)323 template<class U> void foo(U a) { }
foo(int 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
330 namespace 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
339 namespace 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
349 namespace 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
361 namespace 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
411 namespace testUsingDecl {
412 int i;
413 }
414 namespace TestUsingDecl {
415 using testUsingDecl::i;
416 }
417 // CHECK: NamespaceDecl{{.*}} TestUsingDecl
418 // CHECK-NEXT: UsingDecl{{.*}} testUsingDecl::i
419 // CHECK-NEXT: UsingShadowDecl{{.*}} Var{{.*}} 'i' 'int'
420
421 namespace 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
436 namespace 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
446 class TestAccessSpecDecl {
447 public:
448 private:
449 protected:
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
457 template<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
469 namespace TestFileScopeAsmDecl {
470 asm("ret");
471 }
472 // CHECK: NamespaceDecl{{.*}} TestFileScopeAsmDecl{{$}}
473 // CHECK: FileScopeAsmDecl{{.*> .*$}}
474 // CHECK-NEXT: StringLiteral
475
476 namespace 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
489 namespace 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