1 // RUN: %clang_cc1 -emit-llvm-only -verify -std=c++11 %s
2 struct A {};
3
4 enum Foo { F };
5 typedef Foo Bar; // expected-note{{type 'Bar' (aka 'Foo') found by destructor name lookup}}
6
7 typedef int Integer;
8 typedef double Double;
9
10 void g();
11
12 namespace N {
13 typedef Foo Wibble;
14 typedef int OtherInteger;
15 }
16
17 template <typename T>
cv_test(const volatile T * cvt)18 void cv_test(const volatile T* cvt) {
19 cvt->T::~T(); // no-warning
20 }
21
f(A * a,Foo * f,int * i,double * d,int ii)22 void f(A* a, Foo *f, int *i, double *d, int ii) {
23 a->~A();
24 a->A::~A();
25
26 a->~foo(); // expected-error{{undeclared identifier 'foo' in destructor name}}
27
28 a->~Bar(); // expected-error{{destructor type 'Bar' (aka 'Foo') in object destruction expression does not match the type 'A' of the object being destroyed}}
29
30 f->~Bar();
31 f->~Foo();
32 i->~Bar(); // expected-error{{does not match}}
33
34 g().~Bar(); // expected-error{{non-scalar}}
35
36 f->::~Bar(); // expected-error {{not a structure or union}}
37 f->::Bar::~Bar();
38 f->N::~Wibble(); // expected-error{{'N' does not refer to a type}} expected-error{{'Wibble' does not refer to a type}}
39
40 f->Bar::~Bar(17, 42); // expected-error{{cannot have any arguments}}
41
42 i->~Integer();
43 i->Integer::~Integer();
44 i->N::~OtherInteger(); // expected-error{{'N' does not refer to a type name in pseudo-destructor expression; expected the name of type 'int'}}
45 // expected-error@-1{{'OtherInteger' does not refer to a type name in pseudo-destructor expression; expected the name of type 'int'}}
46 i->N::OtherInteger::~OtherInteger();
47 i->N::OtherInteger::~OtherInteger();
48 i->N::OtherInteger::~Integer(); // expected-error{{'Integer' does not refer to a type name in pseudo-destructor expression; expected the name of type 'int'}}
49 i->N::~Integer(); // expected-error{{'N' does not refer to a type name in pseudo-destructor expression; expected the name of type 'int'}}
50 i->N::OtherInteger::~Integer(); // expected-error{{'Integer' does not refer to a type name in pseudo-destructor expression; expected the name of type 'int'}}
51 i->Integer::~Double(); // expected-error{{the type of object expression ('int') does not match the type being destroyed ('Double' (aka 'double')) in pseudo-destructor expression}}
52
53 ii->~Integer(); // expected-error{{member reference type 'int' is not a pointer; did you mean to use '.'?}}
54 ii.~Integer();
55
56 cv_test(a);
57 cv_test(f);
58 cv_test(i);
59 cv_test(d);
60 }
61
62
63 typedef int Integer;
64
destroy_without_call(int * ip)65 void destroy_without_call(int *ip) {
66 ip->~Integer; // expected-error{{reference to pseudo-destructor must be called}}
67 }
68
paren_destroy_with_call(int * ip)69 void paren_destroy_with_call(int *ip) {
70 (ip->~Integer)();
71 }
72
73 // PR5530
74 namespace N1 {
75 class X0 { };
76 }
77
test_X0(N1::X0 & x0)78 void test_X0(N1::X0 &x0) {
79 x0.~X0();
80 }
81
82 namespace PR11339 {
83 template<class T>
destroy(T * p)84 void destroy(T* p) {
85 p->~T(); // ok
86 p->~oops(); // expected-error{{undeclared identifier 'oops' in destructor name}}
87 }
88
89 template void destroy(int*); // expected-note{{in instantiation of function template specialization}}
90 }
91
92 template<typename T> using Id = T;
AliasTemplate(int * p)93 void AliasTemplate(int *p) {
94 p->~Id<int>();
95 p->template ~Id<int>(); // expected-error {{'template' keyword not permitted in destructor name}}
96 (0).~Id<int>();
97 (0).template ~Id<int>(); // expected-error {{'template' keyword not permitted in destructor name}}
98 }
99
100 namespace dotPointerAccess {
101 struct Base {
~BasedotPointerAccess::Base102 virtual ~Base() {}
103 };
104
105 struct Derived : Base {
~DeriveddotPointerAccess::Derived106 ~Derived() {}
107 };
108
test()109 void test() {
110 Derived d;
111 static_cast<Base *>(&d).~Base(); // expected-error {{member reference type 'dotPointerAccess::Base *' is a pointer; did you mean to use '->'}}
112 d->~Derived(); // expected-error {{member reference type 'dotPointerAccess::Derived' is not a pointer; did you mean to use '.'}}
113 }
114
115 typedef Derived *Foo;
116
test2(Foo d)117 void test2(Foo d) {
118 d.~Foo(); // This is ok
119 d.~Derived(); // expected-error {{member reference type 'dotPointerAccess::Foo' (aka 'dotPointerAccess::Derived *') is a pointer; did you mean to use '->'}}
120 }
121 }
122
123 int pr45294 = 1 .~undeclared_tempate_name<>(); // expected-error {{use of undeclared 'undeclared_tempate_name'}}
124
125 namespace TwoPhaseLookup {
126 namespace NonTemplate {
127 struct Y {};
128 using G = Y;
f(T * p)129 template<typename T> void f(T *p) { p->~G(); } // expected-error {{no member named '~Y'}}
h1(Y * p)130 void h1(Y *p) { p->~G(); }
h2(Y * p)131 void h2(Y *p) { f(p); }
132 namespace N { struct G{}; }
h3(N::G * p)133 void h3(N::G *p) { p->~G(); }
h4(N::G * p)134 void h4(N::G *p) { f(p); } // expected-note {{instantiation of}}
135 }
136
137 namespace NonTemplateUndeclared {
138 struct Y {};
f(T * p)139 template<typename T> void f(T *p) { p->~G(); } // expected-error {{undeclared identifier 'G' in destructor name}}
140 using G = Y;
h1(Y * p)141 void h1(Y *p) { p->~G(); }
h2(Y * p)142 void h2(Y *p) { f(p); } // expected-note {{instantiation of}}
143 namespace N { struct G{}; }
h3(N::G * p)144 void h3(N::G *p) { p->~G(); }
h4(N::G * p)145 void h4(N::G *p) { f(p); }
146 }
147
148 namespace Template {
149 template<typename T> struct Y {};
150 template<class U> using G = Y<U>;
f(T * p)151 template<typename T> void f(T *p) { p->~G<int>(); } // expected-error {{no member named '~Y'}}
h1(Y<int> * p)152 void h1(Y<int> *p) { p->~G<int>(); }
h2(Y<int> * p)153 void h2(Y<int> *p) { f(p); }
154 namespace N { template<typename T> struct G {}; }
h3(N::G<int> * p)155 void h3(N::G<int> *p) { p->~G<int>(); }
h4(N::G<int> * p)156 void h4(N::G<int> *p) { f(p); } // expected-note {{instantiation of}}
157 }
158
159 namespace TemplateUndeclared {
160 template<typename T> struct Y {};
161 // FIXME: Formally, this is ill-formed before we hit any instantiation,
162 // because we aren't supposed to treat the '<' as introducing a template
163 // name.
f(T * p)164 template<typename T> void f(T *p) { p->~G<int>(); } // expected-error {{no member named 'G'}}
165 template<class U> using G = Y<U>;
h1(Y<int> * p)166 void h1(Y<int> *p) { p->~G<int>(); }
h2(Y<int> * p)167 void h2(Y<int> *p) { f(p); } // expected-note {{instantiation of}}
168 namespace N { template<typename T> struct G {}; }
h3(N::G<int> * p)169 void h3(N::G<int> *p) { p->~G<int>(); }
h4(N::G<int> * p)170 void h4(N::G<int> *p) { f(p); }
171 }
172
173 namespace TemplateNamesNonTemplate {
174 int A; // expected-note 2{{non-template here}}
175 template<typename> int B; // expected-note 2{{variable template 'B' declared here}} expected-warning {{extension}}
176 using C = int; // expected-note 2{{non-template here}}
177
f1(int * p)178 template<typename T> void f1(int *p) { p->~A<int>(); } // expected-error {{'A' does not refer to a template}}
f2(int * p)179 template<typename T> void f2(int *p) { p->~B<int>(); } // expected-error {{template name refers to non-type template 'B'}}
f3(int * p)180 template<typename T> void f3(int *p) { p->~C<int>(); } // expected-error {{'C' does not refer to a template}}
f4(int * p)181 template<typename T> void f4(int *p) { p->TemplateNamesNonTemplate::C::~A<int>(); } // expected-error {{'A' does not refer to a template}}
f5(int * p)182 template<typename T> void f5(int *p) { p->TemplateNamesNonTemplate::C::~B<int>(); } // expected-error {{template name refers to non-type template 'TemplateNamesNonTemplate::B'}}
f6(int * p)183 template<typename T> void f6(int *p) { p->TemplateNamesNonTemplate::C::~C<int>(); } // expected-error {{'C' does not refer to a template}}
184 }
185 }
186
destroy_array_element()187 void destroy_array_element() {
188 int arr[5];
189 using T = int;
190 arr->~T(); // ok, destroy arr[0].
191 }
192
destroy_function()193 void destroy_function() {
194 using T = void();
195 destroy_function->~T(); // expected-error {{object expression of non-scalar type 'void ()' cannot be used in a pseudo-destructor expression}}
196 }
197