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