2 files changed, 56 insertions, 5 deletions
diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
index 36bbae03f8..de70ad4cba 100644
--- a/lib/Sema/SemaExpr.cpp
+++ b/lib/Sema/SemaExpr.cpp
@@ -9282,6 +9282,12 @@ namespace {
       return BaseTransform::TransformUnaryOperator(E);
     }
 
+    /// \brief Transform the capture expressions in the lambda
+    /// expression.
+    ExprResult TransformLambdaExpr(LambdaExpr *E) {
+      // Lambdas never need to be transformed.
+      return E;
+    }
   };
 }
 
@@ -9307,6 +9313,29 @@ Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext) {
 void Sema::PopExpressionEvaluationContext() {
   ExpressionEvaluationContextRecord& Rec = ExprEvalContexts.back();
 
+  if (!Rec.Lambdas.empty()) {
+    if (Rec.Context == Unevaluated) {
+      // C++11 [expr.prim.lambda]p2:
+      //   A lambda-expression shall not appear in an unevaluated operand
+      //   (Clause 5).
+      for (unsigned I = 0, N = Rec.Lambdas.size(); I != N; ++I)
+        Diag(Rec.Lambdas[I]->getLocStart(), 
+             diag::err_lambda_unevaluated_operand);
+    } else {
+      // Mark the capture expressions odr-used. This was deferred
+      // during lambda expression creation.
+      for (unsigned I = 0, N = Rec.Lambdas.size(); I != N; ++I) {
+        LambdaExpr *Lambda = Rec.Lambdas[I];
+        for (LambdaExpr::capture_init_iterator 
+                  C = Lambda->capture_init_begin(),
+               CEnd = Lambda->capture_init_end();
+             C != CEnd; ++C) {
+          MarkDeclarationsReferencedInExpr(*C);
+        }
+      }
+    }
+  }
+
   // When are coming out of an unevaluated context, clear out any
   // temporaries that we may have created as part of the evaluation of
   // the expression in that context: they aren't relevant because they
@@ -9318,6 +9347,8 @@ void Sema::PopExpressionEvaluationContext() {
     CleanupVarDeclMarking();
     std::swap(MaybeODRUseExprs, Rec.SavedMaybeODRUseExprs);
 
+    if (Rec.Context == Unevaluated) {
+    }
   // Otherwise, merge the contexts together.
   } else {
     ExprNeedsCleanups |= Rec.ParentNeedsCleanups;
@@ -9589,8 +9620,9 @@ static ExprResult captureInLambda(Sema &S, LambdaScopeInfo *LSI,
   //
   // FIXME: Introduce an initialization entity for lambda captures.
       
-  // Introduce a new evaluation context for the initialization, so that
-  // temporaries introduced as part of the capture
+  // Introduce a new evaluation context for the initialization, so
+  // that temporaries introduced as part of the capture are retained
+  // to be re-"exported" from the lambda expression itself.
   S.PushExpressionEvaluationContext(Sema::PotentiallyEvaluated);
 
   Expr *Ref = new (S.Context) DeclRefExpr(Var, Type.getNonReferenceType(),
diff --git a/lib/Sema/SemaLambda.cpp b/lib/Sema/SemaLambda.cpp
index 776d27a364..afc4d5de27 100644
--- a/lib/Sema/SemaLambda.cpp
+++ b/lib/Sema/SemaLambda.cpp
@@ -357,9 +357,28 @@ ExprResult Sema::ActOnLambdaExpr(SourceLocation StartLoc,
   if (LambdaExprNeedsCleanups)
     ExprNeedsCleanups = true;
 
-  Expr *Lambda = LambdaExpr::Create(Context, Class, IntroducerRange, 
-                                    CaptureDefault, Captures, ExplicitParams, 
-                                    CaptureInits, Body->getLocEnd());
+  LambdaExpr *Lambda = LambdaExpr::Create(Context, Class, IntroducerRange, 
+                                          CaptureDefault, Captures, 
+                                          ExplicitParams, CaptureInits, 
+                                          Body->getLocEnd());
+
+  // C++11 [expr.prim.lambda]p2:
+  //   A lambda-expression shall not appear in an unevaluated operand
+  //   (Clause 5).
+  switch (ExprEvalContexts.back().Context) {
+  case Unevaluated:
+    // We don't actually diagnose this case immediately, because we
+    // could be within a context where we might find out later that
+    // the expression is potentially evaluated (e.g., for typeid).
+    ExprEvalContexts.back().Lambdas.push_back(Lambda);
+    break;
+
+  case ConstantEvaluated:
+  case PotentiallyEvaluated:
+  case PotentiallyEvaluatedIfUsed:
+    break;
+  }
+
   Diag(StartLoc, diag::err_lambda_unsupported);
 
   return MaybeBindToTemporary(Lambda);