1 // RUN: %clang_cc1 -fsyntax-only -verify %s -triple=i686-pc-linux-gnu
2 
3 #include <stddef.h>
4 
5 struct S // expected-note {{candidate}}
6 {
7   S(int, int, double); // expected-note {{candidate}}
8   S(double, int); // expected-note 2 {{candidate}}
9   S(float, int); // expected-note 2 {{candidate}}
10 };
11 struct T; // expected-note{{forward declaration of 'T'}}
12 struct U
13 {
14   // A special new, to verify that the global version isn't used.
15   void* operator new(size_t, S*); // expected-note {{candidate}}
16 };
17 struct V : U
18 {
19 };
20 
21 inline void operator delete(void *); // expected-warning {{replacement function 'operator delete' cannot be declared 'inline'}}
22 
23 __attribute__((used))
24 inline void *operator new(size_t) { // no warning, due to __attribute__((used))
25   return 0;
26 }
27 
28 // PR5823
29 void* operator new(const size_t); // expected-note 2 {{candidate}}
30 void* operator new(size_t, int*); // expected-note 3 {{candidate}}
31 void* operator new(size_t, float*); // expected-note 3 {{candidate}}
32 void* operator new(size_t, S); // expected-note 2 {{candidate}}
33 
34 struct foo { };
35 
36 void good_news()
37 {
38   int *pi = new int;
39   float *pf = new (pi) float();
40   pi = new int(1);
41   pi = new int('c');
42   const int *pci = new const int();
43   S *ps = new S(1, 2, 3.4);
44   ps = new (pf) (S)(1, 2, 3.4);
45   S *(*paps)[2] = new S*[*pi][2];
46   typedef int ia4[4];
47   ia4 *pai = new (int[3][4]);
48   pi = ::new int;
49   U *pu = new (ps) U;
50   V *pv = new (ps) V;
51 
52   pi = new (S(1.0f, 2)) int;
53 
54   (void)new int[true];
55 
56   // PR7147
57   typedef int a[2];
58   foo* f1 = new foo;
59   foo* f2 = new foo[2];
60   typedef foo x[2];
61   typedef foo y[2][2];
62   x* f3 = new y;
63 }
64 
65 struct abstract {
66   virtual ~abstract() = 0;
67 };
68 
69 void bad_news(int *ip)
70 {
71   int i = 1; // expected-note 2{{here}}
72   (void)new; // expected-error {{expected a type}}
73   (void)new 4; // expected-error {{expected a type}}
74   (void)new () int; // expected-error {{expected expression}}
75   (void)new int[1.1]; // expected-error {{array size expression must have integral or enumeration type, not 'double'}}
76   (void)new int[1][i]; // expected-error {{only the first dimension}} expected-note {{read of non-const variable 'i' is not allowed in a constant expression}}
77   (void)new (int[1][i]); // expected-error {{only the first dimension}} expected-note {{read of non-const variable 'i' is not allowed in a constant expression}}
78   (void)new (int[i]); // expected-warning {{when type is in parentheses}}
79   (void)new int(*(S*)0); // expected-error {{no viable conversion from 'S' to 'int'}}
80   (void)new int(1, 2); // expected-error {{excess elements in scalar initializer}}
81   (void)new S(1); // expected-error {{no matching constructor}}
82   (void)new S(1, 1); // expected-error {{call to constructor of 'S' is ambiguous}}
83   (void)new const int; // expected-error {{default initialization of an object of const type 'const int'}}
84   (void)new float*(ip); // expected-error {{cannot initialize a new value of type 'float *' with an lvalue of type 'int *'}}
85   // Undefined, but clang should reject it directly.
86   (void)new int[-1]; // expected-error {{array size is negative}}
87   (void)new int[2000000000]; // expected-error {{array is too large}}
88   (void)new int[*(S*)0]; // expected-error {{array size expression must have integral or enumeration type, not 'S'}}
89   (void)::S::new int; // expected-error {{expected unqualified-id}}
90   (void)new (0, 0) int; // expected-error {{no matching function for call to 'operator new'}}
91   (void)new (0L) int; // expected-error {{call to 'operator new' is ambiguous}}
92   // This must fail, because the member version shouldn't be found.
93   (void)::new ((S*)0) U; // expected-error {{no matching function for call to 'operator new'}}
94   // This must fail, because any member version hides all global versions.
95   (void)new U; // expected-error {{no matching function for call to 'operator new'}}
96   (void)new (int[]); // expected-error {{array size must be specified in new expressions}}
97   (void)new int&; // expected-error {{cannot allocate reference type 'int &' with new}}
98   // Some lacking cases due to lack of sema support.
99 }
100 
101 void good_deletes()
102 {
103   delete (int*)0;
104   delete [](int*)0;
105   delete (S*)0;
106   ::delete (int*)0;
107 }
108 
109 void bad_deletes()
110 {
111   delete 0; // expected-error {{cannot delete expression of type 'int'}}
112   delete [0] (int*)0; // expected-error {{expected expression}}
113   delete (void*)0; // expected-warning {{cannot delete expression with pointer-to-'void' type 'void *'}}
114   delete (T*)0; // expected-warning {{deleting pointer to incomplete type}}
115   ::S::delete (int*)0; // expected-error {{expected unqualified-id}}
116 }
117 
118 struct X0 { };
119 
120 struct X1 {
121   operator int*();
122   operator float();
123 };
124 
125 struct X2 {
126   operator int*(); // expected-note {{conversion}}
127   operator float*(); // expected-note {{conversion}}
128 };
129 
130 void test_delete_conv(X0 x0, X1 x1, X2 x2) {
131   delete x0; // expected-error{{cannot delete}}
132   delete x1;
133   delete x2; // expected-error{{ambiguous conversion of delete expression of type 'X2' to a pointer}}
134 }
135 
136 // PR4782
137 class X3 {
138 public:
139   static void operator delete(void * mem, size_t size);
140 };
141 
142 class X4 {
143 public:
144   static void release(X3 *x);
145   static void operator delete(void * mem, size_t size);
146 };
147 
148 
149 void X4::release(X3 *x) {
150   delete x;
151 }
152 
153 class X5 {
154 public:
155   void Destroy() const { delete this; }
156 };
157 
158 class Base {
159 public:
160   static void *operator new(signed char) throw(); // expected-error {{'operator new' takes type size_t}}
161   static int operator new[] (size_t) throw(); // expected-error {{operator new[]' must return type 'void *'}}
162 };
163 
164 class Tier {};
165 class Comp : public Tier {};
166 
167 class Thai : public Base {
168 public:
169   Thai(const Tier *adoptDictionary);
170 };
171 
172 void loadEngineFor() {
173   const Comp *dict;
174   new Thai(dict);
175 }
176 
177 template <class T> struct TBase {
178   void* operator new(T size, int); // expected-error {{'operator new' cannot take a dependent type as first parameter; use size_t}}
179 };
180 
181 TBase<int> t1;
182 
183 class X6 {
184 public:
185   static void operator delete(void*, int); // expected-note {{member found by ambiguous name lookup}}
186 };
187 
188 class X7 {
189 public:
190   static void operator delete(void*, int); // expected-note {{member found by ambiguous name lookup}}
191 };
192 
193 class X8 : public X6, public X7 {
194 };
195 
196 void f(X8 *x8) {
197   delete x8; // expected-error {{member 'operator delete' found in multiple base classes of different types}}
198 }
199 
200 class X9 {
201 public:
202   static void operator delete(void*, int); // expected-note {{'operator delete' declared here}}
203   static void operator delete(void*, float); // expected-note {{'operator delete' declared here}}
204 };
205 
206 void f(X9 *x9) {
207   delete x9; // expected-error {{no suitable member 'operator delete' in 'X9'}}
208 }
209 
210 struct X10 {
211   virtual ~X10();
212 };
213 
214 struct X11 : X10 { // expected-error {{no suitable member 'operator delete' in 'X11'}}
215   void operator delete(void*, int); // expected-note {{'operator delete' declared here}}
216 };
217 
218 void f() {
219   X11 x11; // expected-note {{implicit destructor for 'X11' first required here}}
220 }
221 
222 struct X12 {
223   void* operator new(size_t, void*);
224 };
225 
226 struct X13 : X12 {
227   using X12::operator new;
228 };
229 
230 static void* f(void* g)
231 {
232     return new (g) X13();
233 }
234 
235 class X14 {
236 public:
237   static void operator delete(void*, const size_t);
238 };
239 
240 void f(X14 *x14a, X14 *x14b) {
241   delete x14a;
242 }
243 
244 class X15 {
245 private:
246   X15(); // expected-note {{declared private here}}
247   ~X15(); // expected-note {{declared private here}}
248 };
249 
250 void f(X15* x) {
251   new X15(); // expected-error {{calling a private constructor}}
252   delete x; // expected-error {{calling a private destructor}}
253 }
254 
255 namespace PR5918 { // Look for template operator new overloads.
256   struct S { template<typename T> static void* operator new(size_t, T); };
257   void test() {
258     (void)new(0) S;
259   }
260 }
261 
262 namespace Test1 {
263 
264 void f() {
265   (void)new int[10](1, 2); // expected-error {{array 'new' cannot have initialization arguments}}
266 
267   typedef int T[10];
268   (void)new T(1, 2); // expected-error {{array 'new' cannot have initialization arguments}}
269 }
270 
271 template<typename T>
272 void g(unsigned i) {
273   (void)new T[1](i); // expected-error {{array 'new' cannot have initialization arguments}}
274 }
275 
276 template<typename T>
277 void h(unsigned i) {
278   (void)new T(i); // expected-error {{array 'new' cannot have initialization arguments}}
279 }
280 template void h<unsigned>(unsigned);
281 template void h<unsigned[10]>(unsigned); // expected-note {{in instantiation of function template specialization 'Test1::h<unsigned int [10]>' requested here}}
282 
283 }
284 
285 // Don't diagnose access for overload candidates that aren't selected.
286 namespace PR7436 {
287 struct S1 {
288   void* operator new(size_t);
289   void operator delete(void* p);
290 
291 private:
292   void* operator new(size_t, void*); // expected-note {{declared private here}}
293   void operator delete(void*, void*);
294 };
295 class S2 {
296   void* operator new(size_t); // expected-note {{declared private here}}
297   void operator delete(void* p); // expected-note {{declared private here}}
298 };
299 
300 void test(S1* s1, S2* s2) {
301   delete s1;
302   delete s2; // expected-error {{is a private member}}
303   (void)new S1();
304   (void)new (0L) S1(); // expected-error {{is a private member}}
305   (void)new S2(); // expected-error {{is a private member}}
306 }
307 }
308 
309 namespace rdar8018245 {
310   struct X0 {
311     static const int value = 17;
312   };
313 
314   const int X0::value;
315 
316   struct X1 {
317     static int value;
318   };
319 
320   int X1::value;
321 
322   template<typename T>
323   int *f() {
324     return new (int[T::value]); // expected-warning{{when type is in parentheses, array cannot have dynamic size}}
325   }
326 
327   template int *f<X0>();
328   template int *f<X1>(); // expected-note{{in instantiation of}}
329 
330 }
331 
332 // <rdar://problem/8248780>
333 namespace Instantiate {
334   template<typename T> struct X {
335     operator T*();
336   };
337 
338   void f(X<int> &xi) {
339     delete xi;
340   }
341 }
342 
343 namespace PR7810 {
344   struct X {
345     // cv is ignored in arguments
346     static void operator delete(void *const);
347   };
348   struct Y {
349     // cv is ignored in arguments
350     static void operator delete(void *volatile);
351   };
352 }
353 
354 // Don't crash on template delete operators
355 namespace TemplateDestructors {
356   struct S {
357     virtual ~S() {}
358 
359     void* operator new(const size_t size);
360     template<class T> void* operator new(const size_t, const int, T*);
361     void operator delete(void*, const size_t);
362     template<class T> void operator delete(void*, const size_t, const int, T*);
363   };
364 }
365 
366 namespace DeleteParam {
367   struct X {
368     void operator delete(X*); // expected-error{{first parameter of 'operator delete' must have type 'void *'}}
369   };
370 
371   struct Y {
372     void operator delete(void* const);
373   };
374 }
375 
376 // <rdar://problem/8427878>
377 // Test that the correct 'operator delete' is selected to pair with
378 // the unexpected placement 'operator new'.
379 namespace PairedDelete {
380   template <class T> struct A {
381     A();
382     void *operator new(size_t s, double d = 0);
383     void operator delete(void *p, double d);
384     void operator delete(void *p) {
385       T::dealloc(p);
386     }
387   };
388 
389   A<int> *test() {
390     return new A<int>();
391   }
392 }
393 
394 namespace PR7702 {
395   void test1() {
396     new DoesNotExist; // expected-error {{unknown type name 'DoesNotExist'}}
397   }
398 }
399 
400 namespace ArrayNewNeedsDtor {
401   struct A { A(); private: ~A(); }; // expected-note {{declared private here}}
402   struct B { B(); A a; }; // expected-error {{field of type 'ArrayNewNeedsDtor::A' has private destructor}}
403   B *test9() {
404     return new B[5]; // expected-note {{implicit destructor for 'ArrayNewNeedsDtor::B' first required here}}
405   }
406 }
407 
408 namespace DeleteIncompleteClass {
409   struct A; // expected-note {{forward declaration}}
410   extern A x;
411   void f() { delete x; } // expected-error {{deleting incomplete class type}}
412 }
413 
414 namespace DeleteIncompleteClassPointerError {
415   struct A; // expected-note {{forward declaration}}
416   void f(A *x) { 1+delete x; } // expected-warning {{deleting pointer to incomplete type}} \
417                                // expected-error {{invalid operands to binary expression}}
418 }
419 
420 namespace PR10504 {
421   struct A {
422     virtual void foo() = 0;
423   };
424   void f(A *x) { delete x; } // expected-warning {{delete called on 'PR10504::A' that is abstract but has non-virtual destructor}}
425 }
426 
427 struct PlacementArg {};
428 inline void *operator new[](size_t, const PlacementArg &) throw () {
429   return 0;
430 }
431 inline void operator delete[](void *, const PlacementArg &) throw () {
432 }
433 
434 namespace r150682 {
435 
436   template <typename X>
437   struct S {
438     struct Inner {};
439     S() { new Inner[1]; }
440   };
441 
442   struct T {
443   };
444 
445   template<typename X>
446   void tfn() {
447     new (*(PlacementArg*)0) T[1];
448   }
449 
450   void fn() {
451     tfn<int>();
452   }
453 
454 }
455 
456 namespace P12023 {
457   struct CopyCounter
458   {
459       CopyCounter();
460       CopyCounter(const CopyCounter&);
461   };
462 
463   int main()
464   {
465     CopyCounter* f = new CopyCounter[10](CopyCounter()); // expected-error {{cannot have initialization arguments}}
466       return 0;
467   }
468 }
469 
470 namespace PR12061 {
471   template <class C> struct scoped_array {
472     scoped_array(C* p = __null);
473   };
474   template <class Payload> struct Foo {
475     Foo() : a_(new scoped_array<int>[5]) { }
476     scoped_array< scoped_array<int> > a_;
477   };
478   class Bar {};
479   Foo<Bar> x;
480 
481   template <class C> struct scoped_array2 {
482     scoped_array2(C* p = __null, C* q = __null);
483   };
484   template <class Payload> struct Foo2 {
485     Foo2() : a_(new scoped_array2<int>[5]) { }
486     scoped_array2< scoped_array2<int> > a_;
487   };
488   class Bar2 {};
489   Foo2<Bar2> x2;
490 
491   class MessageLoop {
492   public:
493     explicit MessageLoop(int type = 0);
494   };
495   template <class CookieStoreTestTraits>
496   class CookieStoreTest {
497   protected:
498     CookieStoreTest() {
499       new MessageLoop;
500     }
501   };
502   struct CookieMonsterTestTraits {
503   };
504   class DeferredCookieTaskTest : public CookieStoreTest<CookieMonsterTestTraits>
505   {
506     DeferredCookieTaskTest() {}
507   };
508 }
509 
510 class DeletingPlaceholder {
511   int* f() {
512     delete f; // expected-error {{reference to non-static member function must be called; did you mean to call it with no arguments?}}
513     return 0;
514   }
515   int* g(int, int) {
516     delete g; // expected-error {{reference to non-static member function must be called}}
517     return 0;
518   }
519 };
520