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}}
355