[clang][Interp] Create a new local variable in visitLambdaExpr()

[tbaeder]

Summary

Move the logic for initialization of a lambda into
visitRecordInitializer(). When we visit a LambdaExpr outside of the
visitInitializer() logic, we need to create a new local variable so we
have a place to write the lambda members into.

This fixes passing lambas as arguments to function calls.

In that case, we visit a LambdaExpr without it being an initializer to anything, so we should create a new local variable and return a pointer to it, which we then pass to the function call.

[tbaeder]

Ping

[tbaeder]

Abandoning this in favor of https://reviews.llvm.org/D156027

clang/lib/AST/Interp/ByteCodeExprGen.cpp

 bool ByteCodeExprGen<Emitter>::VisitTypeTraitExpr(const TypeTraitExpr *E) {
   if (DiscardResult)
     return true;
   return this->emitConstBool(E->getValue(), E);
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitLambdaExpr(const LambdaExpr *E) {
-  // XXX We assume here that a pointer-to-initialize is on the stack.
-
-  const Record *R = P.getOrCreateRecord(E->getLambdaClass());
 
-  auto *CaptureInitIt = E->capture_init_begin();
-  // Initialize all fields (which represent lambda captures) of the
-  // record with their initializers.
-  for (const Record::Field &F : R->fields()) {
-    const Expr *Init = *CaptureInitIt;
-    ++CaptureInitIt;
-
-    if (std::optional<PrimType> T = classify(Init)) {
-      if (!this->visit(Init))
-        return false;
+  if (std::optional<unsigned> GI = allocateLocal(E, /*IsExtended=*/false)) {
+    if (!this->emitGetPtrLocal(*GI, E))
 
-      if (!this->emitSetField(*T, F.Offset, E))
-        return false;
-    } else {
-      if (!this->emitDupPtr(E))
-        return false;
-
-      if (!this->emitGetPtrField(F.Offset, E))
-        return false;
-
-      if (!this->visitInitializer(Init))
-        return false;
-
-      if (!this->emitPopPtr(E))
-        return false;
-    }
+    return this->visitRecordInitializer(E);
   }
 
-  return true;
+  return false;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitPredefinedExpr(const PredefinedExpr *E) {
   if (DiscardResult)
     return true;
 
   return this->visit(E->getFunctionName());
if (const auto CtorExpr = dyn_cast<CXXConstructExpr>(Initializer)) {
     return this->visitInitializer(CE->getSubExpr());
   } else if (const auto *CE = dyn_cast<CXXBindTemporaryExpr>(Initializer)) {
     return this->visitInitializer(CE->getSubExpr());
   } else if (const auto *ACO =
                  dyn_cast<AbstractConditionalOperator>(Initializer)) {
     return this->visitConditional(
         ACO, [this](const Expr *E) { return this->visitRecordInitializer(E); });
   } else if (const auto *LE = dyn_cast<LambdaExpr>(Initializer)) {
-    return this->VisitLambdaExpr(LE);
+    // XXX We assume here that a pointer-to-initialize is on the stack.
+
+    const Record *R = P.getOrCreateRecord(LE->getLambdaClass());
+
+    auto *CaptureInitIt = LE->capture_init_begin();
+    // Initialize all fields (which represent lambda captures) of the
+    // record with their initializers.
+    for (const Record::Field &F : R->fields()) {
+      const Expr *Init = *CaptureInitIt;
+      ++CaptureInitIt;
+
+      if (std::optional<PrimType> T = classify(Init)) {
+        if (!this->visit(Init))
+          return false;
+
+        if (!this->emitSetField(*T, F.Offset, LE))
+          return false;
+      } else {
+        if (!this->emitDupPtr(LE))
+          return false;
+
+        if (!this->emitGetPtrField(F.Offset, LE))
+          return false;
+
+        if (!this->visitInitializer(Init))
+          return false;
+
+        if (!this->emitPopPtr(LE))
+          return false;
+      }
+    }
+
+    return true;
   }
 
   return false;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::visitInitializer(const Expr *Initializer) {
   QualType InitializerType = Initializer->getType();

clang/test/AST/Interp/lambda.cpp

constexpr int foo() {
     callThis(f);
 
     return a;
   }
   /// FIXME: This should work in the new interpreter.
   static_assert(foo() == 1); // expected-error {{not an integral constant expression}}
 }
 
+namespace LambdasAsParams {
+  template<typename F>
+  constexpr auto call(F f) {
+    return f();
+  }
+  static_assert(call([](){ return 1;}) == 1);
+  static_assert(call([](){ return 2;}) == 2);
+
+
+  constexpr unsigned L = call([](){ return 12;});
+  static_assert(L == 12);
+
+
+  constexpr float heh() {
+    auto a = []() {
+      return 1.0;
+    };
+
+    return static_cast<float>(a());
+  }
+  static_assert(heh() == 1.0);
+}
+
 namespace StaticInvoker {
   constexpr int sv1(int i) {
     auto l = []() { return 12; };
     int (*fp)() = l;
     return fp();
   }
   static_assert(sv1(12) == 12);