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