Daniel Dunbar | d7d5f02 | 2009-03-24 02:24:46 +0000 | [diff] [blame] | 1 | // RUN: clang-cc -fsyntax-only -verify %s |
Douglas Gregor | c83ed04 | 2008-11-25 04:08:05 +0000 | [diff] [blame] | 2 | |
Sebastian Redl | b5a57a6 | 2008-12-03 20:26:15 +0000 | [diff] [blame] | 3 | #include <stddef.h> |
| 4 | |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 5 | struct S // expected-note {{candidate}} |
| 6 | { |
| 7 | S(int, int, double); // expected-note {{candidate}} |
Sebastian Redl | 3cb0692 | 2009-02-07 19:52:04 +0000 | [diff] [blame] | 8 | S(double, int); // expected-note 2 {{candidate}} |
| 9 | S(float, int); // expected-note 2 {{candidate}} |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 10 | }; |
Douglas Gregor | 4ec339f | 2009-01-19 19:26:10 +0000 | [diff] [blame] | 11 | struct T; // expected-note{{forward declaration of 'struct T'}} |
Sebastian Redl | 636a7c4 | 2008-12-04 17:24:46 +0000 | [diff] [blame] | 12 | struct U |
| 13 | { |
| 14 | // A special new, to verify that the global version isn't used. |
Sebastian Redl | 9afe130 | 2009-05-14 18:11:41 +0000 | [diff] [blame] | 15 | void* operator new(size_t, S*); // expected-note {{candidate}} |
Sebastian Redl | 636a7c4 | 2008-12-04 17:24:46 +0000 | [diff] [blame] | 16 | }; |
Sebastian Redl | 7f66239 | 2008-12-04 22:20:51 +0000 | [diff] [blame] | 17 | struct V : U |
| 18 | { |
| 19 | }; |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 20 | |
Sebastian Redl | 3cb0692 | 2009-02-07 19:52:04 +0000 | [diff] [blame] | 21 | void* operator new(size_t); // expected-note 2 {{candidate}} |
| 22 | void* operator new(size_t, int*); // expected-note 3 {{candidate}} |
| 23 | void* operator new(size_t, float*); // expected-note 3 {{candidate}} |
Anders Carlsson | fc27d26 | 2009-05-31 19:49:47 +0000 | [diff] [blame] | 24 | void* operator new(size_t, S); // expected-note 2 {{candidate}} |
Sebastian Redl | b5a57a6 | 2008-12-03 20:26:15 +0000 | [diff] [blame] | 25 | |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 26 | void good_news() |
| 27 | { |
| 28 | int *pi = new int; |
| 29 | float *pf = new (pi) float(); |
| 30 | pi = new int(1); |
| 31 | pi = new int('c'); |
| 32 | const int *pci = new const int(); |
| 33 | S *ps = new S(1, 2, 3.4); |
Sebastian Redl | cee63fb | 2008-12-02 14:43:59 +0000 | [diff] [blame] | 34 | ps = new (pf) (S)(1, 2, 3.4); |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 35 | S *(*paps)[2] = new S*[*pi][2]; |
| 36 | ps = new (S[3])(1, 2, 3.4); |
| 37 | typedef int ia4[4]; |
| 38 | ia4 *pai = new (int[3][4]); |
Sebastian Redl | fb4ccd7 | 2008-12-02 16:35:44 +0000 | [diff] [blame] | 39 | pi = ::new int; |
Sebastian Redl | 636a7c4 | 2008-12-04 17:24:46 +0000 | [diff] [blame] | 40 | U *pu = new (ps) U; |
Douglas Gregor | 5d64e5b | 2009-09-30 00:03:47 +0000 | [diff] [blame] | 41 | V *pv = new (ps) V; |
Anders Carlsson | fc27d26 | 2009-05-31 19:49:47 +0000 | [diff] [blame] | 42 | |
| 43 | pi = new (S(1.0f, 2)) int; |
Anders Carlsson | ac18b2e | 2009-09-23 00:37:25 +0000 | [diff] [blame] | 44 | |
| 45 | (void)new int[true]; |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 46 | } |
| 47 | |
Douglas Gregor | e7450f5 | 2009-03-24 19:52:54 +0000 | [diff] [blame] | 48 | struct abstract { |
| 49 | virtual ~abstract() = 0; |
| 50 | }; |
| 51 | |
Douglas Gregor | c83ed04 | 2008-11-25 04:08:05 +0000 | [diff] [blame] | 52 | void bad_news(int *ip) |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 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}} |
Sebastian Redl | cee63fb | 2008-12-02 14:43:59 +0000 | [diff] [blame] | 58 | (void)new int[1.1]; // expected-error {{array size expression must have integral or enumerated type, not 'double'}} |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 59 | (void)new int[1][i]; // expected-error {{only the first dimension}} |
| 60 | (void)new (int[1][i]); // expected-error {{only the first dimension}} |
Sebastian Redl | 8ce35b0 | 2009-10-25 21:45:37 +0000 | [diff] [blame] | 61 | (void)new (int[i]); // expected-error {{when type is in parentheses}} |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 62 | (void)new int(*(S*)0); // expected-error {{incompatible type initializing}} |
| 63 | (void)new int(1, 2); // expected-error {{initializer of a builtin type can only take one argument}} |
| 64 | (void)new S(1); // expected-error {{no matching constructor}} |
Douglas Gregor | c83ed04 | 2008-11-25 04:08:05 +0000 | [diff] [blame] | 65 | (void)new S(1, 1); // expected-error {{call to constructor of 'S' is ambiguous}} |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 66 | (void)new const int; // expected-error {{must provide an initializer}} |
Douglas Gregor | c83ed04 | 2008-11-25 04:08:05 +0000 | [diff] [blame] | 67 | (void)new float*(ip); // expected-error {{incompatible type initializing 'int *', expected 'float *'}} |
Sebastian Redl | cee63fb | 2008-12-02 14:43:59 +0000 | [diff] [blame] | 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 'struct S'}} |
Sebastian Redl | fb4ccd7 | 2008-12-02 16:35:44 +0000 | [diff] [blame] | 71 | (void)::S::new int; // expected-error {{expected unqualified-id}} |
Sebastian Redl | b5a57a6 | 2008-12-03 20:26:15 +0000 | [diff] [blame] | 72 | (void)new (0, 0) int; // expected-error {{no matching function for call to 'operator new'}} |
Sebastian Redl | 7f66239 | 2008-12-04 22:20:51 +0000 | [diff] [blame] | 73 | (void)new (0L) int; // expected-error {{call to 'operator new' is ambiguous}} |
Sebastian Redl | 636a7c4 | 2008-12-04 17:24:46 +0000 | [diff] [blame] | 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'}} |
Sebastian Redl | 9afe130 | 2009-05-14 18:11:41 +0000 | [diff] [blame] | 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'}} |
Sebastian Redl | 00e68e2 | 2009-02-09 18:24:27 +0000 | [diff] [blame] | 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}} |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 80 | // Some lacking cases due to lack of sema support. |
| 81 | } |
| 82 | |
| 83 | void good_deletes() |
| 84 | { |
| 85 | delete (int*)0; |
| 86 | delete [](int*)0; |
| 87 | delete (S*)0; |
Sebastian Redl | fb4ccd7 | 2008-12-02 16:35:44 +0000 | [diff] [blame] | 88 | ::delete (int*)0; |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 89 | } |
| 90 | |
| 91 | void bad_deletes() |
| 92 | { |
| 93 | delete 0; // expected-error {{cannot delete expression of type 'int'}} |
| 94 | delete [0] (int*)0; // expected-error {{expected ']'}} \ |
Chris Lattner | 28eb7e9 | 2008-11-23 23:17:07 +0000 | [diff] [blame] | 95 | // expected-note {{to match this '['}} |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 96 | delete (void*)0; // expected-error {{cannot delete expression}} |
| 97 | delete (T*)0; // expected-warning {{deleting pointer to incomplete type}} |
Sebastian Redl | fb4ccd7 | 2008-12-02 16:35:44 +0000 | [diff] [blame] | 98 | ::S::delete (int*)0; // expected-error {{expected unqualified-id}} |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 99 | } |
Douglas Gregor | 9cd9f3f | 2009-09-09 23:39:55 +0000 | [diff] [blame] | 100 | |
| 101 | struct X0 { }; |
| 102 | |
| 103 | struct X1 { |
| 104 | operator int*(); |
| 105 | operator float(); |
| 106 | }; |
| 107 | |
| 108 | struct X2 { |
Fariborz Jahanian | f652793 | 2009-09-15 17:21:47 +0000 | [diff] [blame] | 109 | operator int*(); // expected-note {{candidate function}} |
| 110 | operator float*(); // expected-note {{candidate function}} |
Douglas Gregor | 9cd9f3f | 2009-09-09 23:39:55 +0000 | [diff] [blame] | 111 | }; |
| 112 | |
| 113 | void test_delete_conv(X0 x0, X1 x1, X2 x2) { |
| 114 | delete x0; // expected-error{{cannot delete}} |
| 115 | delete x1; |
Fariborz Jahanian | f652793 | 2009-09-15 17:21:47 +0000 | [diff] [blame] | 116 | delete x2; // expected-error{{ambiguous conversion of delete expression of type 'struct X2' to a pointer}} |
| 117 | } |
Douglas Gregor | 9091656 | 2009-09-29 18:16:17 +0000 | [diff] [blame] | 118 | |
| 119 | // PR4782 |
| 120 | class X3 { |
| 121 | public: |
| 122 | static void operator delete(void * mem, unsigned long size); |
| 123 | }; |
| 124 | |
| 125 | class X4 { |
| 126 | public: |
| 127 | static void release(X3 *x); |
| 128 | static void operator delete(void * mem, unsigned long size); |
| 129 | }; |
| 130 | |
| 131 | |
| 132 | void X4::release(X3 *x) { |
| 133 | delete x; |
| 134 | } |
Douglas Gregor | 1070c9f | 2009-09-29 21:38:53 +0000 | [diff] [blame] | 135 | |
Douglas Gregor | 5d64e5b | 2009-09-30 00:03:47 +0000 | [diff] [blame] | 136 | class X5 { |
Douglas Gregor | 1070c9f | 2009-09-29 21:38:53 +0000 | [diff] [blame] | 137 | public: |
| 138 | void Destroy() const { delete this; } |
| 139 | }; |
Fariborz Jahanian | b03bfa5 | 2009-11-10 23:47:18 +0000 | [diff] [blame] | 140 | |
| 141 | class Base { |
| 142 | public: |
Fariborz Jahanian | 1f2fcee | 2009-11-11 22:45:41 +0000 | [diff] [blame^] | 143 | static int operator new(signed char) throw(); // expected-error {{'operator new' takes type size_t}} \ |
Fariborz Jahanian | b03bfa5 | 2009-11-10 23:47:18 +0000 | [diff] [blame] | 144 | // expected-error {{operator new' must return type 'void *'}} |
Fariborz Jahanian | 1f2fcee | 2009-11-11 22:45:41 +0000 | [diff] [blame^] | 145 | static int operator new[] (signed char) throw(); // expected-error {{'operator new[]' takes type size_t}} \ |
Fariborz Jahanian | b03bfa5 | 2009-11-10 23:47:18 +0000 | [diff] [blame] | 146 | // expected-error {{operator new[]' must return type 'void *'}} |
| 147 | }; |
| 148 | |
| 149 | class Tier {}; |
| 150 | class Comp : public Tier {}; |
| 151 | |
| 152 | class Thai : public Base { |
| 153 | public: |
| 154 | Thai(const Tier *adoptDictionary); |
| 155 | }; |
| 156 | |
| 157 | void loadEngineFor() { |
| 158 | const Comp *dict; |
| 159 | new Thai(dict); |
| 160 | } |
| 161 | |
| 162 | template <class T> struct TBase { |
| 163 | void* operator new(T size, int); // expected-error {{'operator new' takes type size_t}} |
| 164 | }; |
| 165 | |
| 166 | TBase<int> t1; // expected-note {{in instantiation of template class 'struct TBase<int>' requested here}} |
| 167 | |