1 // RUN: %clang_cc1 -std=c++17 -verify=expected,cxx17 %s 2 // RUN: %clang_cc1 -std=c++20 -verify=expected,cxx20 -ast-dump -ast-dump-decl-types -ast-dump-filter "deduction guide" %s | FileCheck %s --strict-whitespace 3 4 namespace Basic { 5 template<class T> struct A { // cxx17-note 6 {{candidate}} cxx17-note 6 {{implicit deduction guide}} 6 T x; 7 T y; 8 }; 9 10 A a1 = {3.0, 4.0}; // cxx17-error {{no viable}} 11 A a2 = {.x = 3.0, .y = 4.0}; // cxx17-error {{no viable}} 12 13 A a3(3.0, 4.0); // cxx17-error {{no viable}} 14 15 // CHECK-LABEL: Dumping Basic::<deduction guide for A>: 16 // CHECK: FunctionTemplateDecl {{.*}} implicit <deduction guide for A> 17 // CHECK: |-TemplateTypeParmDecl {{.*}} referenced class depth 0 index 0 T 18 // CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for A> 'auto (T, T) -> A<T>' 19 // CHECK: | |-ParmVarDecl {{.*}} 'T' 20 // CHECK: | `-ParmVarDecl {{.*}} 'T' 21 // CHECK: `-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for A> 'auto (double, double) -> Basic::A<double>' 22 // CHECK: |-TemplateArgument type 'double' 23 // CHECK: | `-BuiltinType {{.*}} 'double' 24 // CHECK: |-ParmVarDecl {{.*}} 'double' 25 // CHECK: `-ParmVarDecl {{.*}} 'double' 26 // CHECK: FunctionProtoType {{.*}} 'auto (T, T) -> A<T>' dependent trailing_return cdecl 27 // CHECK: |-InjectedClassNameType {{.*}} 'A<T>' dependent 28 // CHECK: | `-CXXRecord {{.*}} 'A' 29 // CHECK: |-TemplateTypeParmType {{.*}} 'T' dependent depth 0 index 0 30 // CHECK: | `-TemplateTypeParm {{.*}} 'T' 31 // CHECK: `-TemplateTypeParmType {{.*}} 'T' dependent depth 0 index 0 32 // CHECK: `-TemplateTypeParm {{.*}} 'T' 33 34 template <typename T> struct S { // cxx20-note 2 {{candidate}} 35 T x; 36 T y; 37 }; 38 39 template <typename T> struct C { // cxx20-note 10 {{candidate}} cxx17-note 12 {{candidate}} \ 40 cxx20-note 10 {{implicit deduction guide}} cxx17-note 12 {{implicit deduction guide}} 41 S<T> s; 42 T t; 43 }; 44 45 template <typename T> struct D { // cxx20-note 6 {{candidate}} cxx17-note 8 {{candidate}} \ 46 cxx20-note 6 {{implicit deduction guide}} cxx17-note 8 {{implicit deduction guide}} 47 S<int> s; 48 T t; 49 }; 50 51 C c1 = {1, 2}; // expected-error {{no viable}} 52 C c2 = {1, 2, 3}; // expected-error {{no viable}} 53 C c3 = {{1u, 2u}, 3}; // cxx17-error {{no viable}} 54 55 C c4(1, 2); // expected-error {{no viable}} 56 C c5(1, 2, 3); // expected-error {{no viable}} 57 C c6({1u, 2u}, 3); // cxx17-error {{no viable}} 58 59 D d1 = {1, 2}; // expected-error {{no viable}} 60 D d2 = {1, 2, 3}; // cxx17-error {{no viable}} 61 62 D d3(1, 2); // expected-error {{no viable}} 63 // CTAD succeed but brace elision is not allowed for parenthesized aggregate init. 64 D d4(1, 2, 3); // expected-error {{no viable}} 65 66 // CHECK-LABEL: Dumping Basic::<deduction guide for C>: 67 // CHECK: FunctionTemplateDecl {{.*}} implicit <deduction guide for C> 68 // CHECK: |-TemplateTypeParmDecl {{.*}} referenced typename depth 0 index 0 T 69 // CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for C> 'auto (S<T>, T) -> C<T>' 70 // CHECK: | |-ParmVarDecl {{.*}} 'S<T>' 71 // CHECK: | `-ParmVarDecl {{.*}} 'T' 72 // CHECK: `-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for C> 'auto (S<int>, int) -> Basic::C<int>' 73 // CHECK: |-TemplateArgument type 'int' 74 // CHECK: | `-BuiltinType {{.*}} 'int' 75 // CHECK: |-ParmVarDecl {{.*}} 'S<int>':'Basic::S<int>' 76 // CHECK: `-ParmVarDecl {{.*}} 'int' 77 // CHECK: FunctionProtoType {{.*}} 'auto (S<T>, T) -> C<T>' dependent trailing_return cdecl 78 // CHECK: |-InjectedClassNameType {{.*}} 'C<T>' dependent 79 // CHECK: | `-CXXRecord {{.*}} 'C' 80 // CHECK: |-ElaboratedType {{.*}} 'S<T>' sugar dependent 81 // CHECK: | `-TemplateSpecializationType {{.*}} 'S<T>' dependent 82 // CHECK: | `-TemplateArgument type 'T' 83 // CHECK: | `-TemplateTypeParmType {{.*}} 'T' dependent depth 0 index 0 84 // CHECK: | `-TemplateTypeParm {{.*}} 'T' 85 // CHECK: `-TemplateTypeParmType {{.*}} 'T' dependent depth 0 index 0 86 // CHECK: `-TemplateTypeParm {{.*}} 'T' 87 88 // CHECK-LABEL: Dumping Basic::<deduction guide for D>: 89 // CHECK: FunctionTemplateDecl {{.*}} implicit <deduction guide for D> 90 // CHECK: |-TemplateTypeParmDecl {{.*}} referenced typename depth 0 index 0 T 91 // CHECK: `-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for D> 'auto (int, int) -> D<T>' 92 // CHECK: |-ParmVarDecl {{.*}} 'int' 93 // CHECK: `-ParmVarDecl {{.*}} 'int' 94 // CHECK: FunctionProtoType {{.*}} 'auto (int, int) -> D<T>' dependent trailing_return cdecl 95 // CHECK: |-InjectedClassNameType {{.*}} 'D<T>' dependent 96 // CHECK: | `-CXXRecord {{.*}} 'D' 97 // CHECK: |-SubstTemplateTypeParmType {{.*}} 'int' sugar typename depth 0 index 0 T 98 // CHECK: | |-ClassTemplateSpecialization {{.*}} 'S' 99 // CHECK: | `-BuiltinType {{.*}} 'int' 100 // CHECK: `-SubstTemplateTypeParmType {{.*}} 'int' sugar typename depth 0 index 0 T 101 // CHECK: |-ClassTemplateSpecialization {{.*}} 'S' 102 // CHECK: `-BuiltinType {{.*}} 'int' 103 104 template <typename T> struct E { // cxx17-note 4 {{candidate}} cxx17-note 4 {{implicit deduction guide}} 105 T t; 106 decltype(t) t2; 107 }; 108 109 E e1 = {1, 2}; // cxx17-error {{no viable}} 110 111 E e2(1, 2); // cxx17-error {{no viable}} 112 113 // CHECK-LABEL: Dumping Basic::<deduction guide for E>: 114 // CHECK: FunctionTemplateDecl {{.*}} implicit <deduction guide for E> 115 // CHECK: |-TemplateTypeParmDecl {{.*}} referenced typename depth 0 index 0 T 116 // CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for E> 'auto (T, decltype(t)) -> E<T>' 117 // CHECK: | |-ParmVarDecl {{.*}} 'T' 118 // CHECK: | `-ParmVarDecl {{.*}} 'decltype(t)' 119 // CHECK: `-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for E> 'auto (int, decltype(t)) -> Basic::E<int>' 120 // CHECK: |-TemplateArgument type 'int' 121 // CHECK: | `-BuiltinType {{.*}} 'int' 122 // CHECK: |-ParmVarDecl {{.*}} 'int' 123 // CHECK: `-ParmVarDecl {{.*}} 'decltype(t)':'int' 124 // CHECK: FunctionProtoType {{.*}} 'auto (T, decltype(t)) -> E<T>' dependent trailing_return cdecl 125 // CHECK: |-InjectedClassNameType {{.*}} 'E<T>' dependent 126 // CHECK: | `-CXXRecord {{.*}} 'E' 127 // CHECK: |-TemplateTypeParmType {{.*}} 'T' dependent depth 0 index 0 128 // CHECK: | `-TemplateTypeParm {{.*}} 'T' 129 // CHECK: `-DecltypeType {{.*}} 'decltype(t)' dependent 130 // CHECK: `-DeclRefExpr {{.*}} 'T' lvalue Field {{.*}} 't' 'T' non_odr_use_unevaluated 131 132 template <typename T> 133 struct I { 134 using type = T; 135 }; 136 137 template <typename T> 138 struct F { // cxx17-note 2 {{candidate}} cxx17-note 2 {{implicit deduction guide}} 139 typename I<T>::type i; 140 T t; 141 }; 142 143 F f1 = {1, 2}; // cxx17-error {{no viable}} 144 145 // CHECK-LABEL: Dumping Basic::<deduction guide for F>: 146 // CHECK: FunctionTemplateDecl {{.*}} implicit <deduction guide for F> 147 // CHECK: |-TemplateTypeParmDecl {{.*}} referenced typename depth 0 index 0 T 148 // CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for F> 'auto (typename I<T>::type, T) -> F<T>' 149 // CHECK: | |-ParmVarDecl {{.*}} 'typename I<T>::type' 150 // CHECK: | `-ParmVarDecl {{.*}} 'T' 151 // CHECK: `-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for F> 'auto (typename I<int>::type, int) -> Basic::F<int>' 152 // CHECK: |-TemplateArgument type 'int' 153 // CHECK: | `-BuiltinType {{.*}} 'int' 154 // CHECK: |-ParmVarDecl {{.*}} 'typename I<int>::type':'int' 155 // CHECK: `-ParmVarDecl {{.*}} 'int' 156 // CHECK: FunctionProtoType {{.*}} 'auto (typename I<T>::type, T) -> F<T>' dependent trailing_return cdecl 157 // CHECK: |-InjectedClassNameType {{.*}} 'F<T>' dependent 158 // CHECK: | `-CXXRecord {{.*}} 'F' 159 // CHECK: |-DependentNameType {{.*}} 'typename I<T>::type' dependent 160 // CHECK: `-TemplateTypeParmType {{.*}} 'T' dependent depth 0 index 0 161 // CHECK: `-TemplateTypeParm {{.*}} 'T' 162 } 163 164 namespace Array { 165 typedef unsigned long size_t; 166 template <typename T, size_t N> struct A { // cxx20-note 2 {{candidate}} cxx17-note 14 {{candidate}} \ 167 cxx20-note 2 {{implicit deduction guide}} cxx17-note 14 {{implicit deduction guide}} 168 T array[N]; 169 }; 170 171 A a1 = {{1, 2, 3}}; // cxx17-error {{no viable}} 172 A a2 = {1, 2, 3}; // expected-error {{no viable}} 173 A a3 = {"meow"}; // cxx17-error {{no viable}} 174 A a4 = {("meow")}; // cxx17-error {{no viable}} 175 176 A a5({1, 2, 3}); // cxx17-error {{no viable}} 177 A a6("meow"); // cxx17-error {{no viable}} 178 A a7(("meow")); // cxx17-error {{no viable}} 179 180 // CHECK-LABEL: Dumping Array::<deduction guide for A>: 181 // CHECK: FunctionTemplateDecl {{.*}} implicit <deduction guide for A> 182 // CHECK: |-TemplateTypeParmDecl {{.*}} referenced typename depth 0 index 0 T 183 // CHECK: |-NonTypeTemplateParmDecl {{.*}} 'size_t':'unsigned {{.*}}' depth 0 index 1 N 184 // CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for A> 'auto (T (&&)[N]) -> A<T, N>' 185 // CHECK: | `-ParmVarDecl {{.*}} 'T (&&)[N]' 186 // CHECK: `-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for A> 'auto (int (&&)[3]) -> Array::A<int, 3>' 187 // CHECK: |-TemplateArgument type 'int' 188 // CHECK: | `-BuiltinType {{.*}} 'int' 189 // CHECK: |-TemplateArgument integral '3UL' 190 // CHECK: `-ParmVarDecl {{.*}} 'int (&&)[3]' 191 // CHECK: FunctionProtoType {{.*}} 'auto (T (&&)[N]) -> A<T, N>' dependent trailing_return cdecl 192 // CHECK: |-InjectedClassNameType {{.*}} 'A<T, N>' dependent 193 // CHECK: | `-CXXRecord {{.*}} 'A' 194 // CHECK: `-RValueReferenceType {{.*}} 'T (&&)[N]' dependent 195 // CHECK: `-DependentSizedArrayType {{.*}} 'T[N]' dependent 196 // CHECK: |-TemplateTypeParmType {{.*}} 'T' dependent depth 0 index 0 197 // CHECK: | `-TemplateTypeParm {{.*}} 'T' 198 // CHECK: `-DeclRefExpr {{.*}} 'size_t':'unsigned {{.*}}' NonTypeTemplateParm {{.*}} 'N' 'size_t':'unsigned {{.*}}' 199 200 // CHECK: Dumping Array::<deduction guide for A>: 201 // CHECK: FunctionTemplateDecl {{.*}} implicit <deduction guide for A> 202 // CHECK: |-TemplateTypeParmDecl {{.*}} referenced typename depth 0 index 0 T 203 // CHECK: |-NonTypeTemplateParmDecl {{.*}} 'size_t':'unsigned {{.*}}' depth 0 index 1 N 204 // CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for A> 'auto (const T (&)[N]) -> A<T, N>' 205 // CHECK: | `-ParmVarDecl {{.*}} 'const T (&)[N]' 206 // CHECK: `-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for A> 'auto (const char (&)[5]) -> Array::A<char, 5>' 207 // CHECK: |-TemplateArgument type 'char' 208 // CHECK: | `-BuiltinType {{.*}} 'char' 209 // CHECK: |-TemplateArgument integral '5UL' 210 // CHECK: `-ParmVarDecl {{.*}} 'const char (&)[5]' 211 // CHECK: FunctionProtoType {{.*}} 'auto (const T (&)[N]) -> A<T, N>' dependent trailing_return cdecl 212 // CHECK: |-InjectedClassNameType {{.*}} 'A<T, N>' dependent 213 // CHECK: | `-CXXRecord {{.*}} 'A' 214 // CHECK: `-LValueReferenceType {{.*}} 'const T (&)[N]' dependent 215 // CHECK: `-QualType {{.*}} 'const T[N]' const 216 // CHECK: `-DependentSizedArrayType {{.*}} 'T[N]' dependent 217 // CHECK: |-TemplateTypeParmType {{.*}} 'T' dependent depth 0 index 0 218 // CHECK: | `-TemplateTypeParm {{.*}} 'T' 219 // CHECK: `-DeclRefExpr {{.*}} 'size_t':'unsigned{{.*}}' NonTypeTemplateParm {{.*}} 'N' 'size_t':'unsigned{{.*}}' 220 } 221 222 namespace BraceElision { 223 template <typename T> struct A { // cxx17-note 4 {{candidate}} cxx17-note 4 {{implicit deduction guide}} 224 T array[2]; 225 }; 226 227 A a1 = {0, 1}; // cxx17-error {{no viable}} 228 229 // CTAD succeed but brace elision is not allowed for parenthesized aggregate init. 230 A a2(0, 1); // cxx20-error {{array initializer must be an initializer list}} cxx17-error {{no viable}} 231 232 // CHECK-LABEL: Dumping BraceElision::<deduction guide for A>: 233 // CHECK: FunctionTemplateDecl {{.*}} implicit <deduction guide for A> 234 // CHECK: |-TemplateTypeParmDecl {{.*}} referenced typename depth 0 index 0 T 235 // CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for A> 'auto (T, T) -> A<T>' 236 // CHECK: | |-ParmVarDecl {{.*}} 'T' 237 // CHECK: | `-ParmVarDecl {{.*}} 'T' 238 // CHECK: `-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for A> 'auto (int, int) -> BraceElision::A<int>' 239 // CHECK: |-TemplateArgument type 'int' 240 // CHECK: | `-BuiltinType {{.*}} 'int' 241 // CHECK: |-ParmVarDecl {{.*}} 'int' 242 // CHECK: `-ParmVarDecl {{.*}} 'int' 243 // CHECK: FunctionProtoType {{.*}} 'auto (T, T) -> A<T>' dependent trailing_return cdecl 244 // CHECK: |-InjectedClassNameType {{.*}} 'A<T>' dependent 245 // CHECK: | `-CXXRecord {{.*}} 'A' 246 // CHECK: |-TemplateTypeParmType {{.*}} 'T' dependent depth 0 index 0 247 // CHECK: | `-TemplateTypeParm {{.*}} 'T' 248 // CHECK: `-TemplateTypeParmType {{.*}} 'T' dependent depth 0 index 0 249 // CHECK: `-TemplateTypeParm {{.*}} 'T' 250 } 251 252 namespace TrailingPack { 253 template<typename... T> struct A : T... { // cxx17-note 4 {{candidate}} cxx17-note 4 {{implicit deduction guide}} 254 }; 255 256 A a1 = { // cxx17-error {{no viable}} 257 []{ return 1; }, 258 []{ return 2; } 259 }; 260 261 A a2( // cxx17-error {{no viable}} 262 []{ return 1; }, 263 []{ return 2; } 264 ); 265 266 // CHECK-LABEL: Dumping TrailingPack::<deduction guide for A>: 267 // CHECK: FunctionTemplateDecl {{.*}} implicit <deduction guide for A> 268 // CHECK: |-TemplateTypeParmDecl {{.*}} referenced typename depth 0 index 0 ... T 269 // CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for A> 'auto (T...) -> A<T...>' 270 // CHECK: | `-ParmVarDecl {{.*}} 'T...' pack 271 // CHECK: `-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for A> 272 // CHECK-SAME: 'auto (TrailingPack::(lambda at {{.*}}), TrailingPack::(lambda at {{.*}})) -> 273 // CHECK-SAME: TrailingPack::A<TrailingPack::(lambda at {{.*}}), TrailingPack::(lambda at {{.*}})>' 274 // CHECK: |-TemplateArgument pack 275 // CHECK: | |-TemplateArgument type 'TrailingPack::(lambda at {{.*}})' 276 // CHECK: | | `-RecordType {{.*}} 'TrailingPack::(lambda at {{.*}})' 277 // CHECK: | | `-CXXRecord {{.*}} <line:262:5> 278 // CHECK: | `-TemplateArgument type 'TrailingPack::(lambda at {{.*}})' 279 // CHECK: | `-RecordType {{.*}} 'TrailingPack::(lambda at {{.*}})' 280 // CHECK: | `-CXXRecord {{.*}} <line:263:5> 281 // CHECK: |-ParmVarDecl {{.*}} 'TrailingPack::(lambda at {{.*}})' 282 // CHECK: `-ParmVarDecl {{.*}} 'TrailingPack::(lambda at {{.*}})' 283 // CHECK: FunctionProtoType {{.*}} 'auto (T...) -> A<T...>' dependent trailing_return cdecl 284 // CHECK: |-InjectedClassNameType {{.*}} 'A<T...>' dependent 285 // CHECK: | `-CXXRecord {{.*}} 'A' 286 // CHECK: `-PackExpansionType {{.*}} 'T...' dependent 287 // CHECK: `-TemplateTypeParmType {{.*}} 'T' dependent contains_unexpanded_pack depth 0 index 0 pack 288 // CHECK: `-TemplateTypeParm {{.*}} 'T' 289 } 290 291 namespace NonTrailingPack { 292 template<typename... T> struct A : T... { // expected-note 4 {{candidate}} expected-note 4 {{implicit deduction guide}} 293 int a; 294 }; 295 296 A a1 = { // expected-error {{no viable}} 297 []{ return 1; }, 298 []{ return 2; } 299 }; 300 301 A a2( // expected-error {{no viable}} 302 []{ return 1; }, 303 []{ return 2; } 304 ); 305 } 306 307 namespace DeduceArity { 308 template <typename... T> struct Types {}; 309 template <typename... T> struct F : Types<T...>, T... {}; // cxx20-note 12 {{candidate}} cxx17-note 16 {{candidate}} \ 310 cxx20-note 12 {{implicit deduction guide}} cxx17-note 16 {{implicit deduction guide}} 311 312 struct X {}; 313 struct Y {}; 314 struct Z {}; 315 struct W { operator Y(); }; 316 317 F f1 = {Types<X, Y, Z>{}, {}, {}}; // cxx17-error {{no viable}} 318 F f2 = {Types<X, Y, Z>{}, X{}, Y{}}; // cxx17-error {{no viable}} 319 F f3 = {Types<X, Y, Z>{}, X{}, W{}}; // expected-error {{no viable}} 320 F f4 = {Types<X>{}, {}, {}}; // expected-error {{no viable}} 321 322 F f5(Types<X, Y, Z>{}, {}, {}); // cxx17-error {{no viable}} 323 F f6(Types<X, Y, Z>{}, X{}, Y{}); // cxx17-error {{no viable}} 324 F f7(Types<X, Y, Z>{}, X{}, W{}); // expected-error {{no viable}} 325 F f8(Types<X>{}, {}, {}); // expected-error {{no viable}} 326 327 // CHECK-LABEL: Dumping DeduceArity::<deduction guide for F>: 328 // CHECK: FunctionTemplateDecl {{.*}} implicit <deduction guide for F> 329 // CHECK: |-TemplateTypeParmDecl {{.*}} referenced typename depth 0 index 0 ... T 330 // CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for F> 'auto (Types<T...>, T...) -> F<T...>' 331 // CHECK: | |-ParmVarDecl {{.*}} 'Types<T...>' 332 // CHECK: | `-ParmVarDecl {{.*}} 'T...' pack 333 // CHECK: |-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for F> 334 // CHECK-SAME: 'auto (Types<X, Y, Z>, DeduceArity::X, DeduceArity::Y, DeduceArity::Z) -> 335 // CHECK-SAME: DeduceArity::F<DeduceArity::X, DeduceArity::Y, DeduceArity::Z>' 336 // CHECK: | |-TemplateArgument pack 337 // CHECK: | | |-TemplateArgument type 'DeduceArity::X' 338 // CHECK: | | | `-RecordType {{.*}} 'DeduceArity::X' 339 // CHECK: | | | `-CXXRecord {{.*}} 'X' 340 // CHECK: | | |-TemplateArgument type 'DeduceArity::Y' 341 // CHECK: | | | `-RecordType {{.*}} 'DeduceArity::Y' 342 // CHECK: | | | `-CXXRecord {{.*}} 'Y' 343 // CHECK: | | `-TemplateArgument type 'DeduceArity::Z' 344 // CHECK: | | `-RecordType {{.*}} 'DeduceArity::Z' 345 // CHECK: | | `-CXXRecord {{.*}} 'Z' 346 // CHECK: | |-ParmVarDecl {{.*}} 'Types<X, Y, Z>':'DeduceArity::Types<DeduceArity::X, DeduceArity::Y, DeduceArity::Z>' 347 // CHECK: | |-ParmVarDecl {{.*}} 'DeduceArity::X' 348 // CHECK: | |-ParmVarDecl {{.*}} 'DeduceArity::Y' 349 // CHECK: | `-ParmVarDecl {{.*}} 'DeduceArity::Z' 350 // CHECK: `-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for F> 'auto (Types<X>, DeduceArity::X) -> DeduceArity::F<DeduceArity::X>' 351 // CHECK: |-TemplateArgument pack 352 // CHECK: | `-TemplateArgument type 'DeduceArity::X' 353 // CHECK: | `-RecordType {{.*}} 'DeduceArity::X' 354 // CHECK: | `-CXXRecord {{.*}} 'X' 355 // CHECK: |-ParmVarDecl {{.*}} 'Types<X>':'DeduceArity::Types<DeduceArity::X>' 356 // CHECK: `-ParmVarDecl {{.*}} 'DeduceArity::X' 357 // CHECK: FunctionProtoType {{.*}} 'auto (Types<T...>, T...) -> F<T...>' dependent trailing_return cdecl 358 // CHECK: |-InjectedClassNameType {{.*}} 'F<T...>' dependent 359 // CHECK: | `-CXXRecord {{.*}} 'F' 360 // CHECK: |-ElaboratedType {{.*}} 'Types<T...>' sugar dependent 361 // CHECK: | `-TemplateSpecializationType {{.*}} 'Types<T...>' dependent 362 // CHECK: | `-TemplateArgument type 'T...' 363 // CHECK: | `-PackExpansionType {{.*}} 'T...' dependent 364 // CHECK: | `-TemplateTypeParmType {{.*}} 'T' dependent contains_unexpanded_pack depth 0 index 0 pack 365 // CHECK: | `-TemplateTypeParm {{.*}} 'T' 366 // CHECK: `-PackExpansionType {{.*}} 'T...' dependent 367 // CHECK: `-TemplateTypeParmType {{.*}} 'T' dependent contains_unexpanded_pack depth 0 index 0 pack 368 // CHECK: `-TemplateTypeParm {{.*}} 'T' 369 } 370