[cxx1z-constexpr-lambda] Implement captures - thus completing implementation of constexpr lambdas.

[faisalv]

Summary

This patch attempts to enable evaluation of all forms of captures (however deeply nested) within constexpr lambdas.

Appreciate the feedback.

Thanks!

[faisalv]

lib/AST/ExprConstant.cpp

5061

I don't think we need this fixme - the type of the expression should be correct - all other const checks for mutability have already been performed, right?

5486

I need to delete this comment...

[rsmith]

lib/AST/ExprConstant.cpp

5061

When using handleLValueToRValueConversion to obtain the lvalue denoted by a reference, the type you pass should be the reference type itself (FD->getType()). This approach will give the wrong answer when using a captured volatile object:

void f() {
  volatile int n;
  constexpr volatile int *p = [&]{ return &n; }(); // should be accepted
}

5066–5068

I don't see why this assert is correct. If we initialize a reference with a (constant-folded) dereferenced integer cast to pointer type, the value will have integer representation. Just remove the assert?

5473–5474

Please use early-exit style (if (!HandleLValueMember(...)) return false;) here to reduce indentation and make it clearer that you only return false if a diagnostic has already been produced.

6338–6339

Returning false without producing a diagnostic (for the VLA case) is not OK. You should at least produce the basic "not a constant expression" note here.

[faisalv]

Incorporated Richard's feedback and added comments.

[faisalv]

lib/AST/ExprConstant.cpp

5061

OK - but how is the address of a local variable a constant expression?

[hubert.reinterpretcast]

lib/AST/ExprConstant.cpp

5061

I guess this one is safer:

void f() {
  volatile int n;
  constexpr volatile int *p = [&]{ return false ? &n : nullptr; }();
}

[rsmith]

lib/AST/ExprConstant.cpp

428–429

I'm a little concerned that adding this to every CallStackFrame may have a nontrivial impact on the overall stack usage of deeply-recursing constexpr evaluataions. (I'd also like to cache this map rather than recomputing it repeatedly.) But let's try this and see how it goes; we can look into caching the map as a later change.

4194

Indent.

5061

constexpr bool b = [&]{ return &n; }() == &n; // should be accepted

... is more what I was thinking.

5067–5071

Too much indentation here.

[faisalv]

Closed by commit https://reviews.llvm.org/rL295279

lib/AST/ExprConstant.cpp

     /// Index - The call index of this call.
     unsigned Index;
 
+    llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
+    FieldDecl *LambdaThisCaptureField;
+
     CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
                    const FunctionDecl *Callee, const LValue *This,
                    APValue *Arguments);

   return true;
 }
 
+static bool handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv,
+                                           QualType Type, const LValue &LVal,
+                                           APValue &RVal);
+
 /// Try to evaluate the initializer for a variable declaration.
 ///
 /// \param Info   Information about the ongoing evaluation.

 static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E,
                                 const VarDecl *VD, CallStackFrame *Frame,
                                 APValue *&Result) {
+
   // If this is a parameter to an active constexpr function call, perform
   // argument substitution.
   if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD)) {

       return false;
     This->moveInto(Result);
     return true;
+  } else if (MD && isLambdaCallOperator(MD)) {
+    // We're in a lambda; determine the lambda capture field maps.
+    MD->getParent()->getCaptureFields(Frame.LambdaCaptureFields,
+      Frame.LambdaThisCaptureField);
   }
 
   StmtResult Ret = {Result, ResultSlot};

 
 
 bool LValueExprEvaluator::VisitVarDecl(const Expr *E, const VarDecl *VD) {
+
+  if (Info.CurrentCall && isLambdaCallOperator(Info.CurrentCall->Callee)) {
+    if (auto *FD = Info.CurrentCall->LambdaCaptureFields.lookup(VD)) {
+      if (Info.checkingPotentialConstantExpression())
+        return false;
+      Result = *Info.CurrentCall->This;
+      // Set Result to the subobject of the lambda
+      if (HandleLValueMember(Info, E, Result, FD)) {
+        // If the field is of reference type, replace it with the variable or
+        // enclosing field it refers to, otherwise use the value of the field.
+        if (FD->getType()->isReferenceType()) {
+          APValue RVal;
+          // FIXME: We need to make sure we're passing the right type that
+          // maintains cv-qualifiers.
+          if (!handleLValueToRValueConversion(Info, E, E->getType(), Result,
+                                              RVal))
+            return false;
+          assert(RVal.isLValue() && "Reference captures through their "
+                                    "corresponding field members must refer to "
+                                    "lvalues (VarDecls or FieldDecls)");
+          Result.setFrom(Info.Ctx, RVal);
+        }
+        return true;
+      }
+
+      Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
+      return false;
+    }
+  }
   CallStackFrame *Frame = nullptr;
   if (VD->hasLocalStorage() && Info.CurrentCall->Index > 1) {
     // Only if a local variable was declared in the function currently being

       return false;
     }
     Result = *Info.CurrentCall->This;
+    // If we are inside a lambda's call operator, the 'this' expression refers
+    // to the enclosing '*this' object (either by value or reference) which is
+    // either copied into the closure object's field that represents the '*this'
+    // or refers to '*this'.
+    if (isLambdaCallOperator(Info.CurrentCall->Callee)) {
+      
+      if (HandleLValueMember(Info, E, Result,
+                             Info.CurrentCall->LambdaThisCaptureField)) {
+        if (Info.CurrentCall->LambdaThisCaptureField->getType()
+                ->isPointerType()) {
+          APValue RVal;
+          if (!handleLValueToRValueConversion(Info, E, E->getType(), Result,
+                                              RVal))
+            return false;
+
+          Result.setFrom(Info.Ctx, RVal);
+        }
+        return true;
+      }
+      //Info.FFDiag(E);
+      return false;
+    }
     return true;
   }
 

   if (ClosureClass->isInvalidDecl()) return false;
 
   if (Info.checkingPotentialConstantExpression()) return true;
-  if (E->capture_size()) {
-    Info.FFDiag(E, diag::note_unimplemented_constexpr_lambda_feature_ast)
-        << "can not evaluate lambda expressions with captures";
-    return false;
+  
+  const size_t NumFields =
+      std::distance(ClosureClass->field_begin(), ClosureClass->field_end());
+  
+  assert(NumFields ==
+    std::distance(E->capture_init_begin(), E->capture_init_end()) &&
+    "The number of lambda capture initializers should equal the number of "
+    "fields within the closure type");
+  
+  Result = APValue(APValue::UninitStruct(), /*NumBases*/0, NumFields);
+  // Iterate through all the lambda's closure object's fields and initialize
+  // them.
+  auto *CaptureInitIt = E->capture_init_begin();
+  const LambdaCapture *CaptureIt = ClosureClass->captures_begin();
+  bool Success = true;
+  for (const auto *Field : ClosureClass->fields()) {
+    assert(CaptureInitIt != E->capture_init_end());
+    // Get the initializer for this field
+    Expr *const CurFieldInit = *CaptureInitIt++;
+    
+    // If there is no initializer, either this is a VLA or an error has
+    // occurred.
+    if (!CurFieldInit)
+      return false;
+
+    APValue &FieldVal = Result.getStructField(Field->getFieldIndex());
+    if (!EvaluateInPlace(FieldVal, Info, This, CurFieldInit)) {
+      if (!Info.keepEvaluatingAfterFailure())
+        return false;
+      Success = false;
+    }
+    ++CaptureIt;
   }
-  // FIXME: Implement captures.
-  Result = APValue(APValue::UninitStruct(), /*NumBases*/0, /*NumFields*/0);
-  return true;
+  return Success;
 }
 
 static bool EvaluateRecord(const Expr *E, const LValue &This,

test/SemaCXX/cxx1z-constexpr-lambdas.cpp

-// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks %s
-// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s 
-// RUN: %clang_cc1 -std=c++14 -verify -fsyntax-only -fblocks %s -DCPP14_AND_EARLIER
+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks %s -fcxx-exceptions
+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s -fcxx-exceptions
+// RUN: %clang_cc1 -std=c++14 -verify -fsyntax-only -fblocks %s -DCPP14_AND_EARLIER -fcxx-exceptions
 
 
 namespace test_lambda_is_literal {

 
 } // end ns1_simple_lambda
 
-namespace ns1_unimplemented {
-namespace ns1_captures {
+namespace test_captures_1 {
+namespace ns1 {
 constexpr auto f(int i) {
-  double d = 3.14;
-  auto L = [=](auto a) { //expected-note{{coming soon}}
-    int Isz = i + d;
-    return sizeof(i) + sizeof(a) + sizeof(d); 
+  struct S { int x; } s = { i * 2 };
+  auto L = [=](auto a) { 
+    return i + s.x + a;
   };
   return L;
 }
-constexpr auto M = f(3);  //expected-error{{constant expression}} expected-note{{in call to}}
-} // end ns1_captures
+constexpr auto M = f(3);  
+
+static_assert(M(10) == 19);
+
+} // end test_captures_1::ns1
+
+namespace ns2 {
+
+constexpr auto foo(int n) {
+  auto L = [i = n] (auto N) mutable {
+    if (!N(i)) throw "error";
+    return [&i] {
+      return ++i;
+    };
+  };
+  auto M = L([n](int p) { return p == n; });
+  M(); M();
+  L([n](int p) { return p == n + 2; });
+  
+  return L;
+}
+
+constexpr auto L = foo(3);
+
+} // end test_captures_1::ns2
+namespace ns3 {
+
+constexpr auto foo(int n) {
+  auto L = [i = n] (auto N) mutable {
+    if (!N(i)) throw "error";
+    return [&i] {
+      return [i]() mutable {
+        return ++i;
+      };
+    };
+  };
+  auto M = L([n](int p) { return p == n; });
+  M()(); M()();
+  L([n](int p) { return p == n; });
+  
+  return L;
+}
+
+constexpr auto L = foo(3);
+} // end test_captures_1::ns3
+
+namespace ns2_capture_this_byval {
+struct S {
+  int s;
+  constexpr S(int s) : s{s} { }
+  constexpr auto f(S o) {
+    return [*this,o] (auto a) { return s + o.s + a.s; };
+  }
+};
+
+constexpr auto L = S{5}.f(S{10});
+static_assert(L(S{100}) == 115);
+} // end test_captures_1::ns2_capture_this_byval
+
+namespace ns2_capture_this_byref {
+
+struct S {
+  int s;
+  constexpr S(int s) : s{s} { }
+  constexpr auto f() const {
+    return [this] { return s; };
+  }
+};
+
+constexpr S SObj{5};
+constexpr auto L = SObj.f();
+constexpr int I = L();
+static_assert(I == 5);
+
+} // end ns2_capture_this_byref
+
+} // end test_captures_1
+
+namespace test_capture_array {
+namespace ns1 {
+constexpr auto f(int I) {
+  int arr[] = { I, I *2, I * 3 };
+  auto L1 = [&] (auto a) { return arr[a]; };
+  int r = L1(2);
+  struct X { int x, y; };
+  return [=](auto a) { return X{arr[a],r}; };
+}
+constexpr auto L = f(3);
+static_assert(L(0).x == 3);
+static_assert(L(0).y == 9);
+static_assert(L(1).x == 6);
+static_assert(L(1).y == 9);
+} // end ns1
+
+} // end test_capture_array
+namespace ns1_unimplemented {
 } // end ns1_unimplemented 
 
 } // end ns test_lambda_is_cce