|
150
|
1 // RUN: %clang_cc1 -std=c++11 -verify %s
|
|
|
2
|
|
|
3 template<typename ...T> struct X {};
|
|
|
4
|
|
|
5 template<typename T, typename U> struct P {};
|
|
|
6
|
|
|
7 namespace Nested {
|
|
|
8 template<typename ...T> int f1(X<T, T...>... a); // expected-note +{{packs of different lengths for parameter 'T'}}
|
|
|
9 template<typename ...T> int f2(P<X<T...>, T> ...a); // expected-note +{{packs of different lengths for parameter 'T'}}
|
|
|
10
|
|
|
11 int a1 = f1(X<int, int, double>(), X<double, int, double>());
|
|
|
12 int a2 = f1(X<int, int>());
|
|
|
13 int a3 = f1(X<int>(), X<double>()); // expected-error {{no matching}}
|
|
|
14 int a4 = f1(X<int, int>(), X<int>()); // expected-error {{no matching}}
|
|
|
15 int a5 = f1(X<int>(), X<int, int>()); // expected-error {{no matching}}
|
|
|
16 int a6 = f1(X<int, int, int>(), X<int, int, int>(), X<int, int, int, int>()); // expected-error {{no matching}}
|
|
|
17
|
|
|
18 int b1 = f2(P<X<int, double>, int>(), P<X<int, double>, double>());
|
|
|
19 int b2 = f2(P<X<int, double>, int>(), P<X<int, double>, double>(), P<X<int, double>, char>()); // expected-error {{no matching}}
|
|
|
20 }
|
|
|
21
|
|
|
22 namespace PR14841 {
|
|
|
23 template<typename T, typename U> struct A {};
|
|
|
24 template<typename ...Ts> void f(A<Ts...>); // expected-note {{substitution failure [with Ts = <char, short, int>]: too many template arg}}
|
|
|
25
|
|
|
26 void g(A<char, short> a) {
|
|
|
27 f(a);
|
|
|
28 f<char>(a);
|
|
|
29 f<char, short>(a);
|
|
|
30 f<char, short, int>(a); // expected-error {{no matching function}}
|
|
|
31 }
|
|
|
32 }
|
|
|
33
|
|
|
34 namespace RetainExprPacks {
|
|
|
35 int f(int a, int b, int c);
|
|
|
36 template<typename ...Ts> struct X {};
|
|
|
37 template<typename ...Ts> int g(X<Ts...>, decltype(f(Ts()...)));
|
|
|
38 int n = g<int, int>(X<int, int, int>(), 0);
|
|
|
39 }
|
|
|
40
|
|
|
41 namespace PR14615 {
|
|
|
42 namespace comment0 {
|
|
|
43 template <class A, class...> struct X {};
|
|
|
44 template <class... B> struct X<int, B...> {
|
|
|
45 typedef int type;
|
|
|
46 struct valid {};
|
|
|
47 };
|
|
|
48 template <typename A, typename... B, typename T = X<A, B...>,
|
|
|
49 typename = typename T::valid>
|
|
|
50 typename T::type check(int);
|
|
|
51 int i = check<int, char>(1);
|
|
|
52 }
|
|
|
53
|
|
|
54 namespace comment2 {
|
|
|
55 template <class...> struct X;
|
|
|
56 template <typename... B, typename X<B...>::type I = 0>
|
|
|
57 char check(B...); // expected-note {{undefined template 'PR14615::comment2::X<char, int>'}}
|
|
|
58 void f() { check<char>(1, 2); } // expected-error {{no matching function}}
|
|
|
59 }
|
|
|
60
|
|
|
61 namespace comment3 {
|
|
|
62 template <class...> struct X;
|
|
|
63 template <typename... B, typename X<B...>::type I = (typename X<B...>::type)0>
|
|
|
64 char check(B...); // expected-note {{undefined template 'PR14615::comment3::X<char, int>'}}
|
|
|
65 void f() { check<char>(1, 2); } // expected-error {{no matching function}}
|
|
|
66 }
|
|
|
67 }
|
|
|
68
|
|
|
69 namespace fully_expanded_packs {
|
|
|
70 template<typename ...T> struct A {
|
|
|
71 template<T ...X> static constexpr int f() {
|
|
|
72 // expected-note@-1 1+{{deduced too few arguments for expanded pack 'X'}}
|
|
|
73 // expected-note@-2 1+{{too many template arguments}}
|
|
|
74 return (X + ... + 0); // expected-warning {{extension}}
|
|
|
75 }
|
|
|
76
|
|
|
77 template<T ...X, int Y> static constexpr int g() {
|
|
|
78 // expected-note@-1 1+{{deduced too few arguments for expanded pack 'X'}}
|
|
|
79 // expected-note@-2 1+{{couldn't infer template argument 'Y'}}
|
|
|
80 // expected-note@-3 1+{{too many template arguments}}
|
|
|
81 return (X + ... + (1000 * Y)); // expected-warning {{extension}}
|
|
|
82 }
|
|
|
83
|
|
|
84 template<T ...X, int Y, T ...Z> static constexpr int h() {
|
|
|
85 // expected-note@-1 1+{{deduced too few arguments for expanded pack 'X'}}
|
|
|
86 // expected-note@-2 1+{{couldn't infer template argument 'Y'}}
|
|
|
87 // expected-note@-3 1+{{deduced too few arguments for expanded pack 'Z'}}
|
|
|
88 // expected-note@-4 1+{{too many template arguments}}
|
|
|
89 return (X + ... + (1000 * Y)) + 1000000 * (Z + ... + 0); // expected-warning 2{{extension}}
|
|
|
90 }
|
|
|
91
|
|
|
92 template<T ...X, int ...Z> static constexpr int i() {
|
|
|
93 return (X + ... + 0) + 1000 * (Z + ... + 0); // expected-warning 2{{extension}}
|
|
|
94 }
|
|
|
95
|
|
|
96 template<T ...X, int Y, int ...Z> static constexpr int j() {
|
|
|
97 return (X + ... + (1000 * Y)) + 1000000 * (Z + ... + 0); // expected-warning 2{{extension}}
|
|
|
98 }
|
|
|
99 };
|
|
|
100
|
|
|
101 void check_invalid_calls() {
|
|
|
102 A<int, int>::f(); // expected-error {{no matching function}}
|
|
|
103 A<int, int>::f<>(); // expected-error {{no matching function}}
|
|
|
104 A<int, int>::f<0>(); // expected-error {{no matching function}}
|
|
|
105 A<int, int>::g(); // expected-error {{no matching function}}
|
|
|
106 A<int, int>::g<>(); // expected-error {{no matching function}}
|
|
|
107 A<int, int>::g<0>(); // expected-error {{no matching function}}
|
|
|
108 A<int, int>::g<0, 0>(); // expected-error {{no matching function}}
|
|
|
109 A<>::f<0>(); // expected-error {{no matching function}}
|
|
|
110 A<>::g(); // expected-error {{no matching function}}
|
|
|
111 A<>::g<>(); // expected-error {{no matching function}}
|
|
|
112 A<>::g<0, 0>(); // expected-error {{no matching function}}
|
|
|
113 A<>::h<>(); // expected-error {{no matching function}}
|
|
|
114 A<int>::h<>(); // expected-error {{no matching function}}
|
|
|
115 A<int>::h<0, 0>(); // expected-error {{no matching function}}
|
|
|
116 A<>::h<0, 0>(); // expected-error {{no matching function}}
|
|
|
117 }
|
|
|
118
|
|
|
119 static_assert(A<>::f() == 0, "");
|
|
|
120 static_assert(A<int>::f<1>() == 1, "");
|
|
|
121 static_assert(A<>::g<1>() == 1000, "");
|
|
|
122 static_assert(A<int>::g<1, 2>() == 2001, "");
|
|
|
123 static_assert(A<>::h<1>() == 1000, "");
|
|
|
124 static_assert(A<int>::h<1, 2, 3>() == 3002001, "");
|
|
|
125 static_assert(A<int, int>::h<1, 20, 3, 4, 50>() == 54003021, "");
|
|
|
126 static_assert(A<>::i<1>() == 1000, "");
|
|
|
127 static_assert(A<int>::i<1>() == 1, "");
|
|
|
128 static_assert(A<>::j<1, 2, 30>() == 32001000, "");
|
|
|
129 static_assert(A<int>::j<1, 2, 3, 40>() == 43002001, "");
|
|
|
130 }
|
|
|
131
|
|
|
132 namespace partial_full_mix {
|
|
|
133 template<typename T, typename U> struct pair {};
|
|
|
134 template<typename ...T> struct tuple {};
|
|
|
135 template<typename ...T> struct A {
|
|
|
136 template<typename ...U> static pair<tuple<T...>, tuple<U...>> f(pair<T, U> ...p);
|
|
236
|
137 // expected-note@-1 {{[with U = <char, double, long>]: pack expansion contains parameter packs 'T' and 'U' that have different lengths (2 vs. 3)}}
|
|
150
|
138 // expected-note@-2 {{[with U = <char, double, void>]: pack expansion contains parameter pack 'U' that has a different length (at least 3 vs. 2) from outer parameter packs}}
|
|
|
139
|
|
|
140 template<typename ...U> static pair<tuple<T...>, tuple<U...>> g(pair<T, U> ...p, ...);
|
|
236
|
141 // expected-note@-1 {{[with U = <char, double, long>]: pack expansion contains parameter packs 'T' and 'U' that have different lengths (2 vs. 3)}}
|
|
150
|
142
|
|
|
143 template<typename ...U> static tuple<U...> h(tuple<pair<T, U>..., pair<int, int>>);
|
|
236
|
144 // expected-note@-1 {{[with U = <int[2]>]: pack expansion contains parameter packs 'T' and 'U' that have different lengths (2 vs. 1)}}
|
|
150
|
145 };
|
|
|
146
|
|
|
147 pair<tuple<int, float>, tuple<char, double>> k1 = A<int, float>().f<char>(pair<int, char>(), pair<float, double>());
|
|
|
148 pair<tuple<int, float>, tuple<char, double>> k2 = A<int, float>().f<char>(pair<int, char>(), pair<float, double>(), pair<void, long>()); // expected-error {{no match}}
|
|
|
149 pair<tuple<int, float>, tuple<char, double>> k3 = A<int, float>().f<char, double, void>(pair<int, char>(), pair<float, double>()); // expected-error {{no match}}
|
|
|
150
|
|
|
151 // FIXME: We should accept this by treating the pack 'p' as having a fixed length of 2 here.
|
|
|
152 pair<tuple<int, float>, tuple<char, double>> k4 = A<int, float>().g<char>(pair<int, char>(), pair<float, double>(), pair<void, long>()); // expected-error {{no match}}
|
|
|
153
|
|
|
154 // FIXME: We should accept this by treating the pack of pairs as having a fixed length of 2 here.
|
|
|
155 tuple<int[2], int[4]> k5 = A<int[1], int[3]>::h<int[2]>(tuple<pair<int[1], int[2]>, pair<int[3], int[4]>, pair<int, int>>()); // expected-error {{no match}}
|
|
|
156 }
|
|
|
157
|
|
|
158 namespace substitution_vs_function_deduction {
|
|
|
159 template <typename... T> struct A {
|
|
|
160 template <typename... U> void f(void(*...)(T, U)); // expected-warning {{ISO C++11 requires a parenthesized pack declaration to have a name}}
|
|
|
161 template <typename... U> void g(void...(T, U)); // expected-note {{could not match 'void (T, U)' against 'void (*)(int, int)'}}
|
|
|
162 };
|
|
|
163 void f(int, int) {
|
|
|
164 A<int>().f(f);
|
|
|
165 // FIXME: We fail to decay the parameter to a pointer type.
|
|
|
166 A<int>().g(f); // expected-error {{no match}}
|
|
|
167 }
|
|
|
168 }
|
|
|
169
|
|
|
170 namespace Nested_Explicit_Specialization {
|
|
|
171 template <typename>
|
|
|
172 struct Outer {
|
|
|
173
|
|
|
174 template <int>
|
|
|
175 struct Inner;
|
|
|
176
|
|
|
177 template <>
|
|
|
178 struct Inner<0> {
|
|
|
179 template <typename... Args>
|
|
|
180 void Test(Args...) {}
|
|
|
181 };
|
|
|
182 };
|
|
|
183
|
|
|
184 void Run() {
|
|
|
185 Outer<void>::Inner<0>().Test(1,1);
|
|
|
186 }
|
|
|
187 }
|
