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