[clang][Interp] Make sure we have a variable scope for initializers

[tbaeder]

Summary

Otherwise, we run into an assertion when trying to use the current
variable scope while creating temporaries for constructor initializers.

[tbaeder]

Move the scope and add a test that ensures destruction order of the temporaries.

[aaron.ballman]

Generally LGTM but had an additional test request.

clang/test/AST/Interp/records.cpp

315

Would it make sense to give Test a constexpr destructor so that we can validate it's being called? e.g. https://godbolt.org/z/fhE7xzE4e

[tbaeder]

clang/test/AST/Interp/records.cpp

315

That just tests regular destructors, doesn't it? That's already covered by other tests.

[aaron.ballman]

clang/test/AST/Interp/records.cpp

315

Yeah, that's fair I suppose. :-)

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

bool ByteCodeStmtGen<Emitter>::visitFunc(const FunctionDecl *F) {
   // Constructor. Set up field initializers.
   if (const auto Ctor = dyn_cast<CXXConstructorDecl>(F)) {
     const RecordDecl *RD = Ctor->getParent();
     const Record *R = this->getRecord(RD);
     if (!R)
       return false;
 
     for (const auto *Init : Ctor->inits()) {
+      // Scope needed for the initializers.
+      BlockScope<Emitter> Scope(this);
+
       const Expr *InitExpr = Init->getInit();
       if (const FieldDecl *Member = Init->getMember()) {
         const Record::Field *F = R->getField(Member);
 
         if (std::optional<PrimType> T = this->classify(InitExpr)) {
           if (!this->visit(InitExpr))
             return false;
 

clang/test/AST/Interp/records.cpp

struct S {
   constexpr int m() const {
     fo();
     return 1;
   }
 };
 constexpr S s;
 static_assert(s.m() == 1, "");
 
+namespace InitializerTemporaries {
+  class Bar {
+  private:
+    int a;
+
+  public:
+    constexpr Bar() : a(10) {}
+    constexpr int getA() const { return a; }
+  };
+
+  class Foo {
+  public:
+    int a;
+
+    constexpr Foo() : a(Bar().getA()) {}
+  };
+  constexpr Foo F;
+  static_assert(F.a == 10, "");
+
+
+  /// Needs constexpr destructors.
+#if __cplusplus >= 202002L
+  /// Does
+  ///    Arr[Pos] = Value;
+  ///    ++Pos;
+  /// in its destructor.
+  class BitSetter {
+  private:
+    int *Arr;
+    int &Pos;
+    int Value;
+
+  public:
+    constexpr BitSetter(int *Arr, int &Pos, int Value) :
+      Arr(Arr), Pos(Pos), Value(Value) {}
+
+    constexpr int getValue() const { return 0; }
+    constexpr ~BitSetter() {
+      Arr[Pos] = Value;
+      ++Pos;
+    }
+  };
+
+  class Test {
+    int a, b, c;
+  public:
+    constexpr Test(int *Arr, int &Pos) :
+      a(BitSetter(Arr, Pos, 1).getValue()),
+      b(BitSetter(Arr, Pos, 2).getValue()),
+      c(BitSetter(Arr, Pos, 3).getValue())
+    {}
+  };
+
+
+  constexpr int T(int Index) {
+    int Arr[] = {0, 0, 0};
+    int Pos = 0;
+
+    {
+      auto T = 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);
+#endif
+}
+
 #if __cplusplus >= 201703L
 namespace BaseInit {
   class _A {public: int a;};
   class _B : public _A {};
   class _C : public _B {};
 
   constexpr _C c{12};
   constexpr const _B &b = c;