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