]>
Commit | Line | Data |
---|---|---|
1 | // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s | |
2 | ||
3 | // --------------------------------------------------------------------- | |
4 | // C++ Functional Casts | |
5 | // --------------------------------------------------------------------- | |
6 | template<int N> | |
7 | struct ValueInit0 { | |
8 | int f() { | |
9 | return int(); | |
10 | } | |
11 | }; | |
12 | ||
13 | template struct ValueInit0<5>; | |
14 | ||
15 | template<int N> | |
16 | struct FunctionalCast0 { | |
17 | int f() { | |
18 | return int(N); | |
19 | } | |
20 | }; | |
21 | ||
22 | template struct FunctionalCast0<5>; | |
23 | ||
24 | struct X { // expected-note 3 {{candidate constructor (the implicit copy constructor)}} | |
25 | X(int, int); // expected-note 3 {{candidate constructor}} | |
26 | }; | |
27 | ||
28 | template<int N, int M> | |
29 | struct BuildTemporary0 { | |
30 | X f() { | |
31 | return X(N, M); | |
32 | } | |
33 | }; | |
34 | ||
35 | template struct BuildTemporary0<5, 7>; | |
36 | ||
37 | template<int N, int M> | |
38 | struct Temporaries0 { | |
39 | void f() { | |
40 | (void)X(N, M); | |
41 | } | |
42 | }; | |
43 | ||
44 | template struct Temporaries0<5, 7>; | |
45 | ||
46 | // Ensure that both the constructor and the destructor are instantiated by | |
47 | // checking for parse errors from each. | |
48 | template<int N> struct BadX { | |
49 | BadX() { int a[-N]; } // expected-error {{array with a negative size}} | |
50 | ~BadX() { int a[-N]; } // expected-error {{array with a negative size}} | |
51 | }; | |
52 | ||
53 | template<int N> | |
54 | struct PR6671 { | |
55 | void f() { (void)BadX<1>(); } // expected-note 2 {{instantiation}} | |
56 | }; | |
57 | template struct PR6671<1>; | |
58 | ||
59 | // --------------------------------------------------------------------- | |
60 | // new/delete expressions | |
61 | // --------------------------------------------------------------------- | |
62 | struct Y { }; | |
63 | ||
64 | template<typename T> | |
65 | struct New0 { | |
66 | T* f(bool x) { | |
67 | if (x) | |
68 | return new T; // expected-error{{no matching}} | |
69 | else | |
70 | return new T(); | |
71 | } | |
72 | }; | |
73 | ||
74 | template struct New0<int>; | |
75 | template struct New0<Y>; | |
76 | template struct New0<X>; // expected-note{{instantiation}} | |
77 | ||
78 | template<typename T, typename Arg1> | |
79 | struct New1 { | |
80 | T* f(bool x, Arg1 a1) { | |
81 | return new T(a1); // expected-error{{no matching}} | |
82 | } | |
83 | }; | |
84 | ||
85 | template struct New1<int, float>; | |
86 | template struct New1<Y, Y>; | |
87 | template struct New1<X, Y>; // expected-note{{instantiation}} | |
88 | ||
89 | template<typename T, typename Arg1, typename Arg2> | |
90 | struct New2 { | |
91 | T* f(bool x, Arg1 a1, Arg2 a2) { | |
92 | return new T(a1, a2); // expected-error{{no matching}} | |
93 | } | |
94 | }; | |
95 | ||
96 | template struct New2<X, int, float>; | |
97 | template struct New2<X, int, int*>; // expected-note{{instantiation}} | |
98 | // FIXME: template struct New2<int, int, float>; | |
99 | ||
100 | // PR5833 | |
101 | struct New3 { | |
102 | New3(); | |
103 | ||
104 | void *operator new[](__SIZE_TYPE__) __attribute__((unavailable)); // expected-note{{explicitly made unavailable}} | |
105 | }; | |
106 | ||
107 | template<class C> | |
108 | void* object_creator() { | |
109 | return new C(); // expected-error{{call to unavailable function 'operator new[]'}} | |
110 | } | |
111 | ||
112 | template void *object_creator<New3[4]>(); // expected-note{{instantiation}} | |
113 | ||
114 | template<typename T> | |
115 | struct Delete0 { | |
116 | void f(T t) { | |
117 | delete t; // expected-error{{cannot delete}} | |
118 | ::delete [] t; // expected-error{{cannot delete}} | |
119 | } | |
120 | }; | |
121 | ||
122 | template struct Delete0<int*>; | |
123 | template struct Delete0<X*>; | |
124 | template struct Delete0<int>; // expected-note{{instantiation}} | |
125 | ||
126 | namespace PR5755 { | |
127 | template <class T> | |
128 | void Foo() { | |
129 | char* p = 0; | |
130 | delete[] p; | |
131 | } | |
132 | ||
133 | void Test() { | |
134 | Foo<int>(); | |
135 | } | |
136 | } | |
137 | ||
138 | namespace PR10480 { | |
139 | template<typename T> | |
140 | struct X { | |
141 | X(); | |
142 | ~X() { | |
143 | T *ptr = 1; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}} | |
144 | } | |
145 | }; | |
146 | ||
147 | template<typename T> | |
148 | void f() { | |
149 | new X<int>[1]; // expected-note{{in instantiation of member function 'PR10480::X<int>::~X' requested here}} | |
150 | } | |
151 | ||
152 | template void f<int>(); | |
153 | } | |
154 | ||
155 | // --------------------------------------------------------------------- | |
156 | // throw expressions | |
157 | // --------------------------------------------------------------------- | |
158 | template<typename T> | |
159 | struct Throw1 { | |
160 | void f(T t) { | |
161 | throw; | |
162 | throw t; // expected-error{{incomplete type}} | |
163 | } | |
164 | }; | |
165 | ||
166 | struct Incomplete; // expected-note 2{{forward}} | |
167 | ||
168 | template struct Throw1<int>; | |
169 | template struct Throw1<int*>; | |
170 | template struct Throw1<Incomplete*>; // expected-note{{instantiation}} | |
171 | ||
172 | // --------------------------------------------------------------------- | |
173 | // typeid expressions | |
174 | // --------------------------------------------------------------------- | |
175 | ||
176 | namespace std { | |
177 | class type_info; | |
178 | } | |
179 | ||
180 | template<typename T> | |
181 | struct TypeId0 { | |
182 | const std::type_info &f(T* ptr) { | |
183 | if (ptr) | |
184 | return typeid(ptr); | |
185 | else | |
186 | return typeid(T); // expected-error{{'typeid' of incomplete type 'Incomplete'}} | |
187 | } | |
188 | }; | |
189 | ||
190 | struct Abstract { | |
191 | virtual void f() = 0; | |
192 | }; | |
193 | ||
194 | template struct TypeId0<int>; | |
195 | template struct TypeId0<Incomplete>; // expected-note{{instantiation of member function}} | |
196 | template struct TypeId0<Abstract>; | |
197 | ||
198 | // --------------------------------------------------------------------- | |
199 | // type traits | |
200 | // --------------------------------------------------------------------- | |
201 | template<typename T> | |
202 | struct is_pod { | |
203 | static const bool value = __is_pod(T); | |
204 | }; | |
205 | ||
206 | static int is_pod0[is_pod<X>::value? -1 : 1]; | |
207 | static int is_pod1[is_pod<Y>::value? 1 : -1]; | |
208 | ||
209 | // --------------------------------------------------------------------- | |
210 | // initializer lists | |
211 | // --------------------------------------------------------------------- | |
212 | template<typename T, typename Val1> | |
213 | struct InitList1 { | |
214 | void f(Val1 val1) { | |
215 | T x = { val1 }; | |
216 | } | |
217 | }; | |
218 | ||
219 | struct APair { | |
220 | int *x; | |
221 | const float *y; | |
222 | }; | |
223 | ||
224 | template struct InitList1<int[1], float>; | |
225 | template struct InitList1<APair, int*>; | |
226 | ||
227 | template<typename T, typename Val1, typename Val2> | |
228 | struct InitList2 { | |
229 | void f(Val1 val1, Val2 val2) { | |
230 | T x = { val1, val2 }; // expected-error{{cannot initialize}} | |
231 | } | |
232 | }; | |
233 | ||
234 | template struct InitList2<APair, int*, float*>; | |
235 | template struct InitList2<APair, int*, double*>; // expected-note{{instantiation}} | |
236 | ||
237 | // --------------------------------------------------------------------- | |
238 | // member references | |
239 | // --------------------------------------------------------------------- | |
240 | template<typename T, typename Result> | |
241 | struct DotMemRef0 { | |
242 | void f(T t) { | |
243 | Result result = t.m; // expected-error{{non-const lvalue reference to type}} | |
244 | } | |
245 | }; | |
246 | ||
247 | struct MemInt { | |
248 | int m; | |
249 | }; | |
250 | ||
251 | struct InheritsMemInt : MemInt { }; | |
252 | ||
253 | struct MemIntFunc { | |
254 | static int m(int); | |
255 | }; | |
256 | ||
257 | template struct DotMemRef0<MemInt, int&>; | |
258 | template struct DotMemRef0<InheritsMemInt, int&>; | |
259 | template struct DotMemRef0<MemIntFunc, int (*)(int)>; | |
260 | template struct DotMemRef0<MemInt, float&>; // expected-note{{instantiation}} | |
261 | ||
262 | template<typename T, typename Result> | |
263 | struct ArrowMemRef0 { | |
264 | void f(T t) { | |
265 | Result result = t->m; // expected-error 2{{non-const lvalue reference}} | |
266 | } | |
267 | }; | |
268 | ||
269 | template<typename T> | |
270 | struct ArrowWrapper { | |
271 | T operator->(); | |
272 | }; | |
273 | ||
274 | template struct ArrowMemRef0<MemInt*, int&>; | |
275 | template struct ArrowMemRef0<InheritsMemInt*, int&>; | |
276 | template struct ArrowMemRef0<MemIntFunc*, int (*)(int)>; | |
277 | template struct ArrowMemRef0<MemInt*, float&>; // expected-note{{instantiation}} | |
278 | ||
279 | template struct ArrowMemRef0<ArrowWrapper<MemInt*>, int&>; | |
280 | template struct ArrowMemRef0<ArrowWrapper<InheritsMemInt*>, int&>; | |
281 | template struct ArrowMemRef0<ArrowWrapper<MemIntFunc*>, int (*)(int)>; | |
282 | template struct ArrowMemRef0<ArrowWrapper<MemInt*>, float&>; // expected-note{{instantiation}} | |
283 | template struct ArrowMemRef0<ArrowWrapper<ArrowWrapper<MemInt*> >, int&>; | |
284 | ||
285 | struct UnresolvedMemRefArray { | |
286 | int f(int); | |
287 | int f(char); | |
288 | }; | |
289 | UnresolvedMemRefArray Arr[10]; | |
290 | template<typename U> int UnresolvedMemRefArrayT(U u) { | |
291 | return Arr->f(u); | |
292 | } | |
293 | template int UnresolvedMemRefArrayT<int>(int); | |
294 | ||
295 | // FIXME: we should be able to return a MemInt without the reference! | |
296 | MemInt &createMemInt(int); | |
297 | ||
298 | template<int N> | |
299 | struct NonDepMemberExpr0 { | |
300 | void f() { | |
301 | createMemInt(N).m = N; | |
302 | } | |
303 | }; | |
304 | ||
305 | template struct NonDepMemberExpr0<0>; | |
306 | ||
307 | template<typename T, typename Result> | |
308 | struct MemberFuncCall0 { | |
309 | void f(T t) { | |
310 | Result result = t.f(); | |
311 | } | |
312 | }; | |
313 | ||
314 | template<typename T> | |
315 | struct HasMemFunc0 { | |
316 | T f(); | |
317 | }; | |
318 | ||
319 | ||
320 | template struct MemberFuncCall0<HasMemFunc0<int&>, const int&>; | |
321 | ||
322 | template<typename Result> | |
323 | struct ThisMemberFuncCall0 { | |
324 | Result g(); | |
325 | ||
326 | void f() { | |
327 | Result r1 = g(); | |
328 | Result r2 = this->g(); | |
329 | } | |
330 | }; | |
331 | ||
332 | template struct ThisMemberFuncCall0<int&>; | |
333 | ||
334 | template<typename T> | |
335 | struct NonDepMemberCall0 { | |
336 | void foo(HasMemFunc0<int&> x) { | |
337 | T result = x.f(); // expected-error{{non-const lvalue reference}} | |
338 | } | |
339 | }; | |
340 | ||
341 | template struct NonDepMemberCall0<int&>; | |
342 | template struct NonDepMemberCall0<const int&>; | |
343 | template struct NonDepMemberCall0<float&>; // expected-note{{instantiation}} | |
344 | ||
345 | ||
346 | template<typename T> | |
347 | struct QualifiedDeclRef0 { | |
348 | T f() { | |
349 | return is_pod<X>::value; // expected-error{{non-const lvalue reference to type 'int' cannot bind to a value of unrelated type 'const bool'}} | |
350 | } | |
351 | }; | |
352 | ||
353 | template struct QualifiedDeclRef0<bool>; | |
354 | template struct QualifiedDeclRef0<int&>; // expected-note{{instantiation}} |