1 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++11 -fblocks -fms-extensions -fsyntax-only -verify=expected,cxx11 %s
2 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++23 -fblocks -fms-extensions -fsyntax-only -verify=expected %s
3
4 template<typename T, typename U> struct pair;
5 template<typename ...> struct tuple;
6
7 // A parameter pack whose name appears within the pattern of a pack
8 // expansion is expanded by that pack expansion. An appearance of the
9 // name of a parameter pack is only expanded by the innermost
10 // enclosing pack expansion. The pattern of a pack expansion shall
11 // name one or more parameter packs that are not expanded by a nested
12 // pack expansion.
13 template<typename... Types>
14 struct Expansion {
15 typedef pair<Types..., int> expand_with_pacs; // okay
16 typedef pair<Types, int...> expand_no_packs; // expected-error{{pack expansion does not contain any unexpanded parameter packs}}
17 typedef pair<pair<Types..., int>..., int> expand_with_expanded_nested; // expected-error{{pack expansion does not contain any unexpanded parameter packs}}
18 };
19
20 // All of the parameter packs expanded by a pack expansion shall have
21 // the same number of arguments specified.
22 template<typename ...Types>
23 struct ExpansionLengthMismatch {
24 template<typename ...OtherTypes>
25 struct Inner {
26 typedef tuple<pair<Types, OtherTypes>...> type; // expected-error{{pack expansion contains parameter packs 'Types' and 'OtherTypes' that have different lengths (3 vs. 2)}}
27 };
28 };
29
30 ExpansionLengthMismatch<int, long>::Inner<unsigned int, unsigned long>::type
31 *il_pairs;
32 tuple<pair<int, unsigned int>, pair<long, unsigned long> >*il_pairs_2 = il_pairs;
33
34 ExpansionLengthMismatch<short, int, long>::Inner<unsigned int, unsigned long>::type // expected-note{{in instantiation of template class 'ExpansionLengthMismatch<short, int, long>::Inner<unsigned int, unsigned long>' requested here}}
35 *il_pairs_bad;
36
37
38 // An appearance of a name of a parameter pack that is not expanded is
39 // ill-formed.
40
41 // Test for unexpanded parameter packs in each of the type nodes.
42 template<typename T, int N, typename ... Types>
43 struct TestPPName
44 : public Types, public T // expected-error{{base type contains unexpanded parameter pack 'Types'}}
45 {
46 // BuiltinType is uninteresting
47 // FIXME: ComplexType is uninteresting?
48 // PointerType
49 typedef Types *types_pointer; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
50
51 // BlockPointerType
52 typedef Types (^block_pointer_1)(int); // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
53 typedef int (^block_pointer_2)(Types); // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
54
55 // LValueReferenceType
56 typedef Types &lvalue_ref; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
57
58 // RValueReferenceType
59 typedef Types &&rvalue_ref; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
60
61 // MemberPointerType
62 typedef Types TestPPName::* member_pointer_1; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
63 typedef int Types::*member_pointer_2; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
64
65 // ConstantArrayType
66 typedef Types constant_array[17]; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
67
68 // IncompleteArrayType
69 typedef Types incomplete_array[]; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
70
71 // VariableArrayType
fTestPPName72 void f(int i) { // expected-note {{declared here}}
73 Types variable_array[i]; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}} \
74 expected-warning {{variable length arrays in C++ are a Clang extension}} \
75 expected-note {{function parameter 'i' with unknown value cannot be used in a constant expression}}
76 }
77
78 // DependentSizedArrayType
79 typedef Types dependent_sized_array[N]; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
80
81 // DependentSizedExtVectorType
82 typedef Types dependent_sized_ext_vector __attribute__((ext_vector_type(N))); // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
83
84 // VectorType is uninteresting
85
86 // ExtVectorType
87 typedef Types ext_vector __attribute__((ext_vector_type(4))); // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
88
89 // FunctionProtoType
90 typedef Types (function_type_1)(int); // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
91 typedef int (function_type_2)(Types); // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
92
93 // FunctionNoProtoType is uninteresting
94 // UnresolvedUsingType is uninteresting
95 // ParenType is uninteresting
96 // TypedefType is uninteresting
97
98 // TypeOfExprType
99 typedef __typeof__((static_cast<Types>(0))) typeof_expr; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
100
101 // TypeOfType
102 typedef __typeof__(Types) typeof_type; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
103
104 // DecltypeType
105 typedef decltype((static_cast<Types>(0))) typeof_expr; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
106
107 // RecordType is uninteresting
108 // EnumType is uninteresting
109 // ElaboratedType is uninteresting
110
111 // TemplateTypeParmType
112 typedef Types template_type_parm; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
113
114 // SubstTemplateTypeParmType is uninteresting
115
116 // TemplateSpecializationType
117 typedef pair<Types, int> template_specialization; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
118
119 // InjectedClassName is uninteresting.
120
121 // DependentNameType
122 typedef typename Types::type dependent_name; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
123
124 // DependentTemplateSpecializationType
125 typedef typename Types::template apply<int> dependent_name_1; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
126 typedef typename T::template apply<Types> dependent_name_2; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
127
128 // ObjCObjectType is uninteresting
129 // ObjCInterfaceType is uninteresting
130 // ObjCObjectPointerType is uninteresting
131 };
132
133 // FIXME: Test for unexpanded parameter packs in each of the expression nodes.
134 template<int ...Values>
test_unexpanded_in_exprs()135 void test_unexpanded_in_exprs() {
136 // PredefinedExpr is uninteresting
137 // DeclRefExpr
138 Values; // expected-error{{expression contains unexpanded parameter pack 'Values'}}
139 // IntegerLiteral is uninteresting
140 // FloatingLiteral is uninteresting
141 // ImaginaryLiteral is uninteresting
142 // StringLiteral is uninteresting
143 // CharacterLiteral is uninteresting
144 (Values); // expected-error{{expression contains unexpanded parameter pack 'Values'}}
145 // UnaryOperator
146 -Values; // expected-error{{expression contains unexpanded parameter pack 'Values'}}
147 // OffsetOfExpr
148 struct OffsetMe {
149 int array[17];
150 };
151 __builtin_offsetof(OffsetMe, array[Values]); // expected-error{{expression contains unexpanded parameter pack 'Values'}}
152 // FIXME: continue this...
153 }
154
155 template<typename ... Types>
TestPPNameFunc(int i)156 void TestPPNameFunc(int i) {
157 f(static_cast<Types>(i)); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
158 }
159
160 template<typename T, template<class> class ...Meta>
161 struct TestUnexpandedTTP {
162 typedef tuple<typename Meta<T>::type> type; // expected-error{{declaration type contains unexpanded parameter pack 'Meta'}}
163 };
164
165 // Test for unexpanded parameter packs in declarations.
166 template<typename T, typename... Types>
167 // FIXME: this should test that the diagnostic reads "type contains..."
168 struct alignas(Types) TestUnexpandedDecls : T{ // expected-error{{expression contains unexpanded parameter pack 'Types'}}
169 void member_function(Types); // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
170 #if __cplusplus < 201703L
171 void member_function () throw(Types); // expected-error{{exception type contains unexpanded parameter pack 'Types'}}
172 #endif
173 void member_function2() noexcept(Types()); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
174 operator Types() const; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
175 Types data_member; // expected-error{{data member type contains unexpanded parameter pack 'Types'}}
176 static Types static_data_member; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
177 unsigned bit_field : static_cast<Types>(0); // expected-error{{bit-field size contains unexpanded parameter pack 'Types'}}
178 static_assert(static_cast<Types>(0), "Boom"); // expected-error{{static assertion contains unexpanded parameter pack 'Types'}}
179
180 enum E0 : Types { // expected-error{{fixed underlying type contains unexpanded parameter pack 'Types'}}
181 EnumValue = static_cast<Types>(0) // expected-error{{enumerator value contains unexpanded parameter pack 'Types'}}
182 };
183
184 using typename Types::type; // expected-error{{using declaration contains unexpanded parameter pack 'Types'}}
185 using Types::value; // expected-error{{using declaration contains unexpanded parameter pack 'Types'}}
186 using T::operator Types; // expected-error{{using declaration contains unexpanded parameter pack 'Types'}}
187
188 friend class Types::foo; // expected-error{{friend declaration contains unexpanded parameter pack 'Types'}}
189 friend void friend_func(Types); // expected-error{{friend declaration contains unexpanded parameter pack 'Types'}}
190 friend void Types::other_friend_func(int); // expected-error{{friend declaration contains unexpanded parameter pack 'Types'}}
191
test_initializersTestUnexpandedDecls192 void test_initializers() {
193 T copy_init = static_cast<Types>(0); // expected-error{{initializer contains unexpanded parameter pack 'Types'}}
194 T direct_init(0, static_cast<Types>(0)); // expected-error{{initializer contains unexpanded parameter pack 'Types'}}
195 T list_init = { static_cast<Types>(0) }; // expected-error{{initializer contains unexpanded parameter pack 'Types'}}
196 }
197
198 T in_class_member_init = static_cast<Types>(0); // expected-error{{initializer contains unexpanded parameter pack 'Types'}}
TestUnexpandedDeclsTestUnexpandedDecls199 TestUnexpandedDecls() :
200 Types(static_cast<Types>(0)), // expected-error{{initializer contains unexpanded parameter pack 'Types'}}
201 Types(static_cast<Types>(0))...,
202 in_class_member_init(static_cast<Types>(0)) {} // expected-error{{initializer contains unexpanded parameter pack 'Types'}}
203
204 void default_function_args(T = static_cast<Types>(0)); // expected-error{{default argument contains unexpanded parameter pack 'Types'}}
205
206 template<typename = Types*> // expected-error{{default argument contains unexpanded parameter pack 'Types'}}
207 struct default_template_args_1;
208 template<int = static_cast<Types>(0)> // expected-error{{default argument contains unexpanded parameter pack 'Types'}}
209 struct default_template_args_2;
210 template<template<typename> class = Types::template apply> // expected-error{{default argument contains unexpanded parameter pack 'Types'}}
211 struct default_template_args_3;
212
213 template<Types value> // expected-error{{non-type template parameter type contains unexpanded parameter pack 'Types'}}
214 struct non_type_template_param_type;
215
decls_in_stmtsTestUnexpandedDecls216 void decls_in_stmts() {
217 Types t; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
218 for (Types *t = 0; ; ) { } // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
219 for (; Types *t = 0; ) { } // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
220 T a[] = { T(), T(), T() };
221 for (Types t : a) { } // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
222 switch(Types *t = 0) { } // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
223 while(Types *t = 0) { } // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
224 if (Types *t = 0) { } // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
225 try {
226 } catch (Types*) { // expected-error{{exception type contains unexpanded parameter pack 'Types'}}
227 }
228 }
229 };
230
231 // FIXME: Test for unexpanded parameter packs in each of the statements.
232 struct X {
233 void f(int, int);
234 template<typename ...Types>
235 void f(Types...);
236 };
237
238 namespace std {
239 class type_info;
240 }
241
242 typedef struct _GUID {
243 unsigned long Data1;
244 unsigned short Data2;
245 unsigned short Data3;
246 unsigned char Data4[ 8 ];
247 } GUID;
248
249 template<typename T, typename ...Types>
test_unexpanded_exprs(Types...values)250 void test_unexpanded_exprs(Types ...values) {
251 // CXXOperatorCallExpr
252 (void)(values + 0); // expected-error{{expression contains unexpanded parameter pack 'values'}}
253 (void)(0 + values); // expected-error{{expression contains unexpanded parameter pack 'values'}}
254
255 // CXXMemberCallExpr
256 values.f(); // expected-error{{expression contains unexpanded parameter pack 'values'}}
257 X x;
258 x.f(values); // expected-error{{expression contains unexpanded parameter pack 'values'}}
259 x.Types::f(); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
260 x.f<Types>(); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
261
262 // CXXStaticCastExpr
263 (void)static_cast<Types&>(values); // expected-error{{expression contains unexpanded parameter packs 'Types' and 'values'}}
264
265 // CXXDynamicCastExpr
266 (void)dynamic_cast<Types&>(values); // expected-error{{expression contains unexpanded parameter packs 'Types' and 'values'}}
267
268 // CXXReinterpretCastExpr
269 (void)reinterpret_cast<Types&>(values); // expected-error{{expression contains unexpanded parameter packs 'Types' and 'values'}}
270
271 // CXXConstCastExpr
272 (void)const_cast<Types&>(values); // expected-error{{expression contains unexpanded parameter packs 'Types' and 'values'}}
273
274 // CXXTypeidExpr
275 (void)typeid(Types); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
276 (void)typeid(values); // expected-error{{expression contains unexpanded parameter pack 'values'}}
277
278 // CXXUuidofExpr
279 (void)__uuidof(Types); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
280 (void)__uuidof(values); // expected-error{{expression contains unexpanded parameter pack 'values'}}
281
282 // CXXThisExpr is uninteresting
283
284 // CXXThrowExpr
285 throw Types(); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
286 throw values; // expected-error{{expression contains unexpanded parameter pack 'values'}}
287
288 // CXXDefaultArgExpr is uninteresting
289
290 // CXXBindTemporaryExpr is uninteresting
291
292 // CXXConstructExpr is uninteresting
293
294 // CXXFunctionalCastExpr
295 (void)Types(); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
296
297 // CXXTemporaryObjectExpr
298 (void)X(values); // expected-error{{expression contains unexpanded parameter pack 'values'}}
299
300 // CXXScalarValueInitExpr is uninteresting
301
302 // CXXNewExpr
303 (void)new Types; // expected-error{{expression contains unexpanded parameter pack 'Types'}}
304 (void)new X(values); // expected-error{{expression contains unexpanded parameter pack 'values'}}
305 (void)new (values) X(values); // expected-error{{expression contains unexpanded parameter pack 'values'}}
306 (void)new X [values]; // expected-error{{expression contains unexpanded parameter pack 'values'}}
307
308 // CXXDeleteExpr
309 delete values; // expected-error{{expression contains unexpanded parameter pack 'values'}}
310 delete [] values; // expected-error{{expression contains unexpanded parameter pack 'values'}}
311
312 // CXXPseudoDestructorExpr
313 T t;
314 values.~T(); // expected-error{{expression contains unexpanded parameter pack 'values'}}
315 t.~Types(); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
316 t.Types::~T(); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
317
318 // Unary TypeTraitExpr
319 __is_pod(Types); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
320
321 // Binary TypeTraitExpr
322 __is_base_of(Types, T); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
323 __is_base_of(T, Types); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
324
325 // UnresolvedLookupExpr
326 test_unexpanded_exprs(values); // expected-error{{expression contains unexpanded parameter pack 'values'}}
327 test_unexpanded_exprs<Types>(); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
328
329 // DependentScopeDeclRefExpr
330 Types::test_unexpanded_exprs(); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
331 T::template test_unexpanded_exprs<Types>(); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
332
333 // CXXUnresolvedConstructExpr
334 Types(5); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
335
336 // CXXDependentScopeMemberExpr
337 values.foo(); // expected-error{{expression contains unexpanded parameter pack 'values'}}
338 t.foo(values); // expected-error{{expression contains unexpanded parameter pack 'values'}}
339
340 // FIXME: There's an evil ambiguity here, because we don't know if
341 // Types refers to the template type parameter pack in scope or a
342 // non-pack member.
343 // t.Types::foo();
344
345 t.template foo<Types>(); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
346
347 // UnresolvedMemberExpr
348 x.f<Types>(); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
349 x.f(values); // expected-error{{expression contains unexpanded parameter pack 'values'}}
350
351 // CXXNoexceptExpr
352 noexcept(values); // expected-error{{expression contains unexpanded parameter pack 'values'}}
353
354 // PackExpansionExpr is uninteresting
355 // SizeOfPackExpr is uninteresting
356
357 // FIXME: Objective-C expressions will need to go elsewhere
358
359 for (auto t : values) { } // expected-error{{expression contains unexpanded parameter pack 'values'}}
360
361 switch (values) { } // expected-error{{expression contains unexpanded parameter pack 'values'}}
362 switch (0) { case 0: case values: ; } // expected-error{{expression contains unexpanded parameter pack 'values'}}
363
364 do { } while (values); // expected-error{{expression contains unexpanded parameter pack 'values'}}
365
366 test:
367 goto *values; // expected-error{{expression contains unexpanded parameter pack 'values'}}
368
369 void f(int arg = values); // expected-error{{default argument contains unexpanded parameter pack 'values'}}
370 }
371
372 // Test unexpanded parameter packs in partial/explicit specializations.
373 namespace Specializations {
374 template<typename T, typename... Ts>
375 struct PrimaryClass;
376 template<typename... Ts>
377 struct PrimaryClass<Ts>; // expected-error{{partial specialization contains unexpanded parameter pack 'Ts'}}
378
379 template<typename T, typename... Ts>
380 void PrimaryFunction();
381 template<typename T, typename... Ts>
382 void PrimaryFunction<Ts>(); // expected-error{{function template partial specialization is not allowed}}
383
384 #if __cplusplus >= 201402L
385 template<typename T, typename... Ts>
386 constexpr int PrimaryVar = 0;
387 template<typename... Ts>
388 constexpr int PrimaryVar<Ts> = 0; // expected-error{{partial specialization contains unexpanded parameter pack 'Ts'}}
389 #endif
390
391 template<typename... Ts>
392 struct OuterClass {
393 template<typename... Us>
394 struct InnerClass;
395 template<>
396 struct InnerClass<Ts>; // expected-error{{explicit specialization contains unexpanded parameter pack 'Ts'}}
397 template<typename U>
398 struct InnerClass<U, Ts>; // expected-error{{partial specialization contains unexpanded parameter pack 'Ts'}}
399
400 template<typename... Us>
401 void InnerFunction();
402 template<>
403 void InnerFunction<Ts>(); // expected-error{{explicit specialization contains unexpanded parameter pack 'Ts'}}
404
405 friend void PrimaryFunction<Ts>(); // expected-error{{friend declaration contains unexpanded parameter pack 'Ts'}}
406
407 #if __cplusplus >= 201402L
408 template<typename... Us>
409 constexpr static int InnerVar = 0;
410 template<>
411 constexpr int InnerVar<Ts> = 0; // expected-error{{explicit specialization contains unexpanded parameter pack 'Ts'}}
412 template<typename U>
413 constexpr static int InnerVar<U, Ts> = 0; // expected-error{{partial specialization contains unexpanded parameter pack 'Ts'}}
414 #endif
415 };
416 }
417
418 // Test for diagnostics in the presence of multiple unexpanded
419 // parameter packs.
420 template<typename T, typename U> struct pair;
421
422 template<typename ...OuterTypes>
423 struct MemberTemplatePPNames {
424 template<typename ...InnerTypes>
425 struct Inner {
426 typedef pair<OuterTypes, InnerTypes>* types; // expected-error{{declaration type contains unexpanded parameter packs 'OuterTypes' and 'InnerTypes'}}
427
428 template<typename ...VeryInnerTypes>
429 struct VeryInner {
430 typedef pair<pair<VeryInnerTypes, OuterTypes>, pair<InnerTypes, OuterTypes> > types; // expected-error{{declaration type contains unexpanded parameter packs 'VeryInnerTypes', 'OuterTypes', ...}}
431 };
432 };
433 };
434
435 // Example from working paper
436 namespace WorkingPaperExample {
437 template<typename...> struct Tuple {};
438 template<typename T1, typename T2> struct Pair {};
439
440 template<class ... Args1> struct zip {
441 template<class ... Args2> struct with {
442 typedef Tuple<Pair<Args1, Args2> ... > type; // expected-error{{pack expansion contains parameter packs 'Args1' and 'Args2' that have different lengths (1 vs. 2)}}
443 };
444 };
445
446 typedef zip<short, int>::with<unsigned short, unsigned>::type T1; // T1 is Tuple<Pair<short, unsigned short>, Pair<int, unsigned>>
447 typedef Tuple<Pair<short, unsigned short>, Pair<int, unsigned>> T1;
448
449 typedef zip<short>::with<unsigned short, unsigned>::type T2; // expected-note{{in instantiation of template class}}
450
451 template<class ... Args> void f(Args...);
452 template<class ... Args> void h(Args...);
453
454 template<class ... Args>
g(Args...args)455 void g(Args ... args) {
456 f(const_cast<const Args*>(&args)...); // OK: "Args" and "args" are expanded within f
457 f(5 ...); // expected-error{{pack expansion does not contain any unexpanded parameter packs}}
458 f(args); // expected-error{{expression contains unexpanded parameter pack 'args'}}
459 f(h(args ...) + args ...);
460 }
461 }
462
463 namespace PR16303 {
464 template<int> struct A { A(int); };
465 template<int...N> struct B {
466 template<int...M> struct C : A<N>... {
CPR16303::B::C467 C() : A<N>(M)... {} // expected-error{{pack expansion contains parameter packs 'N' and 'M' that have different lengths (2 vs. 3)}} expected-error{{pack expansion contains parameter packs 'N' and 'M' that have different lengths (4 vs. 3)}}
468 };
469 };
470 B<1,2>::C<4,5,6> c1; // expected-note{{in instantiation of}}
471 B<1,2,3,4>::C<4,5,6> c2; // expected-note{{in instantiation of}}
472 }
473
474 namespace PR21289 {
475 template<int> using T = int;
476 template<typename> struct S { static const int value = 0; };
477 template<typename> const int vt = 0; // cxx11-warning {{extension}}
478 int f(...);
g()479 template<int ...Ns> void g() {
480 f(T<Ns>()...);
481 f(S<T<Ns>>::value...);
482 f(vt<T<Ns>>...);
483 }
484 template void g<>();
485 template void g<1, 2, 3>();
486 }
487
488 template <class... Ts>
489 int var_expr(Ts... ts);
490
491 template <class... Ts>
492 auto a_function(Ts... ts) -> decltype(var_expr(ts...));
493
494 template <class T>
495 using partial = decltype(a_function<int, T>);
496
use_partial()497 int use_partial() { partial<char> n; }
498
499 namespace PR26017 {
500 template <class T>
501 struct Foo {};
502 template <class... Ts>
503 using FooAlias = Foo<void(Ts...)>;
504
505 template <class... Ts>
506 using FooAliasAlias = FooAlias<Ts..., Ts...>;
507
508 template <class... Ts>
bar(const FooAlias<Ts...> &)509 void bar(const FooAlias<Ts...> &) {}
510
fn()511 int fn() {
512 FooAlias<> a;
513 bar(a);
514
515 FooAlias<int> b;
516 bar(b);
517 }
518 }
519
520 namespace GH58452 {
521 template <typename... As> struct A {
522 template <typename... Bs> using B = void(As...(Bs));
523 };
524
525 template <typename... Cs> struct C {
526 template <typename... Ds> using D = typename A<Cs...>::template B<Ds...>;
527 };
528
529 using t1 = C<int, int>::template D<float, float>;
530
531 template <typename A, typename B>
532 using ConditionalRewrite = B;
533
534 template <typename T>
535 using SignatureType = int;
536
537 template <typename... Args>
538 struct Type1 {
539 template <typename... Params>
540 using Return = SignatureType<int(ConditionalRewrite<Args, Params>...)>;
541
542 };
543
544 template <typename... Args>
545 struct Type2 {
546 using T1 = Type1<Args...>;
547
548 template <typename... Params>
549 using Return = typename T1::template Return<Params...>;
550
551 };
552
553 template <typename T>
InvokeMethod()554 typename T::template Return<int, int> InvokeMethod() {
555 return 3;
556 }
557
Function1()558 int Function1() {
559 return InvokeMethod<Type2<int, int>>();
560 }
561 }
562