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 { }; 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; 118 TestCXXConstructorDecl(A &a, int i) : A(a), I(i) { } 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 { 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 }; 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 { 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 { }; 185 template<typename T> void TestFunctionTemplate(T) { } 186 187 // implicit instantiation 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); 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 { 328 template<class U> void foo(U 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