summaryrefslogtreecommitdiff
path: root/clang/test/SemaCXX/new-delete.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'clang/test/SemaCXX/new-delete.cpp')
-rw-r--r--clang/test/SemaCXX/new-delete.cpp501
1 files changed, 501 insertions, 0 deletions
diff --git a/clang/test/SemaCXX/new-delete.cpp b/clang/test/SemaCXX/new-delete.cpp
new file mode 100644
index 0000000..e77e3d6
--- /dev/null
+++ b/clang/test/SemaCXX/new-delete.cpp
@@ -0,0 +1,501 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s -triple=i686-pc-linux-gnu
+
+#include <stddef.h>
+
+struct S // expected-note {{candidate}}
+{
+ S(int, int, double); // expected-note {{candidate}}
+ S(double, int); // expected-note 2 {{candidate}}
+ S(float, int); // expected-note 2 {{candidate}}
+};
+struct T; // expected-note{{forward declaration of 'T'}}
+struct U
+{
+ // A special new, to verify that the global version isn't used.
+ void* operator new(size_t, S*); // expected-note {{candidate}}
+};
+struct V : U
+{
+};
+
+// PR5823
+void* operator new(const size_t); // expected-note 2 {{candidate}}
+void* operator new(size_t, int*); // expected-note 3 {{candidate}}
+void* operator new(size_t, float*); // expected-note 3 {{candidate}}
+void* operator new(size_t, S); // expected-note 2 {{candidate}}
+
+struct foo { };
+
+void good_news()
+{
+ int *pi = new int;
+ float *pf = new (pi) float();
+ pi = new int(1);
+ pi = new int('c');
+ const int *pci = new const int();
+ S *ps = new S(1, 2, 3.4);
+ ps = new (pf) (S)(1, 2, 3.4);
+ S *(*paps)[2] = new S*[*pi][2];
+ typedef int ia4[4];
+ ia4 *pai = new (int[3][4]);
+ pi = ::new int;
+ U *pu = new (ps) U;
+ V *pv = new (ps) V;
+
+ pi = new (S(1.0f, 2)) int;
+
+ (void)new int[true];
+
+ // PR7147
+ typedef int a[2];
+ foo* f1 = new foo;
+ foo* f2 = new foo[2];
+ typedef foo x[2];
+ typedef foo y[2][2];
+ x* f3 = new y;
+}
+
+struct abstract {
+ virtual ~abstract() = 0;
+};
+
+void bad_news(int *ip)
+{
+ int i = 1; // expected-note 2{{here}}
+ (void)new; // expected-error {{expected a type}}
+ (void)new 4; // expected-error {{expected a type}}
+ (void)new () int; // expected-error {{expected expression}}
+ (void)new int[1.1]; // expected-error {{array size expression must have integral or enumeration type, not 'double'}}
+ (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}}
+ (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}}
+ (void)new (int[i]); // expected-warning {{when type is in parentheses}}
+ (void)new int(*(S*)0); // expected-error {{no viable conversion from 'S' to 'int'}}
+ (void)new int(1, 2); // expected-error {{excess elements in scalar initializer}}
+ (void)new S(1); // expected-error {{no matching constructor}}
+ (void)new S(1, 1); // expected-error {{call to constructor of 'S' is ambiguous}}
+ (void)new const int; // expected-error {{default initialization of an object of const type 'const int'}}
+ (void)new float*(ip); // expected-error {{cannot initialize a new value of type 'float *' with an lvalue of type 'int *'}}
+ // Undefined, but clang should reject it directly.
+ (void)new int[-1]; // expected-error {{array size is negative}}
+ (void)new int[2000000000]; // expected-error {{array is too large}}
+ (void)new int[*(S*)0]; // expected-error {{array size expression must have integral or enumeration type, not 'S'}}
+ (void)::S::new int; // expected-error {{expected unqualified-id}}
+ (void)new (0, 0) int; // expected-error {{no matching function for call to 'operator new'}}
+ (void)new (0L) int; // expected-error {{call to 'operator new' is ambiguous}}
+ // This must fail, because the member version shouldn't be found.
+ (void)::new ((S*)0) U; // expected-error {{no matching function for call to 'operator new'}}
+ // This must fail, because any member version hides all global versions.
+ (void)new U; // expected-error {{no matching function for call to 'operator new'}}
+ (void)new (int[]); // expected-error {{array size must be specified in new expressions}}
+ (void)new int&; // expected-error {{cannot allocate reference type 'int &' with new}}
+ // Some lacking cases due to lack of sema support.
+}
+
+void good_deletes()
+{
+ delete (int*)0;
+ delete [](int*)0;
+ delete (S*)0;
+ ::delete (int*)0;
+}
+
+void bad_deletes()
+{
+ delete 0; // expected-error {{cannot delete expression of type 'int'}}
+ delete [0] (int*)0; // expected-error {{expected expression}}
+ delete (void*)0; // expected-warning {{cannot delete expression with pointer-to-'void' type 'void *'}}
+ delete (T*)0; // expected-warning {{deleting pointer to incomplete type}}
+ ::S::delete (int*)0; // expected-error {{expected unqualified-id}}
+}
+
+struct X0 { };
+
+struct X1 {
+ operator int*();
+ operator float();
+};
+
+struct X2 {
+ operator int*(); // expected-note {{candidate function}}
+ operator float*(); // expected-note {{candidate function}}
+};
+
+void test_delete_conv(X0 x0, X1 x1, X2 x2) {
+ delete x0; // expected-error{{cannot delete}}
+ delete x1;
+ delete x2; // expected-error{{ambiguous conversion of delete expression of type 'X2' to a pointer}}
+}
+
+// PR4782
+class X3 {
+public:
+ static void operator delete(void * mem, size_t size);
+};
+
+class X4 {
+public:
+ static void release(X3 *x);
+ static void operator delete(void * mem, size_t size);
+};
+
+
+void X4::release(X3 *x) {
+ delete x;
+}
+
+class X5 {
+public:
+ void Destroy() const { delete this; }
+};
+
+class Base {
+public:
+ static void *operator new(signed char) throw(); // expected-error {{'operator new' takes type size_t}}
+ static int operator new[] (size_t) throw(); // expected-error {{operator new[]' must return type 'void *'}}
+};
+
+class Tier {};
+class Comp : public Tier {};
+
+class Thai : public Base {
+public:
+ Thai(const Tier *adoptDictionary);
+};
+
+void loadEngineFor() {
+ const Comp *dict;
+ new Thai(dict);
+}
+
+template <class T> struct TBase {
+ void* operator new(T size, int); // expected-error {{'operator new' cannot take a dependent type as first parameter; use size_t}}
+};
+
+TBase<int> t1;
+
+class X6 {
+public:
+ static void operator delete(void*, int); // expected-note {{member found by ambiguous name lookup}}
+};
+
+class X7 {
+public:
+ static void operator delete(void*, int); // expected-note {{member found by ambiguous name lookup}}
+};
+
+class X8 : public X6, public X7 {
+};
+
+void f(X8 *x8) {
+ delete x8; // expected-error {{member 'operator delete' found in multiple base classes of different types}}
+}
+
+class X9 {
+public:
+ static void operator delete(void*, int); // expected-note {{'operator delete' declared here}}
+ static void operator delete(void*, float); // expected-note {{'operator delete' declared here}}
+};
+
+void f(X9 *x9) {
+ delete x9; // expected-error {{no suitable member 'operator delete' in 'X9'}}
+}
+
+struct X10 {
+ virtual ~X10();
+};
+
+struct X11 : X10 { // expected-error {{no suitable member 'operator delete' in 'X11'}}
+ void operator delete(void*, int); // expected-note {{'operator delete' declared here}}
+};
+
+void f() {
+ X11 x11; // expected-note {{implicit default destructor for 'X11' first required here}}
+}
+
+struct X12 {
+ void* operator new(size_t, void*);
+};
+
+struct X13 : X12 {
+ using X12::operator new;
+};
+
+static void* f(void* g)
+{
+ return new (g) X13();
+}
+
+class X14 {
+public:
+ static void operator delete(void*, const size_t);
+};
+
+void f(X14 *x14a, X14 *x14b) {
+ delete x14a;
+}
+
+class X15 {
+private:
+ X15(); // expected-note {{declared private here}}
+ ~X15(); // expected-note {{declared private here}}
+};
+
+void f(X15* x) {
+ new X15(); // expected-error {{calling a private constructor}}
+ delete x; // expected-error {{calling a private destructor}}
+}
+
+namespace PR5918 { // Look for template operator new overloads.
+ struct S { template<typename T> static void* operator new(size_t, T); };
+ void test() {
+ (void)new(0) S;
+ }
+}
+
+namespace Test1 {
+
+void f() {
+ (void)new int[10](1, 2); // expected-error {{array 'new' cannot have initialization arguments}}
+
+ typedef int T[10];
+ (void)new T(1, 2); // expected-error {{array 'new' cannot have initialization arguments}}
+}
+
+template<typename T>
+void g(unsigned i) {
+ (void)new T[1](i); // expected-error {{array 'new' cannot have initialization arguments}}
+}
+
+template<typename T>
+void h(unsigned i) {
+ (void)new T(i); // expected-error {{array 'new' cannot have initialization arguments}}
+}
+template void h<unsigned>(unsigned);
+template void h<unsigned[10]>(unsigned); // expected-note {{in instantiation of function template specialization 'Test1::h<unsigned int [10]>' requested here}}
+
+}
+
+// Don't diagnose access for overload candidates that aren't selected.
+namespace PR7436 {
+struct S1 {
+ void* operator new(size_t);
+ void operator delete(void* p);
+
+private:
+ void* operator new(size_t, void*); // expected-note {{declared private here}}
+ void operator delete(void*, void*);
+};
+class S2 {
+ void* operator new(size_t); // expected-note {{declared private here}}
+ void operator delete(void* p); // expected-note {{declared private here}}
+};
+
+void test(S1* s1, S2* s2) {
+ delete s1;
+ delete s2; // expected-error {{is a private member}}
+ (void)new S1();
+ (void)new (0L) S1(); // expected-error {{is a private member}}
+ (void)new S2(); // expected-error {{is a private member}}
+}
+}
+
+namespace rdar8018245 {
+ struct X0 {
+ static const int value = 17;
+ };
+
+ const int X0::value;
+
+ struct X1 {
+ static int value;
+ };
+
+ int X1::value;
+
+ template<typename T>
+ int *f() {
+ return new (int[T::value]); // expected-warning{{when type is in parentheses, array cannot have dynamic size}}
+ }
+
+ template int *f<X0>();
+ template int *f<X1>(); // expected-note{{in instantiation of}}
+
+}
+
+// <rdar://problem/8248780>
+namespace Instantiate {
+ template<typename T> struct X {
+ operator T*();
+ };
+
+ void f(X<int> &xi) {
+ delete xi;
+ }
+}
+
+namespace PR7810 {
+ struct X {
+ // cv is ignored in arguments
+ static void operator delete(void *const);
+ };
+ struct Y {
+ // cv is ignored in arguments
+ static void operator delete(void *volatile);
+ };
+}
+
+// Don't crash on template delete operators
+namespace TemplateDestructors {
+ struct S {
+ virtual ~S() {}
+
+ void* operator new(const size_t size);
+ template<class T> void* operator new(const size_t, const int, T*);
+ void operator delete(void*, const size_t);
+ template<class T> void operator delete(void*, const size_t, const int, T*);
+ };
+}
+
+namespace DeleteParam {
+ struct X {
+ void operator delete(X*); // expected-error{{first parameter of 'operator delete' must have type 'void *'}}
+ };
+
+ struct Y {
+ void operator delete(void* const);
+ };
+}
+
+// <rdar://problem/8427878>
+// Test that the correct 'operator delete' is selected to pair with
+// the unexpected placement 'operator new'.
+namespace PairedDelete {
+ template <class T> struct A {
+ A();
+ void *operator new(size_t s, double d = 0);
+ void operator delete(void *p, double d);
+ void operator delete(void *p) {
+ T::dealloc(p);
+ }
+ };
+
+ A<int> *test() {
+ return new A<int>();
+ }
+}
+
+namespace PR7702 {
+ void test1() {
+ new DoesNotExist; // expected-error {{unknown type name 'DoesNotExist'}}
+ }
+}
+
+namespace ArrayNewNeedsDtor {
+ struct A { A(); private: ~A(); }; // expected-note {{declared private here}}
+ struct B { B(); A a; }; // expected-error {{field of type 'ArrayNewNeedsDtor::A' has private destructor}}
+ B *test9() {
+ return new B[5]; // expected-note {{implicit default destructor for 'ArrayNewNeedsDtor::B' first required here}}
+ }
+}
+
+namespace DeleteIncompleteClass {
+ struct A; // expected-note {{forward declaration}}
+ extern A x;
+ void f() { delete x; } // expected-error {{deleting incomplete class type}}
+}
+
+namespace DeleteIncompleteClassPointerError {
+ struct A; // expected-note {{forward declaration}}
+ void f(A *x) { 1+delete x; } // expected-warning {{deleting pointer to incomplete type}} \
+ // expected-error {{invalid operands to binary expression}}
+}
+
+namespace PR10504 {
+ struct A {
+ virtual void foo() = 0;
+ };
+ void f(A *x) { delete x; } // expected-warning {{delete called on 'PR10504::A' that is abstract but has non-virtual destructor}}
+}
+
+struct PlacementArg {};
+inline void *operator new[](size_t, const PlacementArg &) throw () {
+ return 0;
+}
+inline void operator delete[](void *, const PlacementArg &) throw () {
+}
+
+namespace r150682 {
+
+ template <typename X>
+ struct S {
+ struct Inner {};
+ S() { new Inner[1]; }
+ };
+
+ struct T {
+ };
+
+ template<typename X>
+ void tfn() {
+ new (*(PlacementArg*)0) T[1];
+ }
+
+ void fn() {
+ tfn<int>();
+ }
+
+}
+
+namespace P12023 {
+ struct CopyCounter
+ {
+ CopyCounter();
+ CopyCounter(const CopyCounter&);
+ };
+
+ int main()
+ {
+ CopyCounter* f = new CopyCounter[10](CopyCounter()); // expected-error {{cannot have initialization arguments}}
+ return 0;
+ }
+}
+
+namespace PR12061 {
+ template <class C> struct scoped_array {
+ scoped_array(C* p = __null);
+ };
+ template <class Payload> struct Foo {
+ Foo() : a_(new scoped_array<int>[5]) { }
+ scoped_array< scoped_array<int> > a_;
+ };
+ class Bar {};
+ Foo<Bar> x;
+
+ template <class C> struct scoped_array2 {
+ scoped_array2(C* p = __null, C* q = __null);
+ };
+ template <class Payload> struct Foo2 {
+ Foo2() : a_(new scoped_array2<int>[5]) { }
+ scoped_array2< scoped_array2<int> > a_;
+ };
+ class Bar2 {};
+ Foo2<Bar2> x2;
+
+ class MessageLoop {
+ public:
+ explicit MessageLoop(int type = 0);
+ };
+ template <class CookieStoreTestTraits>
+ class CookieStoreTest {
+ protected:
+ CookieStoreTest() {
+ new MessageLoop;
+ }
+ };
+ struct CookieMonsterTestTraits {
+ };
+ class DeferredCookieTaskTest : public CookieStoreTest<CookieMonsterTestTraits>
+ {
+ DeferredCookieTaskTest() {}
+ };
+}