1 // RUN: %clang_cc1 -fsyntax-only -verify %s -triple=i686-pc-linux-gnu -Wno-new-returns-null
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))
operator new(size_t)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
good_news()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
bad_news(int * ip)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
good_deletes()101 void good_deletes()
102 {
103 delete (int*)0;
104 delete [](int*)0;
105 delete (S*)0;
106 ::delete (int*)0;
107 }
108
bad_deletes()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
test_delete_conv(X0 x0,X1 x1,X2 x2)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
release(X3 * x)149 void X4::release(X3 *x) {
150 delete x;
151 }
152
153 class X5 {
154 public:
Destroy() const155 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
loadEngineFor()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
f(X8 * x8)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
f(X9 * x9)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
f()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
f(void * g)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
f(X14 * x14a,X14 * x14b)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
f(X15 * x)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); };
test()257 void test() {
258 (void)new(0) S;
259 }
260 }
261
262 namespace Test1 {
263
f()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>
g(unsigned i)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>
h(unsigned i)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
test(S1 * s1,S2 * s2)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>
f()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
f(X<int> & xi)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 {
~STemplateDestructors::S357 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);
operator deletePairedDelete::A384 void operator delete(void *p) {
385 T::dealloc(p);
386 }
387 };
388
test()389 A<int> *test() {
390 return new A<int>();
391 }
392 }
393
394 namespace PR7702 {
test1()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}}
test9()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;
f()411 void f() { delete x; } // expected-error {{deleting incomplete class type}}
412 }
413
414 namespace DeleteIncompleteClassPointerError {
415 struct A; // expected-note {{forward declaration}}
f(A * x)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 };
f(A * x)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 {};
operator new[](size_t,const PlacementArg &)428 inline void *operator new[](size_t, const PlacementArg &) throw () {
429 return 0;
430 }
operator delete[](void *,const PlacementArg &)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 {};
Sr150682::S439 S() { new Inner[1]; }
440 };
441
442 struct T {
443 };
444
445 template<typename X>
tfn()446 void tfn() {
447 new (*(PlacementArg*)0) T[1]; // expected-warning 2 {{binding dereferenced null pointer to reference has undefined behavior}}
448 }
449
fn()450 void fn() {
451 tfn<int>(); // expected-note {{in instantiation of function template specialization 'r150682::tfn<int>' requested here}}
452 }
453
454 }
455
456 namespace P12023 {
457 struct CopyCounter
458 {
459 CopyCounter();
460 CopyCounter(const CopyCounter&);
461 };
462
main()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 {
FooPR12061::Foo475 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 {
Foo2PR12061::Foo2485 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:
CookieStoreTest()498 CookieStoreTest() {
499 new MessageLoop;
500 }
501 };
502 struct CookieMonsterTestTraits {
503 };
504 class DeferredCookieTaskTest : public CookieStoreTest<CookieMonsterTestTraits>
505 {
DeferredCookieTaskTest()506 DeferredCookieTaskTest() {}
507 };
508 }
509
510 class DeletingPlaceholder {
f()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 }
g(int,int)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
521 namespace PR18544 {
522 inline void *operator new(size_t); // expected-error {{'operator new' cannot be declared inside a namespace}}
523 }
524
525 // PR19968
526 inline void* operator new(); // expected-error {{'operator new' must have at least one parameter}}
527
528 namespace {
529 template <class C>
530 struct A {
f__anon1e3a54200111::A531 void f() { this->::new; } // expected-error {{expected unqualified-id}}
g__anon1e3a54200111::A532 void g() { this->::delete; } // expected-error {{expected unqualified-id}}
533 };
534 }
535