1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -fexceptions -fcxx-exceptions -verify %s
2 // RUN: %clang_cc1 -std=c++2a -fsyntax-only -fexceptions -fcxx-exceptions -verify %s
3
4 template<typename... Types> struct tuple;
5 template<int I> struct int_c;
6
7 template<typename T>
8 struct identity {
9 typedef T type;
10 };
11
12 template<typename T, typename U>
13 struct is_same {
14 static const bool value = false;
15 };
16
17 template<typename T>
18 struct is_same<T, T> {
19 static const bool value = true;
20 };
21
22 // FIXME: Several more bullets to go
23
24 // In a function parameter pack, the pattern is the parameter-declaration
25 // without the ellipsis.
26 namespace PR11850 {
27 template<typename ...T> struct S {
fPR11850::S28 int f(T...a, int b) { return b; }
29 };
30 S<> s;
31 S<int*, char, const double&> t;
32 int k = s.f(0);
33 int l = t.f(&k, 'x', 5.9, 4);
34
35 template<typename ...As> struct A {
36 template<typename ...Bs> struct B {
37 template<typename ...Cs> struct C {
38 C(As..., Bs..., int &k, Cs...);
39 };
40 };
41 };
42 A<>::B<>::C<> c000(k);
43 A<int>::B<>::C<int> c101(1, k, 3);
44 A<>::B<int>::C<int> c011(1, k, 3);
45 A<int>::B<int>::C<> c110(1, 2, k);
46 A<int, int>::B<int, int>::C<int, int> c222(1, 2, 3, 4, k, 5, 6);
47 A<int, int, int>::B<>::C<> c300(1, 2, 3, k);
48
49 int &f();
50 char &f(void*);
51 template<typename ...A> struct U {
52 template<typename ...B> struct V {
53 auto g(A...a, B...b) -> decltype(f(a...));
54 };
55 };
56 U<>::V<int*> v0;
57 U<int*>::V<> v1;
58 int &v0f = v0.g(0);
59 char &v1f = v1.g(0);
60 }
61 namespace PR12096 {
Foo(int)62 void Foo(int) {}
63 void Foo(int, int) = delete;
64 template<typename ...Args> struct Var {
VarPR12096::Var65 Var(const Args &...args, int *) { Foo(args...); }
66 };
67 Var<int> var(1, 0);
68 }
69
70 // In an initializer-list (8.5); the pattern is an initializer-clause.
71 // Note: this also covers expression-lists, since expression-list is
72 // just defined as initializer-list.
73 void five_args(int, int, int, int, int); // expected-note{{candidate function not viable: requires 5 arguments, but 6 were provided}}
74
75 template<int ...Values>
initializer_list_expansion()76 void initializer_list_expansion() {
77 int values[5] = { Values... }; // expected-error{{excess elements in array initializer}}
78 five_args(Values...); // expected-error{{no matching function for call to 'five_args'}}
79 }
80
81 template void initializer_list_expansion<1, 2, 3, 4, 5>();
82 template void initializer_list_expansion<1, 2, 3, 4, 5, 6>(); // expected-note{{in instantiation of function template specialization 'initializer_list_expansion<1, 2, 3, 4, 5, 6>' requested here}}
83
84 namespace PR8977 {
85 struct A { };
f(Args...args)86 template<typename T, typename... Args> void f(Args... args) {
87 // An empty expression-list performs value initialization.
88 constexpr T t(args...);
89 };
90
91 template void f<A>();
92 }
93
94 // In a base-specifier-list (Clause 10); the pattern is a base-specifier.
95 template<typename ...Mixins>
96 struct HasMixins : public Mixins... {
97 HasMixins();
98 HasMixins(const HasMixins&);
99 HasMixins(int i);
100 };
101
102 struct A { }; // expected-note{{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'int' to 'const A' for 1st argument}} \
103 // expected-note{{candidate constructor (the implicit move constructor) not viable: no known conversion from 'int' to 'A' for 1st argument}} \
104 // expected-note{{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
105 struct B { }; // expected-note{{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'int' to 'const B' for 1st argument}} \
106 // expected-note{{candidate constructor (the implicit move constructor) not viable: no known conversion from 'int' to 'B' for 1st argument}} \
107 // expected-note{{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
108 struct C { };
109 struct D { };
110
111 A *checkA = new HasMixins<A, B, C, D>;
112 B *checkB = new HasMixins<A, B, C, D>;
113 D *checkD = new HasMixins<A, B, C, D>;
114 C *checkC = new HasMixins<A, B, D>; // expected-error{{cannot initialize a variable of type 'C *' with an rvalue of type 'HasMixins<A, B, D> *'}}
115 HasMixins<> *checkNone = new HasMixins<>;
116
117 template<typename Mixins>
118 struct BrokenMixins : public Mixins... { }; // expected-error{{pack expansion does not contain any unexpanded parameter packs}}
119
120 // In a mem-initializer-list (12.6.2); the pattern is a mem-initializer.
121 template<typename ...Mixins>
HasMixins()122 HasMixins<Mixins...>::HasMixins(): Mixins()... { }
123
124 template<typename ...Mixins>
HasMixins(const HasMixins & other)125 HasMixins<Mixins...>::HasMixins(const HasMixins &other): Mixins(other)... { }
126
127 template<typename ...Mixins>
HasMixins(int i)128 HasMixins<Mixins...>::HasMixins(int i): Mixins(i)... { }
129 // expected-error@-1 {{no matching constructor for initialization of 'A'}}
130 // expected-error@-2 {{no matching constructor for initialization of 'B'}}
131
test_has_mixins()132 void test_has_mixins() {
133 HasMixins<A, B> ab;
134 HasMixins<A, B> ab2 = ab;
135 HasMixins<A, B> ab3(17); // expected-note{{in instantiation of member function 'HasMixins<A, B>::HasMixins' requested here}}
136 }
137
138 template<typename T>
139 struct X {
140 T member;
141
XX142 X() : member()... { } // expected-error{{pack expansion for initialization of member 'member'}}
143 };
144
145 // There was a bug in the delayed parsing code for the
146 // following case.
147 template<typename ...T>
148 struct DelayedParseTest : T...
149 {
150 int a;
DelayedParseTestDelayedParseTest151 DelayedParseTest(T... i) : T{i}..., a{10} {}
152 };
153
154
155 // In a template-argument-list (14.3); the pattern is a template-argument.
156 template<typename ...Types>
157 struct tuple_of_refs {
158 typedef tuple<Types& ...> types;
159 };
160
161 tuple<int&, float&> *t_int_ref_float_ref;
162 tuple_of_refs<int&, float&>::types *t_int_ref_float_ref_2 = t_int_ref_float_ref;
163
164 template<typename ...Types>
165 struct extract_nested_types {
166 typedef tuple<typename Types::type...> types;
167 };
168
169 tuple<int, float> *t_int_float;
170 extract_nested_types<identity<int>, identity<float> >::types *t_int_float_2
171 = t_int_float;
172
173 template<int ...N>
174 struct tuple_of_ints {
175 typedef tuple<int_c<N>...> type;
176 };
177
178 int check_temp_arg_1[is_same<tuple_of_ints<1, 2, 3, 4, 5>::type,
179 tuple<int_c<1>, int_c<2>, int_c<3>, int_c<4>,
180 int_c<5>>>::value? 1 : -1];
181
182 #if __cplusplus < 201703L
183 // In a dynamic-exception-specification (15.4); the pattern is a type-id.
184 template<typename ...Types>
185 struct f_with_except {
186 virtual void f() throw(Types...); // expected-note{{overridden virtual function is here}}
187 };
188
189 struct check_f_with_except_1 : f_with_except<int, float> {
190 virtual void f() throw(int, float);
191 };
192
193 struct check_f_with_except_2 : f_with_except<int, float> {
194 virtual void f() throw(int);
195 };
196
197 struct check_f_with_except_3 : f_with_except<int, float> {
198 virtual void f() throw(int, float, double); // expected-error{{exception specification of overriding function is more lax than base version}}
199 };
200 #endif
201
202 namespace PackExpansionWithinLambda {
203 void swallow(...);
f(U...u)204 template<typename ...T, typename ...U> void f(U ...u) {
205 swallow([=] {
206 // C++17 [temp.variadic]p4:
207 // Pack expansions can occur in the following contexts:
208
209 // - in a function parameter pack
210 void g(T...);
211
212 #if __cplusplus >= 201703L
213 struct A : T... {
214 // - in a using-declaration
215 using T::x...;
216 using typename T::U...;
217 };
218 #endif
219
220 #if __cplusplus > 201703L
221 // - in a template parameter pack that is a pack expansion
222 swallow([]<T *...v, template<T *> typename ...W>(W<v> ...wv) { });
223 #endif
224
225 // - in an initializer-list
226 int arr[] = {T().x...};
227
228 // - in a base-specifier-list
229 struct B : T... {
230 // - in a mem-initializer-list
231 B() : T{0}... {}
232 };
233
234 // - in a template-argument-list
235 f<T...>();
236
237 // - in an attribute-list
238 // FIXME: We do not support any such attributes yet.
239
240 // - in an alignment-specifier
241 alignas(T...) int y;
242
243 // - in a capture-list
244 [](T ...t) { [t...]{}(); } (T()...);
245
246 // - in a sizeof... expression
247 const int k1 = sizeof...(T);
248
249 #if __cplusplus >= 201703L
250 // - in a fold-expression
251 const int k2 = ((sizeof(T)/sizeof(T)) + ...);
252
253 static_assert(k1 == k2);
254 #endif
255
256 // Trigger clang to look in here for unexpanded packs.
257 U u;
258 } ...);
259 }
260
nested()261 template<typename ...T> void nested() {
262 swallow([=] {
263 [](T ...t) { [t]{}(); } (T()...); // expected-error {{unexpanded parameter pack 't'}}
264 }...); // expected-error {{does not contain any unexpanded}}
265 }
266
g()267 template <typename ...T> void g() {
268 // Check that we do detect the above cases when the pack is not expanded.
269 swallow([=] { void h(T); }); // expected-error {{unexpanded parameter pack 'T'}}
270 swallow([=] { struct A : T {}; }); // expected-error {{unexpanded parameter pack 'T'}}
271 #if __cplusplus >= 201703L
272 swallow([=] { struct A : T... { using T::x; }; }); // expected-error {{unexpanded parameter pack 'T'}}
273 swallow([=] { struct A : T... { using typename T::U; }; }); // expected-error {{unexpanded parameter pack 'T'}}
274 #endif
275
276 swallow([=] { int arr[] = {T().x}; }); // expected-error {{unexpanded parameter pack 'T'}}
277 swallow([=] { struct B : T... { B() : T{0} {} }; }); // expected-error {{unexpanded parameter pack 'T'}}
278 swallow([=] { f<T>(); }); // expected-error {{unexpanded parameter pack 'T'}}
279 swallow([=] { alignas(T) int y; }); // expected-error {{unexpanded parameter pack 'T'}}
280 swallow([=] { [](T ...t) {
281 [t]{}(); // expected-error {{unexpanded parameter pack 't'}}
282 } (T()...); });
283 }
284
285 struct T { int x; using U = int; };
g()286 void g() { f<T>(1, 2, 3); }
287
pack_expand_attr()288 template<typename ...T> void pack_expand_attr() {
289 // FIXME: Move this test into 'f' above once we support this.
290 [[gnu::aligned(alignof(T))...]] int x; // expected-error {{cannot be used as an attribute pack}} expected-error {{unexpanded}}
291 }
292 }
293