[clang][Interp] Handle CXXTemporaryObjectExprs

[tbaeder]

Summary

This is a CXXConstructExpr, so create a local temporary variable and
initialize it.

[tbaeder]

Ping

[tbaeder]

Ping

[aaron.ballman]

clang/test/AST/Interp/records.cpp

314–315

Nit: nothing actually tests that this object is destroyed correctly. Here's an interesting test to consider:

struct S {
  constexpr S() {}
  constexpr ~S() noexcept(false) { throw 12; }
};

constexpr int f() {
  S{};
  return 12;
}

static_assert(f() == 12);

That should fail because ~S() would hit the throw expression and thus is not valid. Note, you'll need to add -Wno-invalid-constexpr to your test to avoid the warning-defaults-to-error about the destructor never producing a constant expression.

[tbaeder]

clang/test/AST/Interp/records.cpp

314–315

There are multiple reasons why that sample is not rejected right now, one I can easily fix in a follow-up patch, the other one would actually require us to recognize the throw and reject it with a proper diagnostic.

[aaron.ballman]

clang/test/AST/Interp/records.cpp

314–315

We should definitely fix the throw at some point, but any of the dynamically reachable problematic constructs would work (dynamic_cast whose type would throw, invocation of the va_arg macro, reinterpret_cast, etc)

[tbaeder]

clang/test/AST/Interp/records.cpp

314–315

Yes, I think we need a new opcode for that so we only emit the diagnostic when such a construct is actually executed.

[aaron.ballman]

clang/test/AST/Interp/records.cpp

314–315

Oh yeah, you'll definitely need that, a whole pile of the constexpr rules are based around code reachability.

Are you saying you've got no way to test this until you implement that opcode?

[tbaeder]

clang/test/AST/Interp/records.cpp

314–315

With https://reviews.llvm.org/D150040 applied, it gets properly rejected, just the diagnostics are off. I can add the test and reorder the commits.

[aaron.ballman]

LG pending test coverage being ready to land

clang/test/AST/Interp/records.cpp

314–315

SGTM, thanks!

clang/lib/AST/Interp/ByteCodeExprGen.h

public:
   bool VisitAbstractConditionalOperator(const AbstractConditionalOperator *E);
   bool VisitStringLiteral(const StringLiteral *E);
   bool VisitCharacterLiteral(const CharacterLiteral *E);
   bool VisitCompoundAssignOperator(const CompoundAssignOperator *E);
   bool VisitFloatCompoundAssignOperator(const CompoundAssignOperator *E);
   bool VisitPointerCompoundAssignOperator(const CompoundAssignOperator *E);
   bool VisitExprWithCleanups(const ExprWithCleanups *E);
   bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
+  bool VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *E);
+  bool VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *E);
   bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
   bool VisitTypeTraitExpr(const TypeTraitExpr *E);
   bool VisitLambdaExpr(const LambdaExpr *E);
   bool VisitPredefinedExpr(const PredefinedExpr *E);
 
 protected:
   bool visitExpr(const Expr *E) override;
   bool visitDecl(const VarDecl *VD) override;

clang/lib/AST/Interp/ByteCodeExprGen.cpp

if (std::optional<unsigned> LocalIndex =
         return false;
       return this->visitInitializer(SubExpr);
     }
   }
   return false;
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXBindTemporaryExpr(
+    const CXXBindTemporaryExpr *E) {
+
+  return this->visit(E->getSubExpr());
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXTemporaryObjectExpr(
+    const CXXTemporaryObjectExpr *E) {
+
+  if (std::optional<unsigned> LocalIndex =
+          allocateLocal(E, /*IsExtended=*/false)) {
+    return this->visitLocalInitializer(E, *LocalIndex);
+  }
+  return false;
+}
+
+template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitCompoundLiteralExpr(
     const CompoundLiteralExpr *E) {
   std::optional<PrimType> T = classify(E->getType());
   const Expr *Init = E->getInitializer();
   if (E->isFileScope()) {
     if (std::optional<unsigned> GlobalIndex = P.createGlobal(E)) {
       if (classify(E->getType()))
         return this->visit(Init);

clang/test/AST/Interp/records.cpp

#if __cplusplus >= 202002L
   };
 
 
   constexpr int T(int Index) {
     int Arr[] = {0, 0, 0};
     int Pos = 0;
 
     {
-      auto T = Test(Arr, Pos);
+      Test(Arr, Pos);
       // End of scope, should destroy Test.
     }
 
     return Arr[Index];
   }
-
   static_assert(T(0) == 1);
   static_assert(T(1) == 2);
   static_assert(T(2) == 3);
+
+  // Invalid destructor.
+  struct S {
+    constexpr S() {}
+    constexpr ~S() noexcept(false) { throw 12; } // expected-error {{cannot use 'throw'}} \
+                                                 // expected-note {{declared here}} \
+                                                 // ref-error {{cannot use 'throw'}} \
+                                                 // ref-error {{never produces a constant expression}} \
+                                                 // ref-note 2{{subexpression not valid}}
+  };
+
+  constexpr int f() {
+    S{}; // ref-note {{in call to 'S{}.~S()'}}
+    return 12; // expected-note {{undefined function '~S'}}
+  }
+  static_assert(f() == 12); // expected-error {{not an integral constant expression}} \
+                            // expected-note {{in call to 'f()'}} \
+                            // ref-error {{not an integral constant expression}} \
+                            // ref-note {{in call to 'f()'}}
+
+
 #endif
 }
 
 #if __cplusplus >= 201703L
 namespace BaseInit {
   class _A {public: int a;};
   class _B : public _A {};
   class _C : public _B {};
namespace Destructors {
   }
   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}} \
+                     // expected-note 2{{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;
+    return 1; // expected-note {{in call to '&S{}->~S()'}}
               // FIXME: ^ Wrong line
   }
   static_assert(testS() == 1); // expected-error {{not an integral constant expression}} \
+                               // expected-note {{in call to 'testS()'}} \
                                // ref-error {{not an integral constant expression}} \
                                // ref-note {{in call to 'testS()'}}
 }
 
 
 namespace VirtualDtors {
   class A {
   public: