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