|
150
|
1 // RUN: %clang_cc1 -std=c++1z -verify %s
|
|
|
2
|
|
|
3 // Test that we cope with failure to expand a pack.
|
|
|
4 template<typename ...T> struct Unexpanded : T... {
|
|
|
5 using T::f; // expected-error {{unexpanded}}
|
|
|
6 using typename T::type; // expected-error {{unexpanded}}
|
|
|
7 template<typename ...U> void g(U ...u) { f(u...); } // expected-error {{undeclared identifier 'f'}}
|
|
|
8 void h() {
|
|
|
9 Unexpanded<type...> *p; // expected-error {{undeclared identifier 'type'}}
|
|
|
10 }
|
|
|
11 };
|
|
|
12 void test_Unexpanded() {
|
|
|
13 struct A { void f(); }; // expected-note {{must qualify}}
|
|
|
14 struct B { void f(int); }; // expected-note {{must qualify}}
|
|
|
15 Unexpanded<A, B>().g(0); // expected-note {{instantiation of}}
|
|
|
16 }
|
|
|
17
|
|
|
18 // Test using non-type members from pack of base classes.
|
|
|
19 template<typename ...T> struct A : T... {
|
|
|
20 using T::T ...; // expected-note 2{{inherited here}}
|
|
|
21 using T::operator() ...;
|
|
|
22 using T::operator T* ...;
|
|
|
23 using T::h ...;
|
|
|
24
|
|
|
25 void f(int n) { h(n); } // expected-error {{ambiguous}}
|
|
|
26 void f(int n, int m) { h(n, m); } // expected-error {{member using declaration 'h' instantiates to an empty pack}}
|
|
|
27 void g(int n) { (*this)(n); } // expected-error {{ambiguous}}
|
|
|
28 void g(int n, int m) { (*this)(n, m); } // expected-error {{does not provide a call operator}}
|
|
|
29 };
|
|
|
30
|
|
|
31 namespace test_A {
|
|
|
32 struct X {
|
|
|
33 X();
|
|
|
34 X(int); // expected-note {{candidate}}
|
|
|
35 void operator()(int); // expected-note 2{{candidate}}
|
|
|
36 operator X *();
|
|
|
37 void h(int); // expected-note {{candidate}}
|
|
|
38 };
|
|
|
39 struct Y {
|
|
|
40 Y();
|
|
|
41 Y(int, int);
|
|
|
42 void operator()(int, int);
|
|
|
43 operator Y *();
|
|
|
44 void h(int, int);
|
|
|
45 };
|
|
|
46 struct Z {
|
|
|
47 Z();
|
|
|
48 Z(int); // expected-note {{candidate}}
|
|
|
49 void operator()(int); // expected-note 2{{candidate}}
|
|
|
50 operator Z *();
|
|
|
51 void h(int); // expected-note {{candidate}}
|
|
|
52 };
|
|
|
53
|
|
|
54 void f() {
|
|
|
55 A<> a;
|
|
|
56 a.f(0, 0); // expected-note {{instantiation of}}
|
|
|
57 a.g(0, 0); // expected-note {{instantiation of}}
|
|
|
58
|
|
|
59 A<X, Y> axy(0);
|
|
|
60 A<X, Y>(0, 0);
|
|
|
61 axy.f(0);
|
|
|
62 axy.f(0, 0);
|
|
|
63 axy.g(0);
|
|
|
64 axy.g(0, 0);
|
|
|
65 axy(0);
|
|
|
66 axy(0, 0);
|
|
|
67
|
|
|
68 A<X, Y, Z>(0); // expected-error {{ambiguous}}
|
|
|
69 A<X, Y, Z> axyz(0, 0);
|
|
|
70 axyz.f(0); // expected-note {{instantiation of}}
|
|
|
71 axyz.f(0, 0);
|
|
|
72 axyz.g(0); // expected-note {{instantiation of}}
|
|
|
73 axyz.g(0, 0);
|
|
|
74 axyz(0); // expected-error {{ambiguous}}
|
|
|
75 axyz(0, 0);
|
|
|
76
|
|
|
77 X *x;
|
|
|
78 x = a; // expected-error {{incompatible}}
|
|
|
79 x = axy;
|
|
|
80 x = axyz;
|
|
|
81 x = a.operator X*(); // expected-error {{no member}}
|
|
|
82 x = axy.operator X*();
|
|
|
83 x = axyz.operator X*();
|
|
|
84
|
|
|
85 Z *z;
|
|
|
86 z = axyz;
|
|
|
87 z = axyz.operator Z*();
|
|
|
88 }
|
|
|
89 }
|
|
|
90
|
|
|
91 // Test using pack of non-type members from single base class.
|
|
|
92 template<typename X, typename Y, typename ...T> struct B : X, Y {
|
|
|
93 using X::operator T* ...;
|
|
|
94 };
|
|
|
95
|
|
|
96 namespace test_B {
|
|
|
97 struct X { operator int*(); operator float*(); operator char*(); }; // expected-note {{candidate}}
|
|
|
98 struct Y { operator int*(); operator float*(); operator char*(); }; // expected-note {{candidate}}
|
|
|
99 B<X, Y, int, float> bif;
|
|
|
100 int *pi = bif;
|
|
|
101 float *pf = bif;
|
|
|
102 char *pc = bif; // expected-error {{ambiguous}}
|
|
|
103 }
|
|
|
104
|
|
|
105 // Test using type member from pack of base classes.
|
|
|
106 template<typename ...T> struct C : T... {
|
|
|
107 using typename T::type ...; // expected-error {{target of using declaration conflicts}}
|
|
|
108 void f() { type value; } // expected-error {{member using declaration 'type' instantiates to an empty pack}}
|
|
|
109 };
|
|
|
110
|
|
|
111 namespace test_C {
|
|
|
112 struct X { typedef int type; };
|
|
|
113 struct Y { typedef int type; }; // expected-note {{conflicting}}
|
|
|
114 struct Z { typedef float type; }; // expected-note {{target}}
|
|
|
115
|
|
|
116 void f() {
|
|
|
117 C<> c;
|
|
|
118 c.f(); // expected-note {{instantiation of}}
|
|
|
119
|
|
|
120 C<X, Y> cxy;
|
|
|
121 cxy.f();
|
|
|
122
|
|
|
123 C<X, Y, Z> cxyz; // expected-note {{instantiation of}}
|
|
|
124 cxyz.f();
|
|
|
125 }
|
|
|
126 }
|
|
|
127
|
|
|
128 // Test using pack of non-types at block scope.
|
|
|
129 template<typename ...T> int fn1() {
|
|
|
130 using T::e ...; // expected-error 2{{class member}} expected-note 2{{instead}}
|
|
|
131 // expected-error@-1 2{{produces multiple values}}
|
|
|
132 return e; // expected-error {{using declaration 'e' instantiates to an empty pack}}
|
|
|
133 }
|
|
|
134
|
|
|
135 namespace test_fn1 {
|
|
|
136 struct X { static int e; };
|
|
|
137 struct Y { typedef int e; };
|
|
|
138 inline namespace P { enum E { e }; }
|
|
|
139 inline namespace Q { enum F { e }; }
|
|
|
140 void f() {
|
|
|
141 fn1<>(); // expected-note {{instantiation of}}
|
|
|
142 fn1<X>(); // expected-note {{instantiation of}}
|
|
|
143 fn1<Y>(); // expected-note {{instantiation of}}
|
|
|
144 fn1<E>();
|
|
|
145 fn1<E, F>(); // expected-note {{instantiation of}}
|
|
|
146 fn1<E, X>(); // expected-note {{instantiation of}}
|
|
|
147 }
|
|
|
148 }
|
|
|
149
|
|
|
150 // Test using pack of types at block scope.
|
|
|
151 template<typename ...T> void fn2() {
|
|
|
152 // This cannot ever be valid: in order for T::type to be a type, T must be a
|
|
|
153 // class, and a class member cannot be named by a block-scope using declaration.
|
|
|
154 using typename T::type ...; // expected-error {{class member}}
|
|
|
155 type x; // expected-error {{unknown type name 'type'}}
|
|
|
156 }
|
|
|
157
|
|
|
158 // Test partial substitution into class-scope pack.
|
|
|
159 template<typename ...T> auto lambda1() {
|
|
|
160 return [](auto x) {
|
|
|
161 struct A : T::template X<decltype(x)>... { // expected-note 1+{{instantiation of}}
|
|
|
162 using T::template X<decltype(x)>::f ...;
|
|
|
163 using typename T::template X<decltype(x)>::type ...;
|
|
|
164 void g(int n) { f(n); } // expected-error {{empty pack}} expected-error {{expected 2, have 1}} expected-error {{ambiguous}}
|
|
|
165 void h() { type value; } // expected-error {{empty pack}}
|
|
|
166 };
|
|
|
167 return A();
|
|
|
168 };
|
|
|
169 }
|
|
|
170
|
|
|
171 namespace test_lambda1 {
|
|
|
172 struct A {
|
|
|
173 template<typename> struct X {
|
|
|
174 void f(int); // expected-note {{candidate}}
|
|
|
175 using type = int;
|
|
|
176 };
|
|
|
177 };
|
|
|
178 struct B {
|
|
|
179 template<typename> struct X {
|
|
|
180 void f(int, int); // expected-note {{declared here}}
|
|
|
181 using type = int;
|
|
|
182 };
|
|
|
183 };
|
|
|
184 struct C {
|
|
|
185 template<typename> struct X {
|
|
|
186 void f(int); // expected-note {{candidate}}
|
|
|
187 void f(int, int);
|
|
|
188 using type = int;
|
|
|
189 };
|
|
|
190 };
|
|
|
191
|
|
|
192 void f() {
|
|
|
193 lambda1<>() // expected-note 2{{instantiation of}}
|
|
|
194 (0)
|
|
|
195 // FIXME: This is poor error recovery
|
|
|
196 .g(0); // expected-error {{no member named 'g'}}
|
|
|
197 lambda1<A>()
|
|
|
198 (0)
|
|
|
199 .g(0);
|
|
|
200 lambda1<B>()
|
|
|
201 (0) // expected-note {{instantiation of}}
|
|
|
202 .g(0);
|
|
|
203 lambda1<A, B, C>()
|
|
|
204 (0) // expected-note {{instantiation of}}
|
|
|
205 .g(0);
|
|
|
206 }
|
|
|
207 }
|
|
|
208
|
|
|
209 namespace p0195r2_example {
|
|
|
210 template<typename ...Ts>
|
|
|
211 struct Overloader : Ts... {
|
|
|
212 using Ts::operator() ...;
|
|
|
213 };
|
|
|
214
|
|
|
215 template<typename ...Ts>
|
|
|
216 constexpr auto make_overloader(Ts &&...ts) {
|
|
|
217 return Overloader<Ts...>{static_cast<Ts&&>(ts)...};
|
|
|
218 }
|
|
|
219
|
|
|
220 void test() {
|
|
|
221 auto o = make_overloader(
|
|
|
222 [&](int &r) -> int & { return r; }, // expected-note {{candidate function}}
|
|
|
223 [&](float &r) -> float & { return r; } // expected-note {{candidate function}}
|
|
|
224 );
|
|
|
225 int a; float f; double d;
|
|
|
226 int &ra = o(a);
|
|
|
227 float &rf = o(f);
|
|
|
228 double &rd = o(d); // expected-error {{no matching function}}
|
|
|
229 }
|
|
|
230 }
|
