1 // Test without serialization: 2 // RUN: %clang_cc1 -std=c++11 -triple x86_64-linux-gnu -fms-extensions \ 3 // RUN: -ast-dump -ast-dump-filter Test %s \ 4 // RUN: | FileCheck --strict-whitespace %s 5 // 6 // Test with serialization: FIXME: Find why the outputs differs and fix it! 7 // : %clang_cc1 -std=c++11 -triple x86_64-linux-gnu -fms-extensions -emit-pch -o %t %s 8 // : %clang_cc1 -x c++ -std=c++11 -triple x86_64-linux-gnu -fms-extensions -include-pch %t \ 9 // : -ast-dump-all -ast-dump-filter Test /dev/null \ 10 // : | sed -e "s/ <undeserialized declarations>//" -e "s/ imported//" \ 11 // : | FileCheck --strict-whitespace %s 12 13 class testEnumDecl { 14 enum class TestEnumDeclScoped; 15 enum TestEnumDeclFixed : int; 16 }; 17 // CHECK: EnumDecl{{.*}} class TestEnumDeclScoped 'int' 18 // CHECK: EnumDecl{{.*}} TestEnumDeclFixed 'int' 19 20 class testFieldDecl { 21 int TestFieldDeclInit = 0; 22 }; 23 // CHECK: FieldDecl{{.*}} TestFieldDeclInit 'int' 24 // CHECK-NEXT: IntegerLiteral 25 26 namespace testVarDeclNRVO { 27 class A { }; 28 A TestFuncNRVO() { 29 A TestVarDeclNRVO; 30 return TestVarDeclNRVO; 31 } 32 } 33 // CHECK: FunctionDecl{{.*}} TestFuncNRVO 'A ()' 34 // CHECK-NEXT: `-CompoundStmt 35 // CHECK-NEXT: |-DeclStmt 36 // CHECK-NEXT: | `-VarDecl{{.*}} TestVarDeclNRVO 'A':'testVarDeclNRVO::A' nrvo callinit 37 // CHECK-NEXT: | `-CXXConstructExpr 38 // CHECK-NEXT: `-ReturnStmt{{.*}} nrvo_candidate(Var {{.*}} 'TestVarDeclNRVO' 'A':'testVarDeclNRVO::A') 39 40 void testParmVarDeclInit(int TestParmVarDeclInit = 0); 41 // CHECK: ParmVarDecl{{.*}} TestParmVarDeclInit 'int' 42 // CHECK-NEXT: IntegerLiteral{{.*}} 43 44 namespace TestNamespaceDecl { 45 int i; 46 } 47 // CHECK: NamespaceDecl{{.*}} TestNamespaceDecl 48 // CHECK-NEXT: VarDecl 49 50 namespace TestNamespaceDecl { 51 int j; 52 } 53 // CHECK: NamespaceDecl{{.*}} TestNamespaceDecl 54 // CHECK-NEXT: original Namespace 55 // CHECK-NEXT: VarDecl 56 57 inline namespace TestNamespaceDeclInline { 58 } 59 // CHECK: NamespaceDecl{{.*}} TestNamespaceDeclInline inline 60 61 namespace TestNestedNameSpace::Nested { 62 } 63 // CHECK: NamespaceDecl{{.*}} TestNestedNameSpace 64 // CHECK: NamespaceDecl{{.*}} Nested nested{{\s*$}} 65 66 namespace TestMultipleNested::SecondLevelNested::Nested { 67 } 68 // CHECK: NamespaceDecl{{.*}} TestMultipleNested 69 // CHECK: NamespaceDecl{{.*}} SecondLevelNested nested 70 // CHECK: NamespaceDecl{{.*}} Nested nested{{\s*$}} 71 72 namespace TestInlineNested::inline SecondLevel::inline Nested { 73 } 74 // CHECK: NamespaceDecl{{.*}} TestInlineNested 75 // CHECK: NamespaceDecl{{.*}} SecondLevel inline nested 76 // CHECK: NamespaceDecl{{.*}} Nested inline nested{{\s*$}} 77 78 namespace testUsingDirectiveDecl { 79 namespace A { 80 } 81 } 82 namespace TestUsingDirectiveDecl { 83 using namespace testUsingDirectiveDecl::A; 84 } 85 // CHECK: NamespaceDecl{{.*}} TestUsingDirectiveDecl 86 // CHECK-NEXT: UsingDirectiveDecl{{.*}} Namespace{{.*}} 'A' 87 88 namespace testNamespaceAlias { 89 namespace A { 90 } 91 } 92 namespace TestNamespaceAlias = testNamespaceAlias::A; 93 // CHECK: NamespaceAliasDecl{{.*}} TestNamespaceAlias 94 // CHECK-NEXT: Namespace{{.*}} 'A' 95 96 using TestTypeAliasDecl = int; 97 // CHECK: TypeAliasDecl{{.*}} TestTypeAliasDecl 'int' 98 99 namespace testTypeAliasTemplateDecl { 100 template<typename T> class A; 101 template<typename T> using TestTypeAliasTemplateDecl = A<T>; 102 } 103 // CHECK: TypeAliasTemplateDecl{{.*}} TestTypeAliasTemplateDecl 104 // CHECK-NEXT: TemplateTypeParmDecl 105 // CHECK-NEXT: TypeAliasDecl{{.*}} TestTypeAliasTemplateDecl 'A<T>' 106 107 namespace testCXXRecordDecl { 108 class TestEmpty {}; 109 // CHECK: CXXRecordDecl{{.*}} class TestEmpty 110 // CHECK-NEXT: DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init 111 // CHECK-NEXT: DefaultConstructor exists trivial constexpr 112 // CHECK-NEXT: CopyConstructor simple trivial has_const_param 113 // CHECK-NEXT: MoveConstructor exists simple trivial 114 // CHECK-NEXT: CopyAssignment simple trivial has_const_param 115 // CHECK-NEXT: MoveAssignment exists simple trivial 116 // CHECK-NEXT: Destructor simple irrelevant trivial 117 118 class A { }; 119 class B { }; 120 class TestCXXRecordDecl : virtual A, public B { 121 int i; 122 }; 123 } 124 // CHECK: CXXRecordDecl{{.*}} class TestCXXRecordDecl 125 // CHECK-NEXT: DefinitionData{{$}} 126 // CHECK-NEXT: DefaultConstructor exists non_trivial 127 // CHECK-NEXT: CopyConstructor simple non_trivial has_const_param 128 // CHECK-NEXT: MoveConstructor exists simple non_trivial 129 // CHECK-NEXT: CopyAssignment simple non_trivial has_const_param 130 // CHECK-NEXT: MoveAssignment exists simple non_trivial 131 // CHECK-NEXT: Destructor simple irrelevant trivial 132 // CHECK-NEXT: virtual private 'A':'testCXXRecordDecl::A' 133 // CHECK-NEXT: public 'B':'testCXXRecordDecl::B' 134 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestCXXRecordDecl 135 // CHECK-NEXT: FieldDecl 136 137 template<class...T> 138 class TestCXXRecordDeclPack : public T... { 139 }; 140 // CHECK: CXXRecordDecl{{.*}} class TestCXXRecordDeclPack 141 // CHECK: public 'T'... 142 // CHECK-NEXT: CXXRecordDecl{{.*}} class TestCXXRecordDeclPack 143 144 thread_local int TestThreadLocalInt; 145 // CHECK: TestThreadLocalInt {{.*}} tls_dynamic 146 147 class testCXXMethodDecl { 148 virtual void TestCXXMethodDeclPure() = 0; 149 void TestCXXMethodDeclDelete() = delete; 150 void TestCXXMethodDeclThrow() throw(); 151 void TestCXXMethodDeclThrowType() throw(int); 152 }; 153 // CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclPure 'void ()' virtual pure 154 // CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclDelete 'void ()' delete 155 // CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclThrow 'void () throw()' 156 // CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclThrowType 'void () throw(int)' 157 158 namespace testCXXConstructorDecl { 159 class A { }; 160 class TestCXXConstructorDecl : public A { 161 int I; 162 TestCXXConstructorDecl(A &a, int i) : A(a), I(i) { } 163 TestCXXConstructorDecl(A &a) : TestCXXConstructorDecl(a, 0) { } 164 }; 165 } 166 // CHECK: CXXConstructorDecl{{.*}} TestCXXConstructorDecl 'void {{.*}}' 167 // CHECK-NEXT: ParmVarDecl{{.*}} a 168 // CHECK-NEXT: ParmVarDecl{{.*}} i 169 // CHECK-NEXT: CXXCtorInitializer{{.*}}A 170 // CHECK-NEXT: Expr 171 // CHECK: CXXCtorInitializer{{.*}}I 172 // CHECK-NEXT: Expr 173 // CHECK: CompoundStmt 174 // CHECK: CXXConstructorDecl{{.*}} TestCXXConstructorDecl 'void {{.*}}' 175 // CHECK-NEXT: ParmVarDecl{{.*}} a 176 // CHECK-NEXT: CXXCtorInitializer{{.*}}TestCXXConstructorDecl 177 // CHECK-NEXT: CXXConstructExpr{{.*}}TestCXXConstructorDecl 178 179 class TestCXXDestructorDecl { 180 ~TestCXXDestructorDecl() { } 181 }; 182 // CHECK: CXXDestructorDecl{{.*}} ~TestCXXDestructorDecl 'void () noexcept' 183 // CHECK-NEXT: CompoundStmt 184 185 // Test that the range of a defaulted members is computed correctly. 186 class TestMemberRanges { 187 public: 188 TestMemberRanges() = default; 189 TestMemberRanges(const TestMemberRanges &Other) = default; 190 TestMemberRanges(TestMemberRanges &&Other) = default; 191 ~TestMemberRanges() = default; 192 TestMemberRanges &operator=(const TestMemberRanges &Other) = default; 193 TestMemberRanges &operator=(TestMemberRanges &&Other) = default; 194 }; 195 void SomeFunction() { 196 TestMemberRanges A; 197 TestMemberRanges B(A); 198 B = A; 199 A = static_cast<TestMemberRanges &&>(B); 200 TestMemberRanges C(static_cast<TestMemberRanges &&>(A)); 201 } 202 // CHECK: CXXConstructorDecl{{.*}} <line:{{.*}}:3, col:30> 203 // CHECK: CXXConstructorDecl{{.*}} <line:{{.*}}:3, col:59> 204 // CHECK: CXXConstructorDecl{{.*}} <line:{{.*}}:3, col:54> 205 // CHECK: CXXDestructorDecl{{.*}} <line:{{.*}}:3, col:31> 206 // CHECK: CXXMethodDecl{{.*}} <line:{{.*}}:3, col:70> 207 // CHECK: CXXMethodDecl{{.*}} <line:{{.*}}:3, col:65> 208 209 class TestCXXConversionDecl { 210 operator int() { return 0; } 211 }; 212 // CHECK: CXXConversionDecl{{.*}} operator int 'int ()' 213 // CHECK-NEXT: CompoundStmt 214 215 namespace TestStaticAssertDecl { 216 static_assert(true, "msg"); 217 } 218 // CHECK: NamespaceDecl{{.*}} TestStaticAssertDecl 219 // CHECK-NEXT: StaticAssertDecl{{.*> .*$}} 220 // CHECK-NEXT: CXXBoolLiteralExpr 221 // CHECK-NEXT: StringLiteral 222 223 namespace testFunctionTemplateDecl { 224 class A { }; 225 class B { }; 226 class C { }; 227 class D { }; 228 template<typename T> void TestFunctionTemplate(T) { } 229 230 // implicit instantiation 231 void bar(A a) { TestFunctionTemplate(a); } 232 233 // explicit specialization 234 template<> void TestFunctionTemplate(B); 235 236 // explicit instantiation declaration 237 extern template void TestFunctionTemplate(C); 238 239 // explicit instantiation definition 240 template void TestFunctionTemplate(D); 241 } 242 // CHECK: FunctionTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-14]]:3, col:55> col:29 TestFunctionTemplate 243 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 referenced typename depth 0 index 0 T 244 // CHECK-NEXT: |-FunctionDecl 0x{{.+}} <col:24, col:55> col:29 TestFunctionTemplate 'void (T)' 245 // CHECK-NEXT: | |-ParmVarDecl 0x{{.+}} <col:50> col:51 'T' 246 // CHECK-NEXT: | `-CompoundStmt 0x{{.+}} <col:53, col:55> 247 // CHECK-NEXT: |-FunctionDecl 0x{{.+}} <col:24, col:55> col:29 used TestFunctionTemplate 'void (testFunctionTemplateDecl::A)' 248 // CHECK-NEXT: | |-TemplateArgument type 'testFunctionTemplateDecl::A' 249 // CHECK-NEXT: | | `-RecordType 0{{.+}} 'testFunctionTemplateDecl::A' 250 // CHECK-NEXT: | | `-CXXRecord 0x{{.+}} 'A' 251 // CHECK-NEXT: | |-ParmVarDecl 0x{{.+}} <col:50> col:51 'testFunctionTemplateDecl::A' 252 // CHECK-NEXT: | `-CompoundStmt 0x{{.+}} <col:53, col:55> 253 // CHECK-NEXT: |-Function 0x{{.+}} 'TestFunctionTemplate' 'void (B)' 254 // CHECK-NEXT: |-FunctionDecl 0x{{.+}} <col:24, col:55> col:29 TestFunctionTemplate 'void (testFunctionTemplateDecl::C)' 255 // CHECK-NEXT: | |-TemplateArgument type 'testFunctionTemplateDecl::C' 256 // CHECK-NEXT: | | `-RecordType 0{{.+}} 'testFunctionTemplateDecl::C' 257 // CHECK-NEXT: | | `-CXXRecord 0x{{.+}} 'C' 258 // CHECK-NEXT: | `-ParmVarDecl 0x{{.+}} <col:50> col:51 'testFunctionTemplateDecl::C' 259 // CHECK-NEXT: `-FunctionDecl 0x{{.+}} <col:24, col:55> col:29 TestFunctionTemplate 'void (testFunctionTemplateDecl::D)' 260 // CHECK-NEXT: |-TemplateArgument type 'testFunctionTemplateDecl::D' 261 // CHECK-NEXT: | `-RecordType 0{{.+}} 'testFunctionTemplateDecl::D' 262 // CHECK-NEXT: | `-CXXRecord 0x{{.+}} 'D' 263 // CHECK-NEXT: |-ParmVarDecl 0x{{.+}} <col:50> col:51 'testFunctionTemplateDecl::D' 264 // CHECK-NEXT: `-CompoundStmt 0x{{.+}} <col:53, col:55> 265 266 // CHECK: FunctionDecl 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-32]]:3, col:41> col:19 TestFunctionTemplate 'void (B)' 267 // CHECK-NEXT: |-TemplateArgument type 'testFunctionTemplateDecl::B' 268 // CHECK-NEXT: | `-RecordType 0{{.+}} 'testFunctionTemplateDecl::B' 269 // CHECK-NEXT: | `-CXXRecord 0x{{.+}} 'B' 270 // CHECK-NEXT: `-ParmVarDecl 0x{{.+}} <col:40> col:41 'B':'testFunctionTemplateDecl::B' 271 272 273 namespace testClassTemplateDecl { 274 class A { }; 275 class B { }; 276 class C { }; 277 class D { }; 278 279 template<typename T> class TestClassTemplate { 280 public: 281 TestClassTemplate(); 282 ~TestClassTemplate(); 283 int j(); 284 int i; 285 }; 286 287 // implicit instantiation 288 TestClassTemplate<A> a; 289 290 // explicit specialization 291 template<> class TestClassTemplate<B> { 292 int j; 293 }; 294 295 // explicit instantiation declaration 296 extern template class TestClassTemplate<C>; 297 298 // explicit instantiation definition 299 template class TestClassTemplate<D>; 300 301 // partial explicit specialization 302 template<typename T1, typename T2> class TestClassTemplatePartial { 303 int i; 304 }; 305 template<typename T1> class TestClassTemplatePartial<T1, A> { 306 int j; 307 }; 308 309 template<typename T = int> struct TestTemplateDefaultType; 310 template<typename T> struct TestTemplateDefaultType { }; 311 312 template<int I = 42> struct TestTemplateDefaultNonType; 313 template<int I> struct TestTemplateDefaultNonType { }; 314 315 template<template<typename> class TT = TestClassTemplate> struct TestTemplateTemplateDefaultType; 316 template<template<typename> class TT> struct TestTemplateTemplateDefaultType { }; 317 } 318 319 // CHECK: ClassTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-40]]:3, line:[[@LINE-34]]:3> line:[[@LINE-40]]:30 TestClassTemplate{{$}} 320 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T{{$}} 321 // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} <col:24, line:[[@LINE-36]]:3> line:[[@LINE-42]]:30 class TestClassTemplate definition{{$}} 322 // CHECK-NEXT: | |-DefinitionData standard_layout has_user_declared_ctor can_const_default_init{{$}} 323 // CHECK-NEXT: | | |-DefaultConstructor exists non_trivial user_provided{{$}} 324 // CHECK-NEXT: | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 325 // CHECK-NEXT: | | |-MoveConstructor{{$}} 326 // CHECK-NEXT: | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 327 // CHECK-NEXT: | | |-MoveAssignment{{$}} 328 // CHECK-NEXT: | | `-Destructor irrelevant non_trivial user_declared{{$}} 329 // CHECK-NEXT: | |-CXXRecordDecl 0x{{.+}} <col:24, col:30> col:30 implicit referenced class TestClassTemplate{{$}} 330 // CHECK-NEXT: | |-AccessSpecDecl 0x{{.+}} <line:[[@LINE-50]]:3, col:9> col:3 public{{$}} 331 // CHECK-NEXT: | |-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-50]]:5, col:23> col:5 TestClassTemplate<T> 'void ()'{{$}} 332 // CHECK-NEXT: | |-CXXDestructorDecl 0x{{.+}} <line:[[@LINE-50]]:5, col:24> col:5 ~TestClassTemplate<T> 'void ()' not_selected{{$}} 333 // CHECK-NEXT: | |-CXXMethodDecl 0x{{.+}} <line:[[@LINE-50]]:5, col:11> col:9 j 'int ()'{{$}} 334 // CHECK-NEXT: | `-FieldDecl 0x{{.+}} <line:[[@LINE-50]]:5, col:9> col:9 i 'int'{{$}} 335 // CHECK-NEXT: |-ClassTemplateSpecializationDecl 0x{{.+}} <line:[[@LINE-56]]:3, line:[[@LINE-50]]:3> line:[[@LINE-56]]:30 class TestClassTemplate definition implicit_instantiation{{$}} 336 // CHECK-NEXT: | |-DefinitionData standard_layout has_user_declared_ctor can_const_default_init{{$}} 337 // CHECK-NEXT: | | |-DefaultConstructor exists non_trivial user_provided{{$}} 338 // CHECK-NEXT: | | |-CopyConstructor simple trivial has_const_param implicit_has_const_param{{$}} 339 // CHECK-NEXT: | | |-MoveConstructor{{$}} 340 // CHECK-NEXT: | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 341 // CHECK-NEXT: | | |-MoveAssignment{{$}} 342 // CHECK-NEXT: | | `-Destructor non_trivial user_declared{{$}} 343 // CHECK-NEXT: | |-TemplateArgument type 'testClassTemplateDecl::A'{{$}} 344 // CHECK-NEXT: | | `-RecordType 0{{.+}} 'testClassTemplateDecl::A'{{$}} 345 // CHECK-NEXT: | | `-CXXRecord 0x{{.+}} 'A'{{$}} 346 // CHECK-NEXT: | |-CXXRecordDecl 0x{{.+}} <col:24, col:30> col:30 implicit class TestClassTemplate{{$}} 347 // CHECK-NEXT: | |-AccessSpecDecl 0x{{.+}} <line:[[@LINE-67]]:3, col:9> col:3 public{{$}} 348 // CHECK-NEXT: | |-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-67]]:5, col:23> col:5 used TestClassTemplate 'void ()' implicit_instantiation instantiated_from {{0x[^ ]+}}{{$}} 349 // CHECK-NEXT: | |-CXXDestructorDecl 0x{{.+}} <line:[[@LINE-67]]:5, col:24> col:5 used ~TestClassTemplate 'void () noexcept' implicit_instantiation instantiated_from {{0x[^ ]+}}{{$}} 350 // CHECK-NEXT: | |-CXXMethodDecl 0x{{.+}} <line:[[@LINE-67]]:5, col:11> col:9 j 'int ()' implicit_instantiation instantiated_from {{0x[^ ]+}}{{$}} 351 // CHECK-NEXT: | |-FieldDecl 0x{{.+}} <line:[[@LINE-67]]:5, col:9> col:9 i 'int'{{$}} 352 // CHECK-NEXT: | `-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-73]]:30> col:30 implicit constexpr TestClassTemplate 'void (const TestClassTemplate<A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}{{$}} 353 // CHECK-NEXT: | `-ParmVarDecl 0x{{.+}} <col:30> col:30 'const TestClassTemplate<A> &'{{$}} 354 // CHECK-NEXT: |-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate'{{$}} 355 // CHECK-NEXT: |-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate'{{$}} 356 // CHECK-NEXT: `-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate'{{$}} 357 358 // CHECK: ClassTemplateSpecializationDecl 0x{{.+}} <{{.+}}:[[@LINE-67]]:3, line:[[@LINE-65]]:3> line:[[@LINE-67]]:20 class TestClassTemplate definition explicit_specialization{{$}} 359 // CHECK-NEXT: |-DefinitionData pass_in_registers standard_layout trivially_copyable trivial literal{{$}} 360 // CHECK-NEXT: | |-DefaultConstructor exists trivial needs_implicit{{$}} 361 // CHECK-NEXT: | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 362 // CHECK-NEXT: | |-MoveConstructor exists simple trivial needs_implicit{{$}} 363 // CHECK-NEXT: | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 364 // CHECK-NEXT: | |-MoveAssignment exists simple trivial needs_implicit{{$}} 365 // CHECK-NEXT: | `-Destructor simple irrelevant trivial needs_implicit{{$}} 366 // CHECK-NEXT: |-TemplateArgument type 'testClassTemplateDecl::B'{{$}} 367 // CHECK-NEXT: | `-RecordType 0{{.+}} 'testClassTemplateDecl::B'{{$}} 368 // CHECK-NEXT: | `-CXXRecord 0x{{.+}} 'B'{{$}} 369 // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} <col:14, col:20> col:20 implicit class TestClassTemplate{{$}} 370 // CHECK-NEXT: `-FieldDecl 0x{{.+}} <line:[[@LINE-78]]:5, col:9> col:9 j 'int'{{$}} 371 372 // CHECK: ClassTemplateSpecializationDecl 0x{{.+}} <{{.+}}:{{.*}}:3, col:44> col:25 class TestClassTemplate definition explicit_instantiation_declaration{{$}} 373 // CHECK-NEXT: |-DefinitionData standard_layout has_user_declared_ctor can_const_default_init{{$}} 374 // CHECK-NEXT: | |-DefaultConstructor exists non_trivial user_provided{{$}} 375 // CHECK-NEXT: | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 376 // CHECK-NEXT: | |-MoveConstructor{{$}} 377 // CHECK-NEXT: | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 378 // CHECK-NEXT: | |-MoveAssignment{{$}} 379 // CHECK-NEXT: | `-Destructor non_trivial user_declared{{$}} 380 // CHECK-NEXT: |-TemplateArgument type 'testClassTemplateDecl::C'{{$}} 381 // CHECK-NEXT: | `-RecordType 0{{.+}} 'testClassTemplateDecl::C'{{$}} 382 // CHECK-NEXT: | `-CXXRecord 0x{{.+}} 'C'{{$}} 383 // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} <line:[[@LINE-104]]:24, col:30> col:30 implicit class TestClassTemplate{{$}} 384 // CHECK-NEXT: |-AccessSpecDecl 0x{{.+}} <line:[[@LINE-104]]:3, col:9> col:3 public{{$}} 385 // CHECK-NEXT: |-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-104]]:5, col:23> col:5 TestClassTemplate 'void ()' explicit_instantiation_declaration instantiated_from {{0x[^ ]+}}{{$}} 386 // CHECK-NEXT: |-CXXDestructorDecl 0x{{.+}} <line:[[@LINE-104]]:5, col:24> col:5 ~TestClassTemplate 'void ()' explicit_instantiation_declaration noexcept-unevaluated 0x{{[^ ]+}} instantiated_from {{0x[^ ]+}} 387 // CHECK-NEXT: |-CXXMethodDecl 0x{{.+}} <line:[[@LINE-104]]:5, col:11> col:9 j 'int ()' explicit_instantiation_declaration instantiated_from {{0x[^ ]+}}{{$}} 388 // CHECK-NEXT: `-FieldDecl 0x{{.+}} <line:[[@LINE-104]]:5, col:9> col:9 i 'int'{{$}} 389 390 // CHECK: ClassTemplateSpecializationDecl 0x{{.+}} <{{.+}}:[[@LINE-91]]:3, col:37> col:18 class TestClassTemplate definition explicit_instantiation_definition{{$}} 391 // CHECK-NEXT: |-DefinitionData standard_layout has_user_declared_ctor can_const_default_init{{$}} 392 // CHECK-NEXT: | |-DefaultConstructor exists non_trivial user_provided{{$}} 393 // CHECK-NEXT: | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 394 // CHECK-NEXT: | |-MoveConstructor{{$}} 395 // CHECK-NEXT: | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 396 // CHECK-NEXT: | |-MoveAssignment{{$}} 397 // CHECK-NEXT: | `-Destructor non_trivial user_declared{{$}} 398 // CHECK-NEXT: |-TemplateArgument type 'testClassTemplateDecl::D'{{$}} 399 // CHECK-NEXT: | `-RecordType 0{{.+}} 'testClassTemplateDecl::D'{{$}} 400 // CHECK-NEXT: | `-CXXRecord 0x{{.+}} 'D'{{$}} 401 // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} <line:[[@LINE-122]]:24, col:30> col:30 implicit class TestClassTemplate{{$}} 402 // CHECK-NEXT: |-AccessSpecDecl 0x{{.+}} <line:[[@LINE-122]]:3, col:9> col:3 public{{$}} 403 // CHECK-NEXT: |-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-122]]:5, col:23> col:5 TestClassTemplate 'void ()' implicit_instantiation instantiated_from {{0x[^ ]+}}{{$}} 404 // CHECK-NEXT: |-CXXDestructorDecl 0x{{.+}} <line:[[@LINE-122]]:5, col:24> col:5 ~TestClassTemplate 'void ()' implicit_instantiation noexcept-unevaluated 0x{{.+}} instantiated_from {{0x[^ ]+}}{{$}} 405 // CHECK-NEXT: |-CXXMethodDecl 0x{{.+}} <line:[[@LINE-122]]:5, col:11> col:9 j 'int ()' implicit_instantiation instantiated_from {{0x[^ ]+}}{{$}} 406 // CHECK-NEXT: `-FieldDecl 0x{{.+}} <line:[[@LINE-122]]:5, col:9> col:9 i 'int'{{$}} 407 408 // CHECK: ClassTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-106]]:3, line:[[@LINE-104]]:3> line:[[@LINE-106]]:44 TestClassTemplatePartial{{$}} 409 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T1{{$}} 410 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:25, col:34> col:34 typename depth 0 index 1 T2{{$}} 411 // CHECK-NEXT: `-CXXRecordDecl 0x{{.+}} <col:38, line:[[@LINE-107]]:3> line:[[@LINE-109]]:44 class TestClassTemplatePartial definition{{$}} 412 // CHECK-NEXT: |-DefinitionData standard_layout trivially_copyable trivial literal{{$}} 413 // CHECK-NEXT: | |-DefaultConstructor exists trivial needs_implicit{{$}} 414 // CHECK-NEXT: | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 415 // CHECK-NEXT: | |-MoveConstructor exists simple trivial needs_implicit{{$}} 416 // CHECK-NEXT: | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 417 // CHECK-NEXT: | |-MoveAssignment exists simple trivial needs_implicit{{$}} 418 // CHECK-NEXT: | `-Destructor simple irrelevant trivial needs_implicit{{$}} 419 // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} <col:38, col:44> col:44 implicit class TestClassTemplatePartial{{$}} 420 // CHECK-NEXT: `-FieldDecl 0x{{.+}} <line:[[@LINE-117]]:5, col:9> col:9 i 'int'{{$}} 421 422 // CHECK: ClassTemplatePartialSpecializationDecl 0x{{.+}} <{{.+}}:[[@LINE-117]]:3, line:[[@LINE-115]]:3> line:[[@LINE-117]]:31 class TestClassTemplatePartial definition explicit_specialization{{$}} 423 // CHECK-NEXT: |-DefinitionData standard_layout trivially_copyable trivial literal{{$}} 424 // CHECK-NEXT: | |-DefaultConstructor exists trivial needs_implicit{{$}} 425 // CHECK-NEXT: | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 426 // CHECK-NEXT: | |-MoveConstructor exists simple trivial needs_implicit{{$}} 427 // CHECK-NEXT: | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 428 // CHECK-NEXT: | |-MoveAssignment exists simple trivial needs_implicit{{$}} 429 // CHECK-NEXT: | `-Destructor simple irrelevant trivial needs_implicit{{$}} 430 // CHECK-NEXT: |-TemplateArgument type 'type-parameter-0-0'{{$}} 431 // CHECK-NEXT: | `-TemplateTypeParmType 0x{{.+}} 'type-parameter-0-0' dependent depth 0 index 0{{$}} 432 // CHECK-NEXT: |-TemplateArgument type 'testClassTemplateDecl::A'{{$}} 433 // CHECK-NEXT: | `-RecordType 0x{{.+}} 'testClassTemplateDecl::A'{{$}} 434 // CHECK-NEXT: | `-CXXRecord 0x{{.+}} 'A'{{$}} 435 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 referenced typename depth 0 index 0 T1{{$}} 436 // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} <col:25, col:31> col:31 implicit class TestClassTemplatePartial{{$}} 437 // CHECK-NEXT: `-FieldDecl 0x{{.+}} <line:[[@LINE-131]]:5, col:9> col:9 j 'int'{{$}} 438 439 // CHECK: ClassTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-130]]:3, col:37> col:37 TestTemplateDefaultType{{$}} 440 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:25> col:21 typename depth 0 index 0 T{{$}} 441 // CHECK-NEXT: | `-TemplateArgument type 'int'{{$}} 442 // CHECK-NEXT: | `-BuiltinType 0x{{.+}} 'int'{{$}} 443 // CHECK-NEXT: `-CXXRecordDecl 0x{{.+}} <col:30, col:37> col:37 struct TestTemplateDefaultType{{$}} 444 445 // CHECK: ClassTemplateDecl 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-135]]:3, col:57> col:31 TestTemplateDefaultType{{$}} 446 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T{{$}} 447 // CHECK-NEXT: | `-TemplateArgument type 'int'{{$}} 448 // CHECK-NEXT: | |-inherited from TemplateTypeParm 0x{{.+}} 'T'{{$}} 449 // CHECK-NEXT: | `-BuiltinType 0x{{.+}} 'int'{{$}} 450 // CHECK-NEXT: `-CXXRecordDecl 0x{{.+}} prev 0x{{.+}} <col:24, col:57> col:31 struct TestTemplateDefaultType definition{{$}} 451 // CHECK-NEXT: |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init{{$}} 452 // CHECK-NEXT: | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr{{$}} 453 // CHECK-NEXT: | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 454 // CHECK-NEXT: | |-MoveConstructor exists simple trivial needs_implicit{{$}} 455 // CHECK-NEXT: | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 456 // CHECK-NEXT: | |-MoveAssignment exists simple trivial needs_implicit{{$}} 457 // CHECK-NEXT: | `-Destructor simple irrelevant trivial needs_implicit{{$}} 458 // CHECK-NEXT: `-CXXRecordDecl 0x{{.+}} <col:24, col:31> col:31 implicit struct TestTemplateDefaultType{{$}} 459 460 // CHECK: ClassTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-148]]:3, col:31> col:31 TestTemplateDefaultNonType{{$}} 461 // CHECK-NEXT: |-NonTypeTemplateParmDecl 0x{{.+}} <col:12, col:20> col:16 'int' depth 0 index 0 I{{$}} 462 // CHECK-NEXT: | `-TemplateArgument <col:20> expr '42'{{$}} 463 // CHECK-NEXT: | `-IntegerLiteral 0x{{.+}} <col:20> 'int' 42{{$}} 464 // CHECK-NEXT: `-CXXRecordDecl 0x{{.+}} <col:24, col:31> col:31 struct TestTemplateDefaultNonType{{$}} 465 466 // CHECK: ClassTemplateDecl 0x{{.+}} <{{.+}}:{{.*}}:3, col:68> col:68 TestTemplateTemplateDefaultType{{$}} 467 // CHECK-NEXT: |-TemplateTemplateParmDecl 0x{{.+}} <col:12, col:42> col:37 depth 0 index 0 TT{{$}} 468 // CHECK-NEXT: | |-TemplateTypeParmDecl 0x{{.+}} <col:21> col:29 typename depth 1 index 0{{$}} 469 // CHECK-NEXT: | `-TemplateArgument <col:42> template 'TestClassTemplate':'testClassTemplateDecl::TestClassTemplate' qualified{{$}} 470 // CHECK-NEXT: | `-ClassTemplateDecl 0x{{.+}} <line:{{.+}}:3, line:{{.+}}:3> line:{{.+}}:30 TestClassTemplate{{$}} 471 // CHECK-NEXT: `-CXXRecordDecl 0x{{.+}} <line:{{.*}}:61, col:68> col:68 struct TestTemplateTemplateDefaultType{{$}} 472 473 // CHECK: ClassTemplateDecl 0x{{.+}} prev 0x{{.+}} <{{.+}}:{{.*}}:3, col:82> col:48 TestTemplateTemplateDefaultType{{$}} 474 // CHECK-NEXT: |-TemplateTemplateParmDecl 0x{{.+}} <col:12, col:37> col:37 depth 0 index 0 TT{{$}} 475 // CHECK-NEXT: | |-TemplateTypeParmDecl 0x{{.+}} <col:21> col:29 typename depth 1 index 0{{$}} 476 // CHECK-NEXT: | `-TemplateArgument <line:{{.*}}:42> template 'TestClassTemplate':'testClassTemplateDecl::TestClassTemplate' qualified{{$}} 477 // CHECK-NEXT: | |-inherited from TemplateTemplateParm 0x{{.+}} 'TT'{{$}} 478 // CHECK-NEXT: | `-ClassTemplateDecl 0x{{.+}} <line:{{.+}}:3, line:{{.+}}:3> line:{{.+}}:30 TestClassTemplate 479 // CHECK-NEXT: `-CXXRecordDecl 0x{{.+}} prev 0x{{.+}} <line:{{.*}}:41, col:82> col:48 struct TestTemplateTemplateDefaultType definition{{$}} 480 // CHECK-NEXT: |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init{{$}} 481 // CHECK-NEXT: | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr{{$}} 482 // CHECK-NEXT: | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 483 // CHECK-NEXT: | |-MoveConstructor exists simple trivial needs_implicit{{$}} 484 // CHECK-NEXT: | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 485 // CHECK-NEXT: | |-MoveAssignment exists simple trivial needs_implicit{{$}} 486 // CHECK-NEXT: | `-Destructor simple irrelevant trivial needs_implicit{{$}} 487 // CHECK-NEXT: `-CXXRecordDecl 0x{{.+}} <col:41, col:48> col:48 implicit struct TestTemplateTemplateDefaultType{{$}} 488 489 490 // PR15220 dump instantiation only once 491 namespace testCanonicalTemplate { 492 class A {}; 493 494 template<typename T> void TestFunctionTemplate(T); 495 template<typename T> void TestFunctionTemplate(T); 496 void bar(A a) { TestFunctionTemplate(a); } 497 // CHECK: FunctionTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-3]]:3, col:51> col:29 TestFunctionTemplate{{$}} 498 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 referenced typename depth 0 index 0 T{{$}} 499 // CHECK-NEXT: |-FunctionDecl 0x{{.*}} <col:24, col:51> col:29 TestFunctionTemplate 'void (T)'{{$}} 500 // CHECK-NEXT: | `-ParmVarDecl 0x{{.*}} <col:50> col:51 'T'{{$}} 501 // CHECK-NEXT: `-FunctionDecl 0x{{.*}} <line:[[@LINE-6]]:24, col:51> col:29 used TestFunctionTemplate 'void (testCanonicalTemplate::A)' implicit_instantiation{{$}} 502 // CHECK-NEXT: |-TemplateArgument type 'testCanonicalTemplate::A'{{$}} 503 // CHECK-NEXT: | `-RecordType 0x{{.+}} 'testCanonicalTemplate::A'{{$}} 504 // CHECK-NEXT: | `-CXXRecord 0x{{.+}} 'A'{{$}} 505 // CHECK-NEXT: `-ParmVarDecl 0x{{.*}} <col:50> col:51 'testCanonicalTemplate::A'{{$}} 506 507 // CHECK: FunctionTemplateDecl 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-12]]:3, col:51> col:29 TestFunctionTemplate{{$}} 508 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 referenced typename depth 0 index 0 T{{$}} 509 // CHECK-NEXT: |-FunctionDecl{{.*}} 0x{{.+}} prev 0x{{.+}} <col:24, col:51> col:29 TestFunctionTemplate 'void (T)'{{$}} 510 // CHECK-NEXT: | `-ParmVarDecl 0x{{.+}} <col:50> col:51 'T'{{$}} 511 // CHECK-NEXT: `-Function 0x{{.+}} 'TestFunctionTemplate' 'void (testCanonicalTemplate::A)'{{$}} 512 // CHECK-NOT: TemplateArgument{{$}} 513 514 template<typename T1> class TestClassTemplate { 515 template<typename T2> friend class TestClassTemplate; 516 }; 517 TestClassTemplate<A> a; 518 // CHECK: ClassTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-4]]:3, line:[[@LINE-2]]:3> line:[[@LINE-4]]:31 TestClassTemplate{{$}} 519 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T1{{$}} 520 // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} <col:25, line:[[@LINE-4]]:3> line:[[@LINE-6]]:31 class TestClassTemplate definition{{$}} 521 // CHECK-NEXT: | |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init{{$}} 522 // CHECK-NEXT: | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr{{$}} 523 // CHECK-NEXT: | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 524 // CHECK-NEXT: | | |-MoveConstructor exists simple trivial needs_implicit{{$}} 525 // CHECK-NEXT: | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 526 // CHECK-NEXT: | | |-MoveAssignment exists simple trivial needs_implicit{{$}} 527 // CHECK-NEXT: | | `-Destructor simple irrelevant trivial needs_implicit{{$}} 528 // CHECK-NEXT: | |-CXXRecordDecl 0x{{.+}} <col:25, col:31> col:31 implicit class TestClassTemplate{{$}} 529 // CHECK-NEXT: | `-FriendDecl 0x{{.+}} <line:[[@LINE-14]]:5, col:40> col:40{{$}} 530 // CHECK-NEXT: | `-ClassTemplateDecl 0x{{.+}} parent 0x{{.+}} <col:5, col:40> col:40 friend_undeclared TestClassTemplate{{$}} 531 // CHECK-NEXT: | |-TemplateTypeParmDecl 0x{{.+}} <col:14, col:23> col:23 typename depth 1 index 0 T2{{$}} 532 // CHECK-NEXT: | `-CXXRecordDecl 0x{{.+}} parent 0x{{.+}} <col:34, col:40> col:40 class TestClassTemplate{{$}} 533 // CHECK-NEXT: `-ClassTemplateSpecializationDecl 0x{{.+}} <col:5, col:40> line:[[@LINE-19]]:31 class TestClassTemplate definition implicit_instantiation{{$}} 534 // CHECK-NEXT: |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init{{$}} 535 // CHECK-NEXT: | |-DefaultConstructor exists trivial constexpr defaulted_is_constexpr{{$}} 536 // CHECK-NEXT: | |-CopyConstructor simple trivial has_const_param implicit_has_const_param{{$}} 537 // CHECK-NEXT: | |-MoveConstructor exists simple trivial{{$}} 538 // CHECK-NEXT: | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 539 // CHECK-NEXT: | |-MoveAssignment exists simple trivial needs_implicit{{$}} 540 // CHECK-NEXT: | `-Destructor simple irrelevant trivial needs_implicit{{$}} 541 // CHECK-NEXT: |-TemplateArgument type 'testCanonicalTemplate::A'{{$}} 542 // CHECK-NEXT: | `-RecordType 0x{{.+}} 'testCanonicalTemplate::A'{{$}} 543 // CHECK-NEXT: | `-CXXRecord 0x{{.+}} 'A'{{$}} 544 // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} <col:25, col:31> col:31 implicit class TestClassTemplate{{$}} 545 // CHECK-NEXT: |-FriendDecl 0x{{.+}} <line:[[@LINE-30]]:5, col:40> col:40{{$}} 546 // CHECK-NEXT: | `-ClassTemplateDecl 0x{{.+}} parent 0x{{.+}} prev 0x{{.+}} <col:5, col:40> col:40 friend TestClassTemplate{{$}} 547 // CHECK-NEXT: | |-TemplateTypeParmDecl 0x{{.+}} <col:14, col:23> col:23 typename depth 0 index 0 T2{{$}} 548 // CHECK-NEXT: | |-CXXRecordDecl 0x{{.+}} parent 0x{{.+}} prev 0x{{.+}} <col:34, col:40> col:40 class TestClassTemplate{{$}} 549 // CHECK-NEXT: | `-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate'{{$}} 550 // CHECK-NEXT: |-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-36]]:31> col:31 implicit used constexpr TestClassTemplate 'void () noexcept' inline default trivial{{$}} 551 // CHECK-NEXT: | `-CompoundStmt 0x{{.+}} <col:31>{{$}} 552 // CHECK-NEXT: |-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate 'void (const TestClassTemplate<A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}{{$}} 553 // CHECK-NEXT: | `-ParmVarDecl 0x{{.+}} <col:31> col:31 'const TestClassTemplate<A> &'{{$}} 554 // CHECK-NEXT: `-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate 'void (TestClassTemplate<A> &&)' inline default trivial noexcept-unevaluated 0x{{.+}}{{$}} 555 // CHECK-NEXT: `-ParmVarDecl 0x{{.+}} <col:31> col:31 'TestClassTemplate<A> &&'{{$}} 556 557 558 template<typename T1> class TestClassTemplate2; 559 template<typename T1> class TestClassTemplate2; 560 template<typename T1> class TestClassTemplate2 { 561 }; 562 TestClassTemplate2<A> a2; 563 // CHECK: ClassTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-5]]:3, col:31> col:31 TestClassTemplate2{{$}} 564 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T1{{$}} 565 // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} <col:25, col:31> col:31 class TestClassTemplate2{{$}} 566 // CHECK-NEXT: `-ClassTemplateSpecializationDecl 0x{{.+}} <line:[[@LINE-6]]:3, line:[[@LINE-5]]:3> line:[[@LINE-6]]:31 class TestClassTemplate2 definition implicit_instantiation{{$}} 567 // CHECK-NEXT: |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init{{$}} 568 // CHECK-NEXT: | |-DefaultConstructor exists trivial constexpr defaulted_is_constexpr{{$}} 569 // CHECK-NEXT: | |-CopyConstructor simple trivial has_const_param implicit_has_const_param{{$}} 570 // CHECK-NEXT: | |-MoveConstructor exists simple trivial{{$}} 571 // CHECK-NEXT: | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 572 // CHECK-NEXT: | |-MoveAssignment exists simple trivial needs_implicit{{$}} 573 // CHECK-NEXT: | `-Destructor simple irrelevant trivial needs_implicit{{$}} 574 // CHECK-NEXT: |-TemplateArgument type 'testCanonicalTemplate::A'{{$}} 575 // CHECK-NEXT: | `-RecordType 0x{{.+}} 'testCanonicalTemplate::A'{{$}} 576 // CHECK-NEXT: | `-CXXRecord 0x{{.+}} 'A'{{$}} 577 // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} <col:25, col:31> col:31 implicit class TestClassTemplate2{{$}} 578 // CHECK-NEXT: |-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit used constexpr TestClassTemplate2 'void () noexcept' inline default trivial{{$}} 579 // CHECK-NEXT: | `-CompoundStmt 0x{{.+}} <col:31>{{$}} 580 // CHECK-NEXT: |-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate2 'void (const TestClassTemplate2<A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}{{$}} 581 // CHECK-NEXT: | `-ParmVarDecl 0x{{.+}} <col:31> col:31 'const TestClassTemplate2<A> &'{{$}} 582 // CHECK-NEXT: `-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate2 'void (TestClassTemplate2<A> &&)' inline default trivial noexcept-unevaluated 0x{{.+}}{{$}} 583 // CHECK-NEXT: `-ParmVarDecl 0x{{.+}} <col:31> col:31 'TestClassTemplate2<A> &&'{{$}} 584 585 // CHECK: ClassTemplateDecl 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-26]]:3, col:31> col:31 TestClassTemplate2{{$}} 586 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T1{{$}} 587 // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} prev 0x{{.+}} <col:25, col:31> col:31 class TestClassTemplate2{{$}} 588 // CHECK-NEXT: `-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate2'{{$}} 589 590 // CHECK: ClassTemplateDecl 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-30]]:3, line:[[@LINE-29]]:3> line:[[@LINE-30]]:31 TestClassTemplate2{{$}} 591 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T1{{$}} 592 // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} prev 0x{{.+}} <col:25, line:[[@LINE-31]]:3> line:[[@LINE-32]]:31 class TestClassTemplate2 definition{{$}} 593 // CHECK-NEXT: | |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init{{$}} 594 // CHECK-NEXT: | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr{{$}} 595 // CHECK-NEXT: | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 596 // CHECK-NEXT: | | |-MoveConstructor exists simple trivial needs_implicit{{$}} 597 // CHECK-NEXT: | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param{{$}} 598 // CHECK-NEXT: | | |-MoveAssignment exists simple trivial needs_implicit{{$}} 599 // CHECK-NEXT: | | `-Destructor simple irrelevant trivial needs_implicit{{$}} 600 // CHECK-NEXT: | `-CXXRecordDecl 0x{{.+}} <col:25, col:31> col:31 implicit class TestClassTemplate2{{$}} 601 // CHECK-NEXT: `-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate2'{{$}} 602 603 struct S { 604 template<typename T> static const T TestVarTemplate; // declaration of a static data member template 605 }; 606 template<typename T> 607 const T S::TestVarTemplate = { }; // definition of a static data member template 608 609 void f() 610 { 611 int i = S::TestVarTemplate<int>; 612 int j = S::TestVarTemplate<int>; 613 } 614 615 // CHECK: VarTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-11]]:7, col:43> col:43 TestVarTemplate{{$}} 616 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:16, col:25> col:25 referenced typename depth 0 index 0 T{{$}} 617 // CHECK-NEXT: |-VarDecl 0x{{.+}} <col:28, col:43> col:43 TestVarTemplate 'const T' static{{$}} 618 // CHECK-NEXT: |-VarTemplateSpecializationDecl 0x{{.+}} parent 0x{{.+}} prev 0x{{.+}} <line:[[@LINE-12]]:3, line:[[@LINE-11]]:34> col:14 referenced TestVarTemplate 'const int' implicit_instantiation cinit{{$}} 619 // CHECK-NEXT: | |-NestedNameSpecifier TypeSpec 'testCanonicalTemplate::S'{{$}} 620 // CHECK-NEXT: | |-TemplateArgument type 'int'{{$}} 621 // CHECK-NEXT: | | `-BuiltinType 0x{{.+}} 'int'{{$}} 622 // CHECK-NEXT: | `-InitListExpr 0x{{.+}} <col:32, col:34> 'int'{{$}} 623 // CHECK-NEXT: `-VarTemplateSpecializationDecl 0x{{.+}} <line:[[@LINE-19]]:7, col:43> col:43 referenced TestVarTemplate 'const int' implicit_instantiation static{{$}} 624 // CHECK-NEXT: `-TemplateArgument type 'int'{{$}} 625 626 // CHECK: VarTemplateSpecializationDecl 0x{{.+}} <{{.+}}:[[@LINE-22]]:7, col:43> col:43 referenced TestVarTemplate 'const int' implicit_instantiation static{{$}} 627 // CHECK-NEXT:`-TemplateArgument type 'int'{{$}} 628 // CHECK-NEXT: `-BuiltinType 0x{{.+}} 'int'{{$}} 629 630 // CHECK: VarTemplateDecl 0x{{.+}} parent 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-24]]:3, line:[[@LINE-23]]:34> col:14 TestVarTemplate{{$}} 631 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <line:[[@LINE-25]]:12, col:21> col:21 referenced typename depth 0 index 0 T{{$}} 632 // CHECK-NEXT: |-VarDecl 0x{{.+}} parent 0x{{.+}} prev 0x{{.+}} <line:[[@LINE-25]]:3, col:34> col:14 TestVarTemplate 'const T' cinit{{$}} 633 // CHECK-NEXT: | |-NestedNameSpecifier TypeSpec 'testCanonicalTemplate::S'{{$}} 634 // CHECK-NEXT: | `-InitListExpr 0x{{.+}} <col:32, col:34> 'void'{{$}} 635 // CHECK-NEXT: |-VarTemplateSpecialization 0x{{.+}} 'TestVarTemplate' 'const int'{{$}} 636 // CHECK-NEXT: `-VarTemplateSpecialization 0x{{.+}} 'TestVarTemplate' 'const int'{{$}} 637 638 // CHECK: VarTemplateSpecializationDecl 0x{{.+}} parent 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-32]]:3, line:[[@LINE-31]]:34> col:14 referenced TestVarTemplate 'const int' implicit_instantiation cinit{{$}} 639 // CHECK-NEXT: |-NestedNameSpecifier TypeSpec 'testCanonicalTemplate::S'{{$}} 640 // CHECK-NEXT: |-TemplateArgument type 'int'{{$}} 641 // CHECK-NEXT: | `-BuiltinType 0x{{.+}} 'int'{{$}} 642 // CHECK-NEXT: `-InitListExpr 0x{{.+}} <col:32, col:34> 'int'{{$}} 643 } 644 645 template <class T> 646 class TestClassScopeFunctionSpecialization { 647 template<class U> void foo(U a) { } 648 template<> void foo<int>(int a) { } 649 }; 650 // CHECK: FunctionTemplateDecl{{.*}} foo 651 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} referenced class depth 1 index 0 U 652 // CHECK-NEXT: CXXMethodDecl{{.*}} foo 'void (U)' implicit-inline 653 // CHECK-NEXT: ParmVarDecl 654 // CHECK-NEXT: CompoundStmt 655 // CHECK-NEXT: CXXMethodDecl{{.*}} foo 'void (int)' explicit_specialization implicit-inline 656 // CHECK-NEXT: TemplateArgument{{.*}} 'int' 657 // CHECK-NEXT: BuiltinType{{.*}} 'int' 658 // CHECK-NEXT: ParmVarDecl 659 // CHECK-NEXT: CompoundStmt 660 661 namespace TestTemplateTypeParmDecl { 662 template<typename ... T, class U = int> void foo(); 663 } 664 // CHECK: NamespaceDecl{{.*}} TestTemplateTypeParmDecl 665 // CHECK-NEXT: FunctionTemplateDecl 666 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename depth 0 index 0 ... T 667 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} class depth 0 index 1 U 668 // CHECK-NEXT: TemplateArgument type 'int' 669 670 namespace TestNonTypeTemplateParmDecl { 671 template<int I = 1, int ... J> void foo(); 672 } 673 // CHECK: NamespaceDecl{{.*}} TestNonTypeTemplateParmDecl 674 // CHECK-NEXT: FunctionTemplateDecl 675 // CHECK-NEXT: NonTypeTemplateParmDecl{{.*}} 'int' depth 0 index 0 I 676 // CHECK-NEXT: TemplateArgument {{.*}} expr 677 // CHECK-NEXT: IntegerLiteral{{.*}} 'int' 1 678 // CHECK-NEXT: NonTypeTemplateParmDecl{{.*}} 'int' depth 0 index 1 ... J 679 680 namespace TestTemplateTemplateParmDecl { 681 template<typename T> class A; 682 template <template <typename> class T = A, template <typename> class ... U> void foo(); 683 } 684 // CHECK: NamespaceDecl{{.*}} TestTemplateTemplateParmDecl 685 // CHECK: FunctionTemplateDecl 686 // CHECK-NEXT: TemplateTemplateParmDecl{{.*}} T 687 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename 688 // CHECK-NEXT: TemplateArgument{{.*}} template 'A':'TestTemplateTemplateParmDecl::A' qualified{{$}} 689 // CHECK-NEXT: ClassTemplateDecl {{.*}} A 690 // CHECK-NEXT: TemplateTemplateParmDecl{{.*}} ... U 691 // CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename 692 693 namespace TestTemplateArgument { 694 template<typename> class A { }; 695 template<template<typename> class ...> class B { }; 696 int foo(); 697 698 template<typename> class testType { }; 699 template class testType<int>; 700 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testType 701 // CHECK: TemplateArgument{{.*}} type 'int' 702 703 template<int fp(void)> class testDecl { }; 704 template class testDecl<foo>; 705 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testDecl 706 // CHECK: TemplateArgument{{.*}} decl 707 // CHECK-NEXT: Function{{.*}}foo 708 709 template class testDecl<nullptr>; 710 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testDecl 711 // CHECK: TemplateArgument{{.*}} nullptr 712 713 template<int> class testIntegral { }; 714 template class testIntegral<1>; 715 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testIntegral 716 // CHECK: TemplateArgument{{.*}} integral '1' 717 718 template<template<typename> class> class testTemplate { }; 719 template class testTemplate<A>; 720 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testTemplate 721 // CHECK: TemplateArgument{{.*}} 'TestTemplateArgument::A'{{$}} 722 723 template<template<typename> class ...T> class C { 724 B<T...> testTemplateExpansion; 725 }; 726 // FIXME: Need TemplateSpecializationType dumping to test TemplateExpansion. 727 728 template<int, int = 0> class testExpr; 729 template<int I> class testExpr<I> { }; 730 // CHECK: ClassTemplatePartialSpecializationDecl{{.*}} class testExpr 731 // CHECK: TemplateArgument{{.*}} expr 732 // CHECK-NEXT: DeclRefExpr{{.*}}I 733 734 template<int, int ...> class testPack { }; 735 template class testPack<0, 1, 2>; 736 // CHECK: ClassTemplateSpecializationDecl{{.*}} class testPack 737 // CHECK: TemplateArgument{{.*}} integral '0' 738 // CHECK-NEXT: TemplateArgument{{.*}} pack 739 // CHECK-NEXT: TemplateArgument{{.*}} integral '1' 740 // CHECK-NEXT: TemplateArgument{{.*}} integral '2' 741 } 742 743 namespace testUsingDecl { 744 int i; 745 } 746 namespace TestUsingDecl { 747 using testUsingDecl::i; 748 } 749 // CHECK: NamespaceDecl{{.*}} TestUsingDecl 750 // CHECK-NEXT: UsingDecl{{.*}} testUsingDecl::i 751 // CHECK-NEXT: | `-NestedNameSpecifier Namespace 0x{{.*}} 'testUsingDecl 752 // CHECK-NEXT: UsingShadowDecl{{.*}} Var{{.*}} 'i' 'int' 753 754 namespace testUnresolvedUsing { 755 class A { }; 756 template<class T> class B { 757 public: 758 A a; 759 }; 760 template<class T> class TestUnresolvedUsing : public B<T> { 761 using typename B<T>::a; 762 using B<T>::a; 763 }; 764 } 765 // CHECK: CXXRecordDecl{{.*}} TestUnresolvedUsing 766 // CHECK: UnresolvedUsingTypenameDecl{{.*}} B<T>::a 767 // CHECK: UnresolvedUsingValueDecl{{.*}} B<T>::a 768 769 namespace TestLinkageSpecDecl { 770 extern "C" void test1(); 771 extern "C++" void test2(); 772 } 773 // CHECK: NamespaceDecl{{.*}} TestLinkageSpecDecl 774 // CHECK-NEXT: LinkageSpecDecl{{.*}} C 775 // CHECK-NEXT: FunctionDecl 776 // CHECK-NEXT: LinkageSpecDecl{{.*}} C++ 777 // CHECK-NEXT: FunctionDecl 778 779 class TestAccessSpecDecl { 780 public: 781 private: 782 protected: 783 }; 784 // CHECK: CXXRecordDecl{{.*}} class TestAccessSpecDecl 785 // CHECK: CXXRecordDecl{{.*}} class TestAccessSpecDecl 786 // CHECK-NEXT: AccessSpecDecl{{.*}} public 787 // CHECK-NEXT: AccessSpecDecl{{.*}} private 788 // CHECK-NEXT: AccessSpecDecl{{.*}} protected 789 790 template<typename T> class TestFriendDecl { 791 friend int foo(); 792 friend class A; 793 friend T; 794 }; 795 // CHECK: CXXRecord{{.*}} TestFriendDecl 796 // CHECK: CXXRecord{{.*}} TestFriendDecl 797 // CHECK-NEXT: FriendDecl 798 // CHECK-NEXT: FunctionDecl{{.*}} foo 799 // CHECK-NEXT: FriendDecl{{.*}} 'class A':'A' 800 // CHECK-NEXT: CXXRecordDecl{{.*}} class A 801 // CHECK-NEXT: FriendDecl{{.*}} 'T' 802 803 namespace TestFileScopeAsmDecl { 804 asm("ret"); 805 } 806 // CHECK: NamespaceDecl{{.*}} TestFileScopeAsmDecl{{$}} 807 // CHECK: FileScopeAsmDecl{{.*> .*$}} 808 // CHECK-NEXT: StringLiteral 809 810 namespace TestFriendDecl2 { 811 void f(); 812 struct S { 813 friend void f(); 814 }; 815 } 816 // CHECK: NamespaceDecl [[TestFriendDecl2:0x.*]] <{{.*}}> {{.*}} TestFriendDecl2 817 // CHECK: |-FunctionDecl [[TestFriendDecl2_f:0x.*]] <{{.*}}> {{.*}} f 'void ()' 818 // CHECK: `-CXXRecordDecl {{.*}} struct S 819 // CHECK: |-CXXRecordDecl {{.*}} struct S 820 // CHECK: `-FriendDecl 821 // CHECK: `-FunctionDecl {{.*}} parent [[TestFriendDecl2]] prev [[TestFriendDecl2_f]] <{{.*}}> {{.*}} f 'void ()' 822 823 namespace Comment { 824 extern int Test; 825 /// Something here. 826 extern int Test; 827 extern int Test; 828 } 829 830 // CHECK: VarDecl {{.*}} Test 'int' extern 831 // CHECK-NOT: FullComment 832 // CHECK: VarDecl {{.*}} Test 'int' extern 833 // CHECK: `-FullComment 834 // CHECK: `-ParagraphComment 835 // CHECK: `-TextComment 836 // CHECK: VarDecl {{.*}} Test 'int' extern 837 // CHECK-NOT: FullComment 838 839 namespace TestConstexprVariableTemplateWithInitializer { 840 template<typename T> constexpr T foo{}; 841 // CHECK: VarTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-1]]:3, col:40> col:36 foo{{$}} 842 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 referenced typename depth 0 index 0 T{{$}} 843 // CHECK-NEXT: `-VarDecl 0x{{.+}} <col:24, col:40> col:36 foo 'const T' constexpr listinit{{$}} 844 // CHECK-NEXT: `-InitListExpr 0x{{.+}} <col:39, col:40> 'void'{{$}} 845 846 template<typename T> constexpr int val{42}; 847 // CHECK: VarTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-1]]:3, col:44> col:38 val{{$}} 848 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T{{$}} 849 // CHECK-NEXT: `-VarDecl 0x{{.+}} <col:24, col:44> col:38 val 'const int' constexpr listinit{{$}} 850 // CHECK-NEXT: |-value: Int 42{{$}} 851 // CHECK-NEXT: `-InitListExpr 0x{{.+}} <col:41, col:44> 'int'{{$}} 852 853 template <typename _Tp> 854 struct in_place_type_t { 855 explicit in_place_type_t() = default; 856 }; 857 858 template <typename _Tp> 859 inline constexpr in_place_type_t<_Tp> in_place_type{}; 860 // CHECK: -VarTemplateDecl 0x{{.+}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:55> col:41 in_place_type{{$}} 861 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <line:[[@LINE-3]]:13, col:22> col:22 referenced typename depth 0 index 0 _Tp{{$}} 862 // CHECK-NEXT: `-VarDecl 0x{{.+}} <line:[[@LINE-3]]:3, col:55> col:41 in_place_type 'const in_place_type_t<_Tp>' inline constexpr listinit{{$}} 863 // CHECK-NEXT: `-InitListExpr 0x{{.+}} <col:54, col:55> 'void'{{$}} 864 865 template <typename T> constexpr T call_init(0); 866 // CHECK: -VarTemplateDecl 0x{{.+}} <line:[[@LINE-1]]:3, col:48> col:37 call_init{{$}} 867 // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:13, col:22> col:22 referenced typename depth 0 index 0 T{{$}} 868 // CHECK-NEXT: `-VarDecl 0x{{.+}} <col:25, col:48> col:37 call_init 'const T' constexpr callinit{{$}} 869 // CHECK-NEXT: `-ParenListExpr 0x{{.+}} <col:46, col:48> 'NULL TYPE'{{$}} 870 // CHECK-NEXT: `-IntegerLiteral 0x{{.+}} <col:47> 'int' 0{{$}} 871 872 } 873