clang/test/SemaCXX/destructor.cpp

   1 // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fsyntax-only -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -fcxx-exceptions -verify %s -pedantic
   2 // RUN: %clang_cc1 -std=c++11 -triple %ms_abi_triple -DMSABI -fsyntax-only -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -verify %s -pedantic
   3
   4 #if defined(BE_THE_HEADER)
   5
   6 // Wdelete-non-virtual-dtor should warn about the delete from smart pointer
   7 // classes in system headers (std::unique_ptr...) too.
   8
   9 #pragma clang system_header
  10 namespace dnvd {
  11
  12 struct SystemB {
  13   virtual void foo();
  14 };
  15
  16 template <typename T>
  17 class simple_ptr {
  18 public:
  19   simple_ptr(T* t): _ptr(t) {}
  20   ~simple_ptr() { delete _ptr; } // \
  21     // expected-warning {{delete called on non-final 'dnvd::B' that has virtual functions but non-virtual destructor}} \
  22     // expected-warning {{delete called on non-final 'dnvd::D' that has virtual functions but non-virtual destructor}}
  23   T& operator*() const { return *_ptr; }
  24 private:
  25   T* _ptr;
  26 };
  27 }
  28
  29 #else
  30
  31 #define BE_THE_HEADER
  32 #include __FILE__
  33
  34 class A {
  35 public:
  36   ~A();
  37 };
  38
  39 class B {
  40 public:
  41   ~B() { }
  42 };
  43
  44 class C {
  45 public:
  46   (~C)() { }
  47 };
  48
  49 struct D {
  50   static void ~D(int, ...) const { } //                          \
  51     // expected-error{{static member function cannot have 'const' qualifier}} \
  52     // expected-error{{destructor cannot be declared 'static'}}  \
  53     // expected-error{{destructor cannot have any parameters}}   \
  54     // expected-error{{destructor cannot be variadic}} \
  55     // expected-error{{destructor cannot have a return type}} \
  56     // expected-error{{'const' qualifier is not allowed on a destructor}}
  57 };
  58
  59 struct D2 {
  60   void ~D2() { } //                          \
  61   // expected-error{{destructor cannot have a return type}}
  62 };
  63
  64
  65 struct E;
  66
  67 typedef E E_typedef;
  68 struct E {
  69   ~E_typedef(); // expected-error{{destructor cannot be declared using a typedef 'E_typedef' (aka 'E') of the class name}}
  70 };
  71
  72 struct F {
  73   (~F)(); // expected-note {{previous declaration is here}}
  74   ~F(); // expected-error {{destructor cannot be redeclared}}
  75 };
  76
  77 ~; // expected-error {{expected a class name after '~' to name a destructor}}
  78 ~undef(); // expected-error {{undeclared identifier 'undef' in destructor name}}
  79 ~operator+(int, int);  // expected-error {{expected a class name after '~' to name a destructor}}
  80 ~F(){} // expected-error {{destructor must be a non-static member function}}
  81
  82 struct G {
  83   ~G();
  84 };
  85
  86 G::~G() { }
  87
  88 // <rdar://problem/6841210>
  89 struct H {
  90   ~H(void) { }
  91 };
  92
  93 struct X {};
  94
  95 struct Y {
  96   ~X(); // expected-error {{expected the class name after '~' to name the enclosing class}}
  97 };
  98
  99 namespace PR6421 {
 100   class T; // expected-note{{forward declaration}}
 101
 102   class QGenericArgument
 103   {
 104     template<typename U>
 105     void foo(T t) // expected-error{{variable has incomplete type}}
 106     { }
 107
 108     void disconnect()
 109     {
 110       T* t;
 111       bob<QGenericArgument>(t); // expected-error{{undeclared identifier 'bob'}}
 112     }
 113   };
 114 }
 115
 116 namespace PR6709 {
 117 #ifdef MSABI
 118   // This bug, "Clang instantiates destructor for function argument" is intended
 119   // behaviour in the Microsoft ABI because the callee needs to destruct the arguments.
 120   // expected-error@+3 {{indirection requires pointer operand ('int' invalid)}}
 121   // expected-note@+3 {{in instantiation of member function 'PR6709::X<int>::~X' requested here}}
 122 #endif
 123   template<class T> class X { T v; ~X() { ++*v; } };
 124   void a(X<int> x) {}
 125 }
 126
 127 struct X0 { virtual ~X0() throw(); };
 128 struct X1 : public X0 { };
 129
 130 // Make sure we instantiate operator deletes when building a virtual
 131 // destructor.
 132 namespace test6 {
 133   template <class T> class A {
 134   public:
 135     void *operator new(__SIZE_TYPE__);
 136     void operator delete(void *p) {
 137       T::deleteIt(p); // expected-error {{type 'int' cannot be used prior to '::'}}
 138     }
 139
 140 #ifdef MSABI
 141     // expected-note@+2 {{in instantiation of member function 'test6::A<int>::operator delete' requested here}}
 142 #endif
 143     virtual ~A() {}
 144   };
 145
 146 #ifndef MSABI
 147     // expected-note@+2 {{in instantiation of member function 'test6::A<int>::operator delete' requested here}}
 148 #endif
 149   class B : A<int> { B(); };
 150   B::B() {}
 151 }
 152
 153 // Make sure classes are marked invalid when they have invalid
 154 // members.  This avoids a crash-on-invalid.
 155 namespace test7 {
 156   struct A {
 157     ~A() const; // expected-error {{'const' qualifier is not allowed on a destructor}}
 158   };
 159   struct B : A {};
 160
 161   void test() {
 162     B *b;
 163     b->~B();
 164   }
 165 }
 166
 167 namespace nonvirtualdtor {
 168 struct S1 { // expected-warning {{has virtual functions but non-virtual destructor}}
 169   virtual void m();
 170 };
 171
 172 struct S2 {
 173   ~S2(); // expected-warning {{has virtual functions but non-virtual destructor}}
 174   virtual void m();
 175 };
 176
 177 struct S3 : public S1 {  // expected-warning {{has virtual functions but non-virtual destructor}}
 178   virtual void m();
 179 };
 180
 181 struct S4 : public S2 {  // expected-warning {{has virtual functions but non-virtual destructor}}
 182   virtual void m();
 183 };
 184
 185 struct B {
 186   virtual ~B();
 187   virtual void m();
 188 };
 189
 190 struct S5 : public B {
 191   virtual void m();
 192 };
 193
 194 struct S6 {
 195   virtual void m();
 196 private:
 197   ~S6();
 198 };
 199
 200 struct S7 {
 201   virtual void m();
 202 protected:
 203   ~S7();
 204 };
 205
 206 struct S8 {} s8;
 207
 208 UnknownType S8::~S8() { // expected-error {{unknown type name 'UnknownType'}}
 209   s8.~S8();
 210 }
 211
 212 template<class T> class TS : public B {
 213   virtual void m();
 214 };
 215
 216 TS<int> baz;
 217
 218 template<class T> class TS2 { // expected-warning {{'nonvirtualdtor::TS2<int>' has virtual functions but non-virtual destructor}}
 219   virtual void m();
 220 };
 221
 222 TS2<int> foo; // expected-note {{instantiation}}
 223 }
 224
 225 namespace dnvd { // delete-non-virtual-dtor warning
 226 struct NP {};
 227
 228 struct B { // expected-warning {{has virtual functions but non-virtual destructor}}
 229   virtual void foo();
 230 };
 231
 232 struct D: B {}; // expected-warning {{has virtual functions but non-virtual destructor}}
 233
 234 struct F final : B {};
 235
 236 struct VB {
 237   virtual void foo();
 238   virtual ~VB();
 239 };
 240
 241 struct VD: VB {};
 242
 243 struct VF final: VB {};
 244
 245 template <typename T>
 246 class simple_ptr2 {
 247 public:
 248   simple_ptr2(T* t): _ptr(t) {}
 249   ~simple_ptr2() { delete _ptr; } // expected-warning {{delete called on non-final 'dnvd::B' that has virtual functions but non-virtual destructor}}
 250   T& operator*() const { return *_ptr; }
 251 private:
 252   T* _ptr;
 253 };
 254
 255 void use(B&);
 256 void use(SystemB&);
 257 void use(VB&);
 258
 259 void nowarnstack() {
 260   B b; use(b);
 261   D d; use(d);
 262   F f; use(f);
 263   VB vb; use(vb);
 264   VD vd; use(vd);
 265   VF vf; use(vf);
 266 }
 267
 268 void nowarnnonpoly() {
 269   {
 270     NP* np = new NP();
 271     delete np;
 272   }
 273   {
 274     NP* np = new NP[4];
 275     delete[] np;
 276   }
 277 }
 278
 279 // FIXME: Why are these supposed to not warn?
 280 void nowarnarray() {
 281   {
 282     B* b = new B[4];
 283     delete[] b;
 284   }
 285   {
 286     D* d = new D[4];
 287     delete[] d;
 288   }
 289   {
 290     VB* vb = new VB[4];
 291     delete[] vb;
 292   }
 293   {
 294     VD* vd = new VD[4];
 295     delete[] vd;
 296   }
 297 }
 298
 299 template <typename T>
 300 void nowarntemplate() {
 301   {
 302     T* t = new T();
 303     delete t;
 304   }
 305   {
 306     T* t = new T[4];
 307     delete[] t;
 308   }
 309 }
 310
 311 void nowarn0() {
 312   {
 313     F* f = new F();
 314     delete f;
 315   }
 316   {
 317     VB* vb = new VB();
 318     delete vb;
 319   }
 320   {
 321     VB* vb = new VD();
 322     delete vb;
 323   }
 324   {
 325     VD* vd = new VD();
 326     delete vd;
 327   }
 328   {
 329     VF* vf = new VF();
 330     delete vf;
 331   }
 332 }
 333
 334 void nowarn0_explicit_dtor(F* f, VB* vb, VD* vd, VF* vf) {
 335   f->~F();
 336   f->~F();
 337   vb->~VB();
 338   vd->~VD();
 339   vf->~VF();
 340 }
 341
 342 void warn0() {
 343   {
 344     B* b = new B();
 345     delete b; // expected-warning {{delete called on non-final 'dnvd::B' that has virtual functions but non-virtual destructor}}
 346   }
 347   {
 348     B* b = new D();
 349     delete b; // expected-warning {{delete called on non-final 'dnvd::B' that has virtual functions but non-virtual destructor}}
 350   }
 351   {
 352     D* d = new D();
 353     delete d; // expected-warning {{delete called on non-final 'dnvd::D' that has virtual functions but non-virtual destructor}}
 354   }
 355 }
 356
 357 // Taken from libc++, slightly simplified.
 358 template <class>
 359 struct __is_destructible_apply { typedef int type; };
 360 struct __two {char __lx[2];};
 361 template <typename _Tp>
 362 struct __is_destructor_wellformed {
 363   template <typename _Tp1>
 364   static char __test(typename __is_destructible_apply<
 365                        decltype(_Tp1().~_Tp1())>::type);
 366   template <typename _Tp1>
 367   static __two __test (...);
 368
 369   static const bool value = sizeof(__test<_Tp>(12)) == sizeof(char);
 370 };
 371
 372 void warn0_explicit_dtor(B* b, B& br, D* d) {
 373   b->~B(); // expected-warning {{destructor called on non-final 'dnvd::B' that has virtual functions but non-virtual destructor}} expected-note{{qualify call to silence this warning}}
 374   b->B::~B(); // No warning when the call isn't virtual.
 375
 376   // No warning in unevaluated contexts.
 377   (void)__is_destructor_wellformed<B>::value;
 378
 379   br.~B(); // expected-warning {{destructor called on non-final 'dnvd::B' that has virtual functions but non-virtual destructor}} expected-note{{qualify call to silence this warning}}
 380   br.B::~B();
 381
 382   d->~D(); // expected-warning {{destructor called on non-final 'dnvd::D' that has virtual functions but non-virtual destructor}} expected-note{{qualify call to silence this warning}}
 383   d->D::~D();
 384 }
 385
 386 void nowarn1() {
 387   {
 388     simple_ptr<F> f(new F());
 389     use(*f);
 390   }
 391   {
 392     simple_ptr<VB> vb(new VB());
 393     use(*vb);
 394   }
 395   {
 396     simple_ptr<VB> vb(new VD());
 397     use(*vb);
 398   }
 399   {
 400     simple_ptr<VD> vd(new VD());
 401     use(*vd);
 402   }
 403   {
 404     simple_ptr<VF> vf(new VF());
 405     use(*vf);
 406   }
 407   {
 408     simple_ptr<SystemB> sb(new SystemB());
 409     use(*sb);
 410   }
 411 }
 412
 413 void warn1() {
 414   {
 415     simple_ptr<B> b(new B()); // expected-note {{in instantiation of member function 'dnvd::simple_ptr<dnvd::B>::~simple_ptr' requested here}}
 416     use(*b);
 417   }
 418   {
 419     simple_ptr2<B> b(new D()); // expected-note {{in instantiation of member function 'dnvd::simple_ptr2<dnvd::B>::~simple_ptr2' requested here}}
 420     use(*b);
 421   }
 422   {
 423     simple_ptr<D> d(new D()); // expected-note {{in instantiation of member function 'dnvd::simple_ptr<dnvd::D>::~simple_ptr' requested here}}
 424     use(*d);
 425   }
 426 }
 427 }
 428
 429 namespace PR9238 {
 430   class B { public: ~B(); };
 431   class C : virtual B { public: ~C() { } };
 432 }
 433
 434 namespace PR7900 {
 435   struct A { // expected-note 2{{type 'PR7900::A' found by destructor name lookup}}
 436   };
 437   struct B : public A {
 438   };
 439   void foo() {
 440     B b;
 441     b.~B();
 442     b.~A(); // expected-error{{destructor type 'PR7900::A' in object destruction expression does not match the type 'PR7900::B' of the object being destroyed}}
 443     (&b)->~A(); // expected-error{{destructor type 'PR7900::A' in object destruction expression does not match the type 'PR7900::B' of the object being destroyed}}
 444   }
 445 }
 446
 447 namespace PR16892 {
 448   auto p = &A::~A; // expected-error{{taking the address of a destructor}}
 449 }
 450
 451 namespace PR20238 {
 452 struct S {
 453   volatile ~S() { } // expected-error{{destructor cannot have a return type}}
 454 };
 455 }
 456
 457 namespace PR22668 {
 458 struct S {
 459 };
 460 void f(S s) {
 461   (s.~S)();
 462 }
 463 void g(S s) {
 464   (s.~S); // expected-error{{reference to destructor must be called}}
 465 }
 466 }
 467
 468 class Invalid {
 469     ~Invalid();
 470     UnknownType xx; // expected-error{{unknown type name}}
 471 };
 472
 473 // The constructor definition should not have errors
 474 Invalid::~Invalid() {}
 475
 476 namespace PR30361 {
 477 template <typename T>
 478 struct C1 {
 479   ~C1() {}
 480   operator C1<T>* () { return nullptr; }
 481   void foo1();
 482 };
 483
 484 template<typename T>
 485 void C1<T>::foo1() {
 486   C1::operator C1<T>*();
 487   C1::~C1();
 488 }
 489
 490 void foo1() {
 491   C1<int> x;
 492   x.foo1();
 493 }
 494 }
 495
 496 namespace DtorTypedef {
 497   struct A { ~A(); };
 498   using A = A;
 499   DtorTypedef::A::~A() {}
 500
 501   // This is invalid, but compilers accept it.
 502   struct B { ~B(); };
 503   namespace N { using B = B; }
 504   N::B::~B() {} // expected-error {{destructor cannot be declared using a type alias}}
 505
 506 #pragma clang diagnostic push
 507 #pragma clang diagnostic ignored "-Wdtor-typedef"
 508   struct C { ~C(); };
 509   namespace N { using C = C; }
 510   N::C::~C() {}
 511 #pragma clang diagnostic pop
 512 }
 513
 514 // Ignore ambiguity errors in destructor name lookup. This matches the observed
 515 // behavior of ICC, and is compatible with the observed behavior of GCC (which
 516 // appears to ignore lookups that result in ambiguity) and MSVC (which appears
 517 // to perform the lookups in the opposite order from Clang).
 518 namespace PR44978 {
 519   // All compilers accept this despite it being clearly ill-formed per the
 520   // current wording.
 521   namespace n {
 522     class Foo {}; // expected-note {{found}}
 523   }
 524   class Foo {}; // expected-note {{found}}
 525   using namespace n;
 526   static void func(n::Foo *p) { p->~Foo(); } // expected-warning {{ambiguous}}
 527
 528   // GCC rejects this case, ICC accepts, despite the class member lookup being
 529   // ambiguous.
 530   struct Z;
 531   struct X { using T = Z; }; // expected-note {{found}}
 532   struct Y { using T = int; }; // expected-note {{found}}
 533   struct Z : X, Y {};
 534   void f(Z *p) { p->~T(); } // expected-warning {{ambiguous}}
 535
 536   // GCC accepts this and ignores the ambiguous class member lookup.
 537   //
 538   // FIXME: We should warn on the ambiguity here too, but that requires us to
 539   // keep doing lookups after we've already found the type we want.
 540   using T = Z;
 541   void g(Z *p) { p->~T(); }
 542
 543   // ICC accepts this and ignores the ambiguous unqualified lookup.
 544   struct Q {};
 545   namespace { using U = Q; } // expected-note {{candidate}} expected-note {{found}}
 546   using U = int; // expected-note {{candidate}} expected-note {{found}}
 547   void f(Q *p) { p->~U(); } // expected-warning {{ambiguous}}
 548
 549   // We still diagnose if the unqualified lookup is dependent, though.
 550   template<typename T> void f(T *p) { p->~U(); } // expected-error {{ambiguous}}
 551 }
 552
 553 #endif // BE_THE_HEADER