[clang][Interp] Call invalid destructors

[tbaeder]

Summary

We need to call them like any other function, so we can generate proper
diagnostics.

[erichkeane]

clang/test/AST/Interp/records.cpp

582

Which DTOR is happening here that changes behavior in this patch? You removed the isConstexpr test, but it seems to me that the S destructor is constexpr, right?

[tbaeder]

clang/test/AST/Interp/records.cpp

582

Function::isConstexpr() doesn't return the same as FunctionDecl::isConstexpr() - it's just return IsValid right now, so if the compilation of the function aborts at any point, Function::isConstexpr() returns false (even if the function that was compiled is constexpr).

[tbaeder]

Ping

[aaron.ballman]

LGTM

clang/lib/AST/Interp/ByteCodeExprGen.cpp

bool ByteCodeExprGen<Emitter>::emitRecordDestruction(const Descriptor *Desc) {
   }
 
   // FIXME: Unions need to be handled differently here. We don't want to
   //   call the destructor of its members.
 
   // Now emit the destructor and recurse into base classes.
   if (const CXXDestructorDecl *Dtor = R->getDestructor();
       Dtor && !Dtor->isTrivial()) {
-    const Function *DtorFunc = getFunction(Dtor);
-    if (DtorFunc && DtorFunc->isConstexpr()) {
+    if (const Function *DtorFunc = getFunction(Dtor)) {
       assert(DtorFunc->hasThisPointer());
       assert(DtorFunc->getNumParams() == 1);
       if (!this->emitDupPtr(SourceInfo{}))
         return false;
       if (!this->emitCall(DtorFunc, SourceInfo{}))
         return false;
     }
   }

clang/test/AST/Interp/records.cpp

namespace Destructors {
   };
 
   constexpr int test() {
     int i = 0;
     Derived d(i);
     return i;
   }
   static_assert(test() == 1);
+
+  struct S {
+    constexpr S() {}
+    constexpr ~S() { // expected-error {{never produces a constant expression}} \
+                     // ref-error {{never produces a constant expression}}
+      int i = 1 / 0; // expected-warning {{division by zero}} \
+                     // expected-note {{division by zero}} \
+                     // ref-warning {{division by zero}} \
+                     // ref-note 2{{division by zero}}
+    }
+  };
+  constexpr int testS() {
+    S{}; // ref-note {{in call to 'S{}.~S()'}}
+    return 1;
+              // FIXME: ^ Wrong line
+  }
+  static_assert(testS() == 1); // expected-error {{not an integral constant expression}} \
+                               // ref-error {{not an integral constant expression}} \
+                               // ref-note {{in call to 'testS()'}}
 }
 
 
 namespace VirtualDtors {
   class A {
   public:
     unsigned &v;
     constexpr A(unsigned &v) : v(v) {}