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