new-delete.cpp revision 48c950137e4318abb1080f438208fda8c14ca8b9
1// RUN: %clang_cc1 -fsyntax-only -verify %s 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 27void good_news() 28{ 29 int *pi = new int; 30 float *pf = new (pi) float(); 31 pi = new int(1); 32 pi = new int('c'); 33 const int *pci = new const int(); 34 S *ps = new S(1, 2, 3.4); 35 ps = new (pf) (S)(1, 2, 3.4); 36 S *(*paps)[2] = new S*[*pi][2]; 37 typedef int ia4[4]; 38 ia4 *pai = new (int[3][4]); 39 pi = ::new int; 40 U *pu = new (ps) U; 41 V *pv = new (ps) V; 42 43 pi = new (S(1.0f, 2)) int; 44 45 (void)new int[true]; 46} 47 48struct abstract { 49 virtual ~abstract() = 0; 50}; 51 52void bad_news(int *ip) 53{ 54 int i = 1; 55 (void)new; // expected-error {{missing type specifier}} 56 (void)new 4; // expected-error {{missing type specifier}} 57 (void)new () int; // expected-error {{expected expression}} 58 (void)new int[1.1]; // expected-error {{array size expression must have integral or enumerated type, not 'double'}} 59 (void)new int[1][i]; // expected-error {{only the first dimension}} 60 (void)new (int[1][i]); // expected-error {{only the first dimension}} 61 (void)new (int[i]); // expected-error {{when type is in parentheses}} 62 (void)new int(*(S*)0); // expected-error {{no viable conversion from 'S' to 'int'}} 63 (void)new int(1, 2); // expected-error {{excess elements in scalar initializer}} 64 (void)new S(1); // expected-error {{no matching constructor}} 65 (void)new S(1, 1); // expected-error {{call to constructor of 'S' is ambiguous}} 66 (void)new const int; // expected-error {{default initialization of an object of const type 'int const'}} 67 (void)new float*(ip); // expected-error {{cannot initialize a new value of type 'float *' with an lvalue of type 'int *'}} 68 // Undefined, but clang should reject it directly. 69 (void)new int[-1]; // expected-error {{array size is negative}} 70 (void)new int[*(S*)0]; // expected-error {{array size expression must have integral or enumerated type, not 'S'}} 71 (void)::S::new int; // expected-error {{expected unqualified-id}} 72 (void)new (0, 0) int; // expected-error {{no matching function for call to 'operator new'}} 73 (void)new (0L) int; // expected-error {{call to 'operator new' is ambiguous}} 74 // This must fail, because the member version shouldn't be found. 75 (void)::new ((S*)0) U; // expected-error {{no matching function for call to 'operator new'}} 76 // This must fail, because any member version hides all global versions. 77 (void)new U; // expected-error {{no matching function for call to 'operator new'}} 78 (void)new (int[]); // expected-error {{array size must be specified in new expressions}} 79 (void)new int&; // expected-error {{cannot allocate reference type 'int &' with new}} 80 // Some lacking cases due to lack of sema support. 81} 82 83void good_deletes() 84{ 85 delete (int*)0; 86 delete [](int*)0; 87 delete (S*)0; 88 ::delete (int*)0; 89} 90 91void bad_deletes() 92{ 93 delete 0; // expected-error {{cannot delete expression of type 'int'}} 94 delete [0] (int*)0; // expected-error {{expected ']'}} \ 95 // expected-note {{to match this '['}} 96 delete (void*)0; // expected-error {{cannot delete expression}} 97 delete (T*)0; // expected-warning {{deleting pointer to incomplete type}} 98 ::S::delete (int*)0; // expected-error {{expected unqualified-id}} 99} 100 101struct X0 { }; 102 103struct X1 { 104 operator int*(); 105 operator float(); 106}; 107 108struct X2 { 109 operator int*(); // expected-note {{candidate function}} 110 operator float*(); // expected-note {{candidate function}} 111}; 112 113void test_delete_conv(X0 x0, X1 x1, X2 x2) { 114 delete x0; // expected-error{{cannot delete}} 115 delete x1; 116 delete x2; // expected-error{{ambiguous conversion of delete expression of type 'X2' to a pointer}} 117} 118 119// PR4782 120class X3 { 121public: 122 static void operator delete(void * mem, size_t size); 123}; 124 125class X4 { 126public: 127 static void release(X3 *x); 128 static void operator delete(void * mem, size_t size); 129}; 130 131 132void X4::release(X3 *x) { 133 delete x; 134} 135 136class X5 { 137public: 138 void Destroy() const { delete this; } 139}; 140 141class Base { 142public: 143 static void *operator new(signed char) throw(); // expected-error {{'operator new' takes type size_t}} 144 static int operator new[] (size_t) throw(); // expected-error {{operator new[]' must return type 'void *'}} 145}; 146 147class Tier {}; 148class Comp : public Tier {}; 149 150class Thai : public Base { 151public: 152 Thai(const Tier *adoptDictionary); 153}; 154 155void loadEngineFor() { 156 const Comp *dict; 157 new Thai(dict); 158} 159 160template <class T> struct TBase { 161 void* operator new(T size, int); // expected-error {{'operator new' cannot take a dependent type as first parameter; use size_t}} 162}; 163 164TBase<int> t1; 165 166class X6 { 167public: 168 static void operator delete(void*, int); // expected-note {{member found by ambiguous name lookup}} 169}; 170 171class X7 { 172public: 173 static void operator delete(void*, int); // expected-note {{member found by ambiguous name lookup}} 174}; 175 176class X8 : public X6, public X7 { 177}; 178 179void f(X8 *x8) { 180 delete x8; // expected-error {{member 'operator delete' found in multiple base classes of different types}} 181} 182 183class X9 { 184public: 185 static void operator delete(void*, int); // expected-note {{'operator delete' declared here}} 186 static void operator delete(void*, float); // expected-note {{'operator delete' declared here}} 187}; 188 189void f(X9 *x9) { 190 delete x9; // expected-error {{no suitable member 'operator delete' in 'X9'}} 191} 192 193struct X10 { 194 virtual ~X10(); 195}; 196 197struct X11 : X10 { // expected-error {{no suitable member 'operator delete' in 'X11'}} 198 void operator delete(void*, int); // expected-note {{'operator delete' declared here}} 199}; 200 201void f() { 202 X11 x11; // expected-note {{implicit default destructor for 'X11' first required here}} 203} 204 205struct X12 { 206 void* operator new(size_t, void*); 207}; 208 209struct X13 : X12 { 210 using X12::operator new; 211}; 212 213static void* f(void* g) 214{ 215 return new (g) X13(); 216} 217 218class X14 { 219public: 220 static void operator delete(void*, const size_t); 221}; 222 223void f(X14 *x14a, X14 *x14b) { 224 delete x14a; 225} 226 227namespace PR5918 { // Look for template operator new overloads. 228 struct S { template<typename T> static void* operator new(size_t, T); }; 229 void test() { 230 (void)new(0) S; 231 } 232} 233 234namespace Test1 { 235 236void f() { 237 (void)new int[10](1, 2); // expected-error {{array 'new' cannot have initialization arguments}} 238} 239 240template<typename T> 241void g(unsigned i) { 242 (void)new T[1](i); // expected-error {{array 'new' cannot have initialization arguments}} 243} 244 245template<typename T> 246void h(unsigned i) { 247 (void)new T(i); // expected-error {{array 'new' cannot have initialization arguments}} 248} 249template void h<unsigned>(unsigned); 250template void h<unsigned[10]>(unsigned); // expected-note {{in instantiation of function template specialization 'Test1::h<unsigned int [10]>' requested here}} 251 252} 253