contrib/llvm/tools/clang/lib/Sema/SemaLambda.cpp

   1 //===--- SemaLambda.cpp - Semantic Analysis for C++11 Lambdas -------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file implements semantic analysis for C++ lambda expressions.
  11 //
  12 //===----------------------------------------------------------------------===//
  13 #include "clang/Sema/DeclSpec.h"
  14 #include "TypeLocBuilder.h"
  15 #include "clang/AST/ASTLambda.h"
  16 #include "clang/AST/ExprCXX.h"
  17 #include "clang/Basic/TargetInfo.h"
  18 #include "clang/Sema/Initialization.h"
  19 #include "clang/Sema/Lookup.h"
  20 #include "clang/Sema/Scope.h"
  21 #include "clang/Sema/ScopeInfo.h"
  22 #include "clang/Sema/SemaInternal.h"
  23 #include "clang/Sema/SemaLambda.h"
  24 using namespace clang;
  25 using namespace sema;
  26
  27 /// \brief Examines the FunctionScopeInfo stack to determine the nearest
  28 /// enclosing lambda (to the current lambda) that is 'capture-ready' for
  29 /// the variable referenced in the current lambda (i.e. \p VarToCapture).
  30 /// If successful, returns the index into Sema's FunctionScopeInfo stack
  31 /// of the capture-ready lambda's LambdaScopeInfo.
  32 ///
  33 /// Climbs down the stack of lambdas (deepest nested lambda - i.e. current
  34 /// lambda - is on top) to determine the index of the nearest enclosing/outer
  35 /// lambda that is ready to capture the \p VarToCapture being referenced in
  36 /// the current lambda.
  37 /// As we climb down the stack, we want the index of the first such lambda -
  38 /// that is the lambda with the highest index that is 'capture-ready'.
  39 ///
  40 /// A lambda 'L' is capture-ready for 'V' (var or this) if:
  41 ///  - its enclosing context is non-dependent
  42 ///  - and if the chain of lambdas between L and the lambda in which
  43 ///    V is potentially used (i.e. the lambda at the top of the scope info
  44 ///    stack), can all capture or have already captured V.
  45 /// If \p VarToCapture is 'null' then we are trying to capture 'this'.
  46 ///
  47 /// Note that a lambda that is deemed 'capture-ready' still needs to be checked
  48 /// for whether it is 'capture-capable' (see
  49 /// getStackIndexOfNearestEnclosingCaptureCapableLambda), before it can truly
  50 /// capture.
  51 ///
  52 /// \param FunctionScopes - Sema's stack of nested FunctionScopeInfo's (which a
  53 ///  LambdaScopeInfo inherits from).  The current/deepest/innermost lambda
  54 ///  is at the top of the stack and has the highest index.
  55 /// \param VarToCapture - the variable to capture.  If NULL, capture 'this'.
  56 ///
  57 /// \returns An Optional<unsigned> Index that if evaluates to 'true' contains
  58 /// the index (into Sema's FunctionScopeInfo stack) of the innermost lambda
  59 /// which is capture-ready.  If the return value evaluates to 'false' then
  60 /// no lambda is capture-ready for \p VarToCapture.
  61
  62 static inline Optional<unsigned>
  63 getStackIndexOfNearestEnclosingCaptureReadyLambda(
  64     ArrayRef<const clang::sema::FunctionScopeInfo *> FunctionScopes,
  65     VarDecl *VarToCapture) {
  66   // Label failure to capture.
  67   const Optional<unsigned> NoLambdaIsCaptureReady;
  68
  69   assert(
  70       isa<clang::sema::LambdaScopeInfo>(
  71           FunctionScopes[FunctionScopes.size() - 1]) &&
  72       "The function on the top of sema's function-info stack must be a lambda");
  73
  74   // If VarToCapture is null, we are attempting to capture 'this'.
  75   const bool IsCapturingThis = !VarToCapture;
  76   const bool IsCapturingVariable = !IsCapturingThis;
  77
  78   // Start with the current lambda at the top of the stack (highest index).
  79   unsigned CurScopeIndex = FunctionScopes.size() - 1;
  80   DeclContext *EnclosingDC =
  81       cast<sema::LambdaScopeInfo>(FunctionScopes[CurScopeIndex])->CallOperator;
  82
  83   do {
  84     const clang::sema::LambdaScopeInfo *LSI =
  85         cast<sema::LambdaScopeInfo>(FunctionScopes[CurScopeIndex]);
  86     // IF we have climbed down to an intervening enclosing lambda that contains
  87     // the variable declaration - it obviously can/must not capture the
  88     // variable.
  89     // Since its enclosing DC is dependent, all the lambdas between it and the
  90     // innermost nested lambda are dependent (otherwise we wouldn't have
  91     // arrived here) - so we don't yet have a lambda that can capture the
  92     // variable.
  93     if (IsCapturingVariable &&
  94         VarToCapture->getDeclContext()->Equals(EnclosingDC))
  95       return NoLambdaIsCaptureReady;
  96
  97     // For an enclosing lambda to be capture ready for an entity, all
  98     // intervening lambda's have to be able to capture that entity. If even
  99     // one of the intervening lambda's is not capable of capturing the entity
 100     // then no enclosing lambda can ever capture that entity.
 101     // For e.g.
 102     // const int x = 10;
 103     // [=](auto a) {    #1
 104     //   [](auto b) {   #2 <-- an intervening lambda that can never capture 'x'
 105     //    [=](auto c) { #3
 106     //       f(x, c);  <-- can not lead to x's speculative capture by #1 or #2
 107     //    }; }; };
 108     // If they do not have a default implicit capture, check to see
 109     // if the entity has already been explicitly captured.
 110     // If even a single dependent enclosing lambda lacks the capability
 111     // to ever capture this variable, there is no further enclosing
 112     // non-dependent lambda that can capture this variable.
 113     if (LSI->ImpCaptureStyle == sema::LambdaScopeInfo::ImpCap_None) {
 114       if (IsCapturingVariable && !LSI->isCaptured(VarToCapture))
 115         return NoLambdaIsCaptureReady;
 116       if (IsCapturingThis && !LSI->isCXXThisCaptured())
 117         return NoLambdaIsCaptureReady;
 118     }
 119     EnclosingDC = getLambdaAwareParentOfDeclContext(EnclosingDC);
 120
 121     assert(CurScopeIndex);
 122     --CurScopeIndex;
 123   } while (!EnclosingDC->isTranslationUnit() &&
 124            EnclosingDC->isDependentContext() &&
 125            isLambdaCallOperator(EnclosingDC));
 126
 127   assert(CurScopeIndex < (FunctionScopes.size() - 1));
 128   // If the enclosingDC is not dependent, then the immediately nested lambda
 129   // (one index above) is capture-ready.
 130   if (!EnclosingDC->isDependentContext())
 131     return CurScopeIndex + 1;
 132   return NoLambdaIsCaptureReady;
 133 }
 134
 135 /// \brief Examines the FunctionScopeInfo stack to determine the nearest
 136 /// enclosing lambda (to the current lambda) that is 'capture-capable' for
 137 /// the variable referenced in the current lambda (i.e. \p VarToCapture).
 138 /// If successful, returns the index into Sema's FunctionScopeInfo stack
 139 /// of the capture-capable lambda's LambdaScopeInfo.
 140 ///
 141 /// Given the current stack of lambdas being processed by Sema and
 142 /// the variable of interest, to identify the nearest enclosing lambda (to the
 143 /// current lambda at the top of the stack) that can truly capture
 144 /// a variable, it has to have the following two properties:
 145 ///  a) 'capture-ready' - be the innermost lambda that is 'capture-ready':
 146 ///     - climb down the stack (i.e. starting from the innermost and examining
 147 ///       each outer lambda step by step) checking if each enclosing
 148 ///       lambda can either implicitly or explicitly capture the variable.
 149 ///       Record the first such lambda that is enclosed in a non-dependent
 150 ///       context. If no such lambda currently exists return failure.
 151 ///  b) 'capture-capable' - make sure the 'capture-ready' lambda can truly
 152 ///  capture the variable by checking all its enclosing lambdas:
 153 ///     - check if all outer lambdas enclosing the 'capture-ready' lambda
 154 ///       identified above in 'a' can also capture the variable (this is done
 155 ///       via tryCaptureVariable for variables and CheckCXXThisCapture for
 156 ///       'this' by passing in the index of the Lambda identified in step 'a')
 157 ///
 158 /// \param FunctionScopes - Sema's stack of nested FunctionScopeInfo's (which a
 159 /// LambdaScopeInfo inherits from).  The current/deepest/innermost lambda
 160 /// is at the top of the stack.
 161 ///
 162 /// \param VarToCapture - the variable to capture.  If NULL, capture 'this'.
 163 ///
 164 ///
 165 /// \returns An Optional<unsigned> Index that if evaluates to 'true' contains
 166 /// the index (into Sema's FunctionScopeInfo stack) of the innermost lambda
 167 /// which is capture-capable.  If the return value evaluates to 'false' then
 168 /// no lambda is capture-capable for \p VarToCapture.
 169
 170 Optional<unsigned> clang::getStackIndexOfNearestEnclosingCaptureCapableLambda(
 171     ArrayRef<const sema::FunctionScopeInfo *> FunctionScopes,
 172     VarDecl *VarToCapture, Sema &S) {
 173
 174   const Optional<unsigned> NoLambdaIsCaptureCapable;
 175
 176   const Optional<unsigned> OptionalStackIndex =
 177       getStackIndexOfNearestEnclosingCaptureReadyLambda(FunctionScopes,
 178                                                         VarToCapture);
 179   if (!OptionalStackIndex)
 180     return NoLambdaIsCaptureCapable;
 181
 182   const unsigned IndexOfCaptureReadyLambda = OptionalStackIndex.getValue();
 183   assert(((IndexOfCaptureReadyLambda != (FunctionScopes.size() - 1)) ||
 184           S.getCurGenericLambda()) &&
 185          "The capture ready lambda for a potential capture can only be the "
 186          "current lambda if it is a generic lambda");
 187
 188   const sema::LambdaScopeInfo *const CaptureReadyLambdaLSI =
 189       cast<sema::LambdaScopeInfo>(FunctionScopes[IndexOfCaptureReadyLambda]);
 190
 191   // If VarToCapture is null, we are attempting to capture 'this'
 192   const bool IsCapturingThis = !VarToCapture;
 193   const bool IsCapturingVariable = !IsCapturingThis;
 194
 195   if (IsCapturingVariable) {
 196     // Check if the capture-ready lambda can truly capture the variable, by
 197     // checking whether all enclosing lambdas of the capture-ready lambda allow
 198     // the capture - i.e. make sure it is capture-capable.
 199     QualType CaptureType, DeclRefType;
 200     const bool CanCaptureVariable =
 201         !S.tryCaptureVariable(VarToCapture,
 202                               /*ExprVarIsUsedInLoc*/ SourceLocation(),
 203                               clang::Sema::TryCapture_Implicit,
 204                               /*EllipsisLoc*/ SourceLocation(),
 205                               /*BuildAndDiagnose*/ false, CaptureType,
 206                               DeclRefType, &IndexOfCaptureReadyLambda);
 207     if (!CanCaptureVariable)
 208       return NoLambdaIsCaptureCapable;
 209   } else {
 210     // Check if the capture-ready lambda can truly capture 'this' by checking
 211     // whether all enclosing lambdas of the capture-ready lambda can capture
 212     // 'this'.
 213     const bool CanCaptureThis =
 214         !S.CheckCXXThisCapture(
 215              CaptureReadyLambdaLSI->PotentialThisCaptureLocation,
 216              /*Explicit*/ false, /*BuildAndDiagnose*/ false,
 217              &IndexOfCaptureReadyLambda);
 218     if (!CanCaptureThis)
 219       return NoLambdaIsCaptureCapable;
 220   }
 221   return IndexOfCaptureReadyLambda;
 222 }
 223
 224 static inline TemplateParameterList *
 225 getGenericLambdaTemplateParameterList(LambdaScopeInfo *LSI, Sema &SemaRef) {
 226   if (LSI->GLTemplateParameterList)
 227     return LSI->GLTemplateParameterList;
 228
 229   if (LSI->AutoTemplateParams.size()) {
 230     SourceRange IntroRange = LSI->IntroducerRange;
 231     SourceLocation LAngleLoc = IntroRange.getBegin();
 232     SourceLocation RAngleLoc = IntroRange.getEnd();
 233     LSI->GLTemplateParameterList = TemplateParameterList::Create(
 234         SemaRef.Context,
 235         /*Template kw loc*/ SourceLocation(), LAngleLoc,
 236         (NamedDecl **)LSI->AutoTemplateParams.data(),
 237         LSI->AutoTemplateParams.size(), RAngleLoc);
 238   }
 239   return LSI->GLTemplateParameterList;
 240 }
 241
 242 CXXRecordDecl *Sema::createLambdaClosureType(SourceRange IntroducerRange,
 243                                              TypeSourceInfo *Info,
 244                                              bool KnownDependent,
 245                                              LambdaCaptureDefault CaptureDefault) {
 246   DeclContext *DC = CurContext;
 247   while (!(DC->isFunctionOrMethod() || DC->isRecord() || DC->isFileContext()))
 248     DC = DC->getParent();
 249   bool IsGenericLambda = getGenericLambdaTemplateParameterList(getCurLambda(),
 250                                                                *this);
 251   // Start constructing the lambda class.
 252   CXXRecordDecl *Class = CXXRecordDecl::CreateLambda(Context, DC, Info,
 253                                                      IntroducerRange.getBegin(),
 254                                                      KnownDependent,
 255                                                      IsGenericLambda,
 256                                                      CaptureDefault);
 257   DC->addDecl(Class);
 258
 259   return Class;
 260 }
 261
 262 /// \brief Determine whether the given context is or is enclosed in an inline
 263 /// function.
 264 static bool isInInlineFunction(const DeclContext *DC) {
 265   while (!DC->isFileContext()) {
 266     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DC))
 267       if (FD->isInlined())
 268         return true;
 269
 270     DC = DC->getLexicalParent();
 271   }
 272
 273   return false;
 274 }
 275
 276 MangleNumberingContext *
 277 Sema::getCurrentMangleNumberContext(const DeclContext *DC,
 278                                     Decl *&ManglingContextDecl) {
 279   // Compute the context for allocating mangling numbers in the current
 280   // expression, if the ABI requires them.
 281   ManglingContextDecl = ExprEvalContexts.back().ManglingContextDecl;
 282
 283   enum ContextKind {
 284     Normal,
 285     DefaultArgument,
 286     DataMember,
 287     StaticDataMember
 288   } Kind = Normal;
 289
 290   // Default arguments of member function parameters that appear in a class
 291   // definition, as well as the initializers of data members, receive special
 292   // treatment. Identify them.
 293   if (ManglingContextDecl) {
 294     if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(ManglingContextDecl)) {
 295       if (const DeclContext *LexicalDC
 296           = Param->getDeclContext()->getLexicalParent())
 297         if (LexicalDC->isRecord())
 298           Kind = DefaultArgument;
 299     } else if (VarDecl *Var = dyn_cast<VarDecl>(ManglingContextDecl)) {
 300       if (Var->getDeclContext()->isRecord())
 301         Kind = StaticDataMember;
 302     } else if (isa<FieldDecl>(ManglingContextDecl)) {
 303       Kind = DataMember;
 304     }
 305   }
 306
 307   // Itanium ABI [5.1.7]:
 308   //   In the following contexts [...] the one-definition rule requires closure
 309   //   types in different translation units to "correspond":
 310   bool IsInNonspecializedTemplate =
 311     !ActiveTemplateInstantiations.empty() || CurContext->isDependentContext();
 312   switch (Kind) {
 313   case Normal:
 314     //  -- the bodies of non-exported nonspecialized template functions
 315     //  -- the bodies of inline functions
 316     if ((IsInNonspecializedTemplate &&
 317          !(ManglingContextDecl && isa<ParmVarDecl>(ManglingContextDecl))) ||
 318         isInInlineFunction(CurContext)) {
 319       ManglingContextDecl = nullptr;
 320       return &Context.getManglingNumberContext(DC);
 321     }
 322
 323     ManglingContextDecl = nullptr;
 324     return nullptr;
 325
 326   case StaticDataMember:
 327     //  -- the initializers of nonspecialized static members of template classes
 328     if (!IsInNonspecializedTemplate) {
 329       ManglingContextDecl = nullptr;
 330       return nullptr;
 331     }
 332     // Fall through to get the current context.
 333
 334   case DataMember:
 335     //  -- the in-class initializers of class members
 336   case DefaultArgument:
 337     //  -- default arguments appearing in class definitions
 338     return &ExprEvalContexts.back().getMangleNumberingContext(Context);
 339   }
 340
 341   llvm_unreachable("unexpected context");
 342 }
 343
 344 MangleNumberingContext &
 345 Sema::ExpressionEvaluationContextRecord::getMangleNumberingContext(
 346     ASTContext &Ctx) {
 347   assert(ManglingContextDecl && "Need to have a context declaration");
 348   if (!MangleNumbering)
 349     MangleNumbering = Ctx.createMangleNumberingContext();
 350   return *MangleNumbering;
 351 }
 352
 353 CXXMethodDecl *Sema::startLambdaDefinition(CXXRecordDecl *Class,
 354                                            SourceRange IntroducerRange,
 355                                            TypeSourceInfo *MethodTypeInfo,
 356                                            SourceLocation EndLoc,
 357                                            ArrayRef<ParmVarDecl *> Params) {
 358   QualType MethodType = MethodTypeInfo->getType();
 359   TemplateParameterList *TemplateParams =
 360             getGenericLambdaTemplateParameterList(getCurLambda(), *this);
 361   // If a lambda appears in a dependent context or is a generic lambda (has
 362   // template parameters) and has an 'auto' return type, deduce it to a
 363   // dependent type.
 364   if (Class->isDependentContext() || TemplateParams) {
 365     const FunctionProtoType *FPT = MethodType->castAs<FunctionProtoType>();
 366     QualType Result = FPT->getReturnType();
 367     if (Result->isUndeducedType()) {
 368       Result = SubstAutoType(Result, Context.DependentTy);
 369       MethodType = Context.getFunctionType(Result, FPT->getParamTypes(),
 370                                            FPT->getExtProtoInfo());
 371     }
 372   }
 373
 374   // C++11 [expr.prim.lambda]p5:
 375   //   The closure type for a lambda-expression has a public inline function
 376   //   call operator (13.5.4) whose parameters and return type are described by
 377   //   the lambda-expression's parameter-declaration-clause and
 378   //   trailing-return-type respectively.
 379   DeclarationName MethodName
 380     = Context.DeclarationNames.getCXXOperatorName(OO_Call);
 381   DeclarationNameLoc MethodNameLoc;
 382   MethodNameLoc.CXXOperatorName.BeginOpNameLoc
 383     = IntroducerRange.getBegin().getRawEncoding();
 384   MethodNameLoc.CXXOperatorName.EndOpNameLoc
 385     = IntroducerRange.getEnd().getRawEncoding();
 386   CXXMethodDecl *Method
 387     = CXXMethodDecl::Create(Context, Class, EndLoc,
 388                             DeclarationNameInfo(MethodName,
 389                                                 IntroducerRange.getBegin(),
 390                                                 MethodNameLoc),
 391                             MethodType, MethodTypeInfo,
 392                             SC_None,
 393                             /*isInline=*/true,
 394                             /*isConstExpr=*/false,
 395                             EndLoc);
 396   Method->setAccess(AS_public);
 397
 398   // Temporarily set the lexical declaration context to the current
 399   // context, so that the Scope stack matches the lexical nesting.
 400   Method->setLexicalDeclContext(CurContext);
 401   // Create a function template if we have a template parameter list
 402   FunctionTemplateDecl *const TemplateMethod = TemplateParams ?
 403             FunctionTemplateDecl::Create(Context, Class,
 404                                          Method->getLocation(), MethodName,
 405                                          TemplateParams,
 406                                          Method) : nullptr;
 407   if (TemplateMethod) {
 408     TemplateMethod->setLexicalDeclContext(CurContext);
 409     TemplateMethod->setAccess(AS_public);
 410     Method->setDescribedFunctionTemplate(TemplateMethod);
 411   }
 412
 413   // Add parameters.
 414   if (!Params.empty()) {
 415     Method->setParams(Params);
 416     CheckParmsForFunctionDef(const_cast<ParmVarDecl **>(Params.begin()),
 417                              const_cast<ParmVarDecl **>(Params.end()),
 418                              /*CheckParameterNames=*/false);
 419
 420     for (auto P : Method->params())
 421       P->setOwningFunction(Method);
 422   }
 423
 424   Decl *ManglingContextDecl;
 425   if (MangleNumberingContext *MCtx =
 426           getCurrentMangleNumberContext(Class->getDeclContext(),
 427                                         ManglingContextDecl)) {
 428     unsigned ManglingNumber = MCtx->getManglingNumber(Method);
 429     Class->setLambdaMangling(ManglingNumber, ManglingContextDecl);
 430   }
 431
 432   return Method;
 433 }
 434
 435 void Sema::buildLambdaScope(LambdaScopeInfo *LSI,
 436                                         CXXMethodDecl *CallOperator,
 437                                         SourceRange IntroducerRange,
 438                                         LambdaCaptureDefault CaptureDefault,
 439                                         SourceLocation CaptureDefaultLoc,
 440                                         bool ExplicitParams,
 441                                         bool ExplicitResultType,
 442                                         bool Mutable) {
 443   LSI->CallOperator = CallOperator;
 444   CXXRecordDecl *LambdaClass = CallOperator->getParent();
 445   LSI->Lambda = LambdaClass;
 446   if (CaptureDefault == LCD_ByCopy)
 447     LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByval;
 448   else if (CaptureDefault == LCD_ByRef)
 449     LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByref;
 450   LSI->CaptureDefaultLoc = CaptureDefaultLoc;
 451   LSI->IntroducerRange = IntroducerRange;
 452   LSI->ExplicitParams = ExplicitParams;
 453   LSI->Mutable = Mutable;
 454
 455   if (ExplicitResultType) {
 456     LSI->ReturnType = CallOperator->getReturnType();
 457
 458     if (!LSI->ReturnType->isDependentType() &&
 459         !LSI->ReturnType->isVoidType()) {
 460       if (RequireCompleteType(CallOperator->getLocStart(), LSI->ReturnType,
 461                               diag::err_lambda_incomplete_result)) {
 462         // Do nothing.
 463       }
 464     }
 465   } else {
 466     LSI->HasImplicitReturnType = true;
 467   }
 468 }
 469
 470 void Sema::finishLambdaExplicitCaptures(LambdaScopeInfo *LSI) {
 471   LSI->finishedExplicitCaptures();
 472 }
 473
 474 void Sema::addLambdaParameters(CXXMethodDecl *CallOperator, Scope *CurScope) {
 475   // Introduce our parameters into the function scope
 476   for (unsigned p = 0, NumParams = CallOperator->getNumParams();
 477        p < NumParams; ++p) {
 478     ParmVarDecl *Param = CallOperator->getParamDecl(p);
 479
 480     // If this has an identifier, add it to the scope stack.
 481     if (CurScope && Param->getIdentifier()) {
 482       CheckShadow(CurScope, Param);
 483
 484       PushOnScopeChains(Param, CurScope);
 485     }
 486   }
 487 }
 488
 489 /// If this expression is an enumerator-like expression of some type
 490 /// T, return the type T; otherwise, return null.
 491 ///
 492 /// Pointer comparisons on the result here should always work because
 493 /// it's derived from either the parent of an EnumConstantDecl
 494 /// (i.e. the definition) or the declaration returned by
 495 /// EnumType::getDecl() (i.e. the definition).
 496 static EnumDecl *findEnumForBlockReturn(Expr *E) {
 497   // An expression is an enumerator-like expression of type T if,
 498   // ignoring parens and parens-like expressions:
 499   E = E->IgnoreParens();
 500
 501   //  - it is an enumerator whose enum type is T or
 502   if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
 503     if (EnumConstantDecl *D
 504           = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
 505       return cast<EnumDecl>(D->getDeclContext());
 506     }
 507     return nullptr;
 508   }
 509
 510   //  - it is a comma expression whose RHS is an enumerator-like
 511   //    expression of type T or
 512   if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
 513     if (BO->getOpcode() == BO_Comma)
 514       return findEnumForBlockReturn(BO->getRHS());
 515     return nullptr;
 516   }
 517
 518   //  - it is a statement-expression whose value expression is an
 519   //    enumerator-like expression of type T or
 520   if (StmtExpr *SE = dyn_cast<StmtExpr>(E)) {
 521     if (Expr *last = dyn_cast_or_null<Expr>(SE->getSubStmt()->body_back()))
 522       return findEnumForBlockReturn(last);
 523     return nullptr;
 524   }
 525
 526   //   - it is a ternary conditional operator (not the GNU ?:
 527   //     extension) whose second and third operands are
 528   //     enumerator-like expressions of type T or
 529   if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
 530     if (EnumDecl *ED = findEnumForBlockReturn(CO->getTrueExpr()))
 531       if (ED == findEnumForBlockReturn(CO->getFalseExpr()))
 532         return ED;
 533     return nullptr;
 534   }
 535
 536   // (implicitly:)
 537   //   - it is an implicit integral conversion applied to an
 538   //     enumerator-like expression of type T or
 539   if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
 540     // We can sometimes see integral conversions in valid
 541     // enumerator-like expressions.
 542     if (ICE->getCastKind() == CK_IntegralCast)
 543       return findEnumForBlockReturn(ICE->getSubExpr());
 544
 545     // Otherwise, just rely on the type.
 546   }
 547
 548   //   - it is an expression of that formal enum type.
 549   if (const EnumType *ET = E->getType()->getAs<EnumType>()) {
 550     return ET->getDecl();
 551   }
 552
 553   // Otherwise, nope.
 554   return nullptr;
 555 }
 556
 557 /// Attempt to find a type T for which the returned expression of the
 558 /// given statement is an enumerator-like expression of that type.
 559 static EnumDecl *findEnumForBlockReturn(ReturnStmt *ret) {
 560   if (Expr *retValue = ret->getRetValue())
 561     return findEnumForBlockReturn(retValue);
 562   return nullptr;
 563 }
 564
 565 /// Attempt to find a common type T for which all of the returned
 566 /// expressions in a block are enumerator-like expressions of that
 567 /// type.
 568 static EnumDecl *findCommonEnumForBlockReturns(ArrayRef<ReturnStmt*> returns) {
 569   ArrayRef<ReturnStmt*>::iterator i = returns.begin(), e = returns.end();
 570
 571   // Try to find one for the first return.
 572   EnumDecl *ED = findEnumForBlockReturn(*i);
 573   if (!ED) return nullptr;
 574
 575   // Check that the rest of the returns have the same enum.
 576   for (++i; i != e; ++i) {
 577     if (findEnumForBlockReturn(*i) != ED)
 578       return nullptr;
 579   }
 580
 581   // Never infer an anonymous enum type.
 582   if (!ED->hasNameForLinkage()) return nullptr;
 583
 584   return ED;
 585 }
 586
 587 /// Adjust the given return statements so that they formally return
 588 /// the given type.  It should require, at most, an IntegralCast.
 589 static void adjustBlockReturnsToEnum(Sema &S, ArrayRef<ReturnStmt*> returns,
 590                                      QualType returnType) {
 591   for (ArrayRef<ReturnStmt*>::iterator
 592          i = returns.begin(), e = returns.end(); i != e; ++i) {
 593     ReturnStmt *ret = *i;
 594     Expr *retValue = ret->getRetValue();
 595     if (S.Context.hasSameType(retValue->getType(), returnType))
 596       continue;
 597
 598     // Right now we only support integral fixup casts.
 599     assert(returnType->isIntegralOrUnscopedEnumerationType());
 600     assert(retValue->getType()->isIntegralOrUnscopedEnumerationType());
 601
 602     ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(retValue);
 603
 604     Expr *E = (cleanups ? cleanups->getSubExpr() : retValue);
 605     E = ImplicitCastExpr::Create(S.Context, returnType, CK_IntegralCast,
 606                                  E, /*base path*/ nullptr, VK_RValue);
 607     if (cleanups) {
 608       cleanups->setSubExpr(E);
 609     } else {
 610       ret->setRetValue(E);
 611     }
 612   }
 613 }
 614
 615 void Sema::deduceClosureReturnType(CapturingScopeInfo &CSI) {
 616   assert(CSI.HasImplicitReturnType);
 617   // If it was ever a placeholder, it had to been deduced to DependentTy.
 618   assert(CSI.ReturnType.isNull() || !CSI.ReturnType->isUndeducedType());
 619
 620   // C++ Core Issue #975, proposed resolution:
 621   //   If a lambda-expression does not include a trailing-return-type,
 622   //   it is as if the trailing-return-type denotes the following type:
 623   //     - if there are no return statements in the compound-statement,
 624   //       or all return statements return either an expression of type
 625   //       void or no expression or braced-init-list, the type void;
 626   //     - otherwise, if all return statements return an expression
 627   //       and the types of the returned expressions after
 628   //       lvalue-to-rvalue conversion (4.1 [conv.lval]),
 629   //       array-to-pointer conversion (4.2 [conv.array]), and
 630   //       function-to-pointer conversion (4.3 [conv.func]) are the
 631   //       same, that common type;
 632   //     - otherwise, the program is ill-formed.
 633   //
 634   // In addition, in blocks in non-C++ modes, if all of the return
 635   // statements are enumerator-like expressions of some type T, where
 636   // T has a name for linkage, then we infer the return type of the
 637   // block to be that type.
 638
 639   // First case: no return statements, implicit void return type.
 640   ASTContext &Ctx = getASTContext();
 641   if (CSI.Returns.empty()) {
 642     // It's possible there were simply no /valid/ return statements.
 643     // In this case, the first one we found may have at least given us a type.
 644     if (CSI.ReturnType.isNull())
 645       CSI.ReturnType = Ctx.VoidTy;
 646     return;
 647   }
 648
 649   // Second case: at least one return statement has dependent type.
 650   // Delay type checking until instantiation.
 651   assert(!CSI.ReturnType.isNull() && "We should have a tentative return type.");
 652   if (CSI.ReturnType->isDependentType())
 653     return;
 654
 655   // Try to apply the enum-fuzz rule.
 656   if (!getLangOpts().CPlusPlus) {
 657     assert(isa<BlockScopeInfo>(CSI));
 658     const EnumDecl *ED = findCommonEnumForBlockReturns(CSI.Returns);
 659     if (ED) {
 660       CSI.ReturnType = Context.getTypeDeclType(ED);
 661       adjustBlockReturnsToEnum(*this, CSI.Returns, CSI.ReturnType);
 662       return;
 663     }
 664   }
 665
 666   // Third case: only one return statement. Don't bother doing extra work!
 667   SmallVectorImpl<ReturnStmt*>::iterator I = CSI.Returns.begin(),
 668                                          E = CSI.Returns.end();
 669   if (I+1 == E)
 670     return;
 671
 672   // General case: many return statements.
 673   // Check that they all have compatible return types.
 674
 675   // We require the return types to strictly match here.
 676   // Note that we've already done the required promotions as part of
 677   // processing the return statement.
 678   for (; I != E; ++I) {
 679     const ReturnStmt *RS = *I;
 680     const Expr *RetE = RS->getRetValue();
 681
 682     QualType ReturnType = (RetE ? RetE->getType() : Context.VoidTy);
 683     if (Context.hasSameType(ReturnType, CSI.ReturnType))
 684       continue;
 685
 686     // FIXME: This is a poor diagnostic for ReturnStmts without expressions.
 687     // TODO: It's possible that the *first* return is the divergent one.
 688     Diag(RS->getLocStart(),
 689          diag::err_typecheck_missing_return_type_incompatible)
 690       << ReturnType << CSI.ReturnType
 691       << isa<LambdaScopeInfo>(CSI);
 692     // Continue iterating so that we keep emitting diagnostics.
 693   }
 694 }
 695
 696 QualType Sema::performLambdaInitCaptureInitialization(SourceLocation Loc,
 697                                                       bool ByRef,
 698                                                       IdentifierInfo *Id,
 699                                                       Expr *&Init) {
 700
 701   // We do not need to distinguish between direct-list-initialization
 702   // and copy-list-initialization here, because we will always deduce
 703   // std::initializer_list<T>, and direct- and copy-list-initialization
 704   // always behave the same for such a type.
 705   // FIXME: We should model whether an '=' was present.
 706   const bool IsDirectInit = isa<ParenListExpr>(Init) || isa<InitListExpr>(Init);
 707
 708   // Create an 'auto' or 'auto&' TypeSourceInfo that we can use to
 709   // deduce against.
 710   QualType DeductType = Context.getAutoDeductType();
 711   TypeLocBuilder TLB;
 712   TLB.pushTypeSpec(DeductType).setNameLoc(Loc);
 713   if (ByRef) {
 714     DeductType = BuildReferenceType(DeductType, true, Loc, Id);
 715     assert(!DeductType.isNull() && "can't build reference to auto");
 716     TLB.push<ReferenceTypeLoc>(DeductType).setSigilLoc(Loc);
 717   }
 718   TypeSourceInfo *TSI = TLB.getTypeSourceInfo(Context, DeductType);
 719
 720   // Are we a non-list direct initialization?
 721   ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init);
 722
 723   Expr *DeduceInit = Init;
 724   // Initializer could be a C++ direct-initializer. Deduction only works if it
 725   // contains exactly one expression.
 726   if (CXXDirectInit) {
 727     if (CXXDirectInit->getNumExprs() == 0) {
 728       Diag(CXXDirectInit->getLocStart(), diag::err_init_capture_no_expression)
 729           << DeclarationName(Id) << TSI->getType() << Loc;
 730       return QualType();
 731     } else if (CXXDirectInit->getNumExprs() > 1) {
 732       Diag(CXXDirectInit->getExpr(1)->getLocStart(),
 733            diag::err_init_capture_multiple_expressions)
 734           << DeclarationName(Id) << TSI->getType() << Loc;
 735       return QualType();
 736     } else {
 737       DeduceInit = CXXDirectInit->getExpr(0);
 738       if (isa<InitListExpr>(DeduceInit))
 739         Diag(CXXDirectInit->getLocStart(), diag::err_init_capture_paren_braces)
 740           << DeclarationName(Id) << Loc;
 741     }
 742   }
 743
 744   // Now deduce against the initialization expression and store the deduced
 745   // type below.
 746   QualType DeducedType;
 747   if (DeduceAutoType(TSI, DeduceInit, DeducedType) == DAR_Failed) {
 748     if (isa<InitListExpr>(Init))
 749       Diag(Loc, diag::err_init_capture_deduction_failure_from_init_list)
 750           << DeclarationName(Id)
 751           << (DeduceInit->getType().isNull() ? TSI->getType()
 752                                              : DeduceInit->getType())
 753           << DeduceInit->getSourceRange();
 754     else
 755       Diag(Loc, diag::err_init_capture_deduction_failure)
 756           << DeclarationName(Id) << TSI->getType()
 757           << (DeduceInit->getType().isNull() ? TSI->getType()
 758                                              : DeduceInit->getType())
 759           << DeduceInit->getSourceRange();
 760   }
 761   if (DeducedType.isNull())
 762     return QualType();
 763
 764   // Perform initialization analysis and ensure any implicit conversions
 765   // (such as lvalue-to-rvalue) are enforced.
 766   InitializedEntity Entity =
 767       InitializedEntity::InitializeLambdaCapture(Id, DeducedType, Loc);
 768   InitializationKind Kind =
 769       IsDirectInit
 770           ? (CXXDirectInit ? InitializationKind::CreateDirect(
 771                                  Loc, Init->getLocStart(), Init->getLocEnd())
 772                            : InitializationKind::CreateDirectList(Loc))
 773           : InitializationKind::CreateCopy(Loc, Init->getLocStart());
 774
 775   MultiExprArg Args = Init;
 776   if (CXXDirectInit)
 777     Args =
 778         MultiExprArg(CXXDirectInit->getExprs(), CXXDirectInit->getNumExprs());
 779   QualType DclT;
 780   InitializationSequence InitSeq(*this, Entity, Kind, Args);
 781   ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT);
 782
 783   if (Result.isInvalid())
 784     return QualType();
 785   Init = Result.getAs<Expr>();
 786
 787   // The init-capture initialization is a full-expression that must be
 788   // processed as one before we enter the declcontext of the lambda's
 789   // call-operator.
 790   Result = ActOnFinishFullExpr(Init, Loc, /*DiscardedValue*/ false,
 791                                /*IsConstexpr*/ false,
 792                                /*IsLambdaInitCaptureInitalizer*/ true);
 793   if (Result.isInvalid())
 794     return QualType();
 795
 796   Init = Result.getAs<Expr>();
 797   return DeducedType;
 798 }
 799
 800 VarDecl *Sema::createLambdaInitCaptureVarDecl(SourceLocation Loc,
 801     QualType InitCaptureType, IdentifierInfo *Id, Expr *Init) {
 802
 803   TypeSourceInfo *TSI = Context.getTrivialTypeSourceInfo(InitCaptureType,
 804       Loc);
 805   // Create a dummy variable representing the init-capture. This is not actually
 806   // used as a variable, and only exists as a way to name and refer to the
 807   // init-capture.
 808   // FIXME: Pass in separate source locations for '&' and identifier.
 809   VarDecl *NewVD = VarDecl::Create(Context, CurContext, Loc,
 810                                    Loc, Id, InitCaptureType, TSI, SC_Auto);
 811   NewVD->setInitCapture(true);
 812   NewVD->setReferenced(true);
 813   NewVD->markUsed(Context);
 814   NewVD->setInit(Init);
 815   return NewVD;
 816
 817 }
 818
 819 FieldDecl *Sema::buildInitCaptureField(LambdaScopeInfo *LSI, VarDecl *Var) {
 820   FieldDecl *Field = FieldDecl::Create(
 821       Context, LSI->Lambda, Var->getLocation(), Var->getLocation(),
 822       nullptr, Var->getType(), Var->getTypeSourceInfo(), nullptr, false,
 823       ICIS_NoInit);
 824   Field->setImplicit(true);
 825   Field->setAccess(AS_private);
 826   LSI->Lambda->addDecl(Field);
 827
 828   LSI->addCapture(Var, /*isBlock*/false, Var->getType()->isReferenceType(),
 829                   /*isNested*/false, Var->getLocation(), SourceLocation(),
 830                   Var->getType(), Var->getInit());
 831   return Field;
 832 }
 833
 834 void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
 835                   Declarator &ParamInfo, Scope *CurScope) {
 836   // Determine if we're within a context where we know that the lambda will
 837   // be dependent, because there are template parameters in scope.
 838   bool KnownDependent = false;
 839   LambdaScopeInfo *const LSI = getCurLambda();
 840   assert(LSI && "LambdaScopeInfo should be on stack!");
 841   TemplateParameterList *TemplateParams =
 842             getGenericLambdaTemplateParameterList(LSI, *this);
 843
 844   if (Scope *TmplScope = CurScope->getTemplateParamParent()) {
 845     // Since we have our own TemplateParams, so check if an outer scope
 846     // has template params, only then are we in a dependent scope.
 847     if (TemplateParams)  {
 848       TmplScope = TmplScope->getParent();
 849       TmplScope = TmplScope ? TmplScope->getTemplateParamParent() : nullptr;
 850     }
 851     if (TmplScope && !TmplScope->decl_empty())
 852       KnownDependent = true;
 853   }
 854   // Determine the signature of the call operator.
 855   TypeSourceInfo *MethodTyInfo;
 856   bool ExplicitParams = true;
 857   bool ExplicitResultType = true;
 858   bool ContainsUnexpandedParameterPack = false;
 859   SourceLocation EndLoc;
 860   SmallVector<ParmVarDecl *, 8> Params;
 861   if (ParamInfo.getNumTypeObjects() == 0) {
 862     // C++11 [expr.prim.lambda]p4:
 863     //   If a lambda-expression does not include a lambda-declarator, it is as
 864     //   if the lambda-declarator were ().
 865     FunctionProtoType::ExtProtoInfo EPI(Context.getDefaultCallingConvention(
 866         /*IsVariadic=*/false, /*IsCXXMethod=*/true));
 867     EPI.HasTrailingReturn = true;
 868     EPI.TypeQuals |= DeclSpec::TQ_const;
 869     // C++1y [expr.prim.lambda]:
 870     //   The lambda return type is 'auto', which is replaced by the
 871     //   trailing-return type if provided and/or deduced from 'return'
 872     //   statements
 873     // We don't do this before C++1y, because we don't support deduced return
 874     // types there.
 875     QualType DefaultTypeForNoTrailingReturn =
 876         getLangOpts().CPlusPlus1y ? Context.getAutoDeductType()
 877                                   : Context.DependentTy;
 878     QualType MethodTy =
 879         Context.getFunctionType(DefaultTypeForNoTrailingReturn, None, EPI);
 880     MethodTyInfo = Context.getTrivialTypeSourceInfo(MethodTy);
 881     ExplicitParams = false;
 882     ExplicitResultType = false;
 883     EndLoc = Intro.Range.getEnd();
 884   } else {
 885     assert(ParamInfo.isFunctionDeclarator() &&
 886            "lambda-declarator is a function");
 887     DeclaratorChunk::FunctionTypeInfo &FTI = ParamInfo.getFunctionTypeInfo();
 888
 889     // C++11 [expr.prim.lambda]p5:
 890     //   This function call operator is declared const (9.3.1) if and only if
 891     //   the lambda-expression's parameter-declaration-clause is not followed
 892     //   by mutable. It is neither virtual nor declared volatile. [...]
 893     if (!FTI.hasMutableQualifier())
 894       FTI.TypeQuals |= DeclSpec::TQ_const;
 895
 896     MethodTyInfo = GetTypeForDeclarator(ParamInfo, CurScope);
 897     assert(MethodTyInfo && "no type from lambda-declarator");
 898     EndLoc = ParamInfo.getSourceRange().getEnd();
 899
 900     ExplicitResultType = FTI.hasTrailingReturnType();
 901
 902     if (FTIHasNonVoidParameters(FTI)) {
 903       Params.reserve(FTI.NumParams);
 904       for (unsigned i = 0, e = FTI.NumParams; i != e; ++i)
 905         Params.push_back(cast<ParmVarDecl>(FTI.Params[i].Param));
 906     }
 907
 908     // Check for unexpanded parameter packs in the method type.
 909     if (MethodTyInfo->getType()->containsUnexpandedParameterPack())
 910       ContainsUnexpandedParameterPack = true;
 911   }
 912
 913   CXXRecordDecl *Class = createLambdaClosureType(Intro.Range, MethodTyInfo,
 914                                                  KnownDependent, Intro.Default);
 915
 916   CXXMethodDecl *Method = startLambdaDefinition(Class, Intro.Range,
 917                                                 MethodTyInfo, EndLoc, Params);
 918   if (ExplicitParams)
 919     CheckCXXDefaultArguments(Method);
 920
 921   // Attributes on the lambda apply to the method.
 922   ProcessDeclAttributes(CurScope, Method, ParamInfo);
 923
 924   // Introduce the function call operator as the current declaration context.
 925   PushDeclContext(CurScope, Method);
 926
 927   // Build the lambda scope.
 928   buildLambdaScope(LSI, Method,
 929                        Intro.Range,
 930                        Intro.Default, Intro.DefaultLoc,
 931                        ExplicitParams,
 932                        ExplicitResultType,
 933                        !Method->isConst());
 934
 935   // C++11 [expr.prim.lambda]p9:
 936   //   A lambda-expression whose smallest enclosing scope is a block scope is a
 937   //   local lambda expression; any other lambda expression shall not have a
 938   //   capture-default or simple-capture in its lambda-introducer.
 939   //
 940   // For simple-captures, this is covered by the check below that any named
 941   // entity is a variable that can be captured.
 942   //
 943   // For DR1632, we also allow a capture-default in any context where we can
 944   // odr-use 'this' (in particular, in a default initializer for a non-static
 945   // data member).
 946   if (Intro.Default != LCD_None && !Class->getParent()->isFunctionOrMethod() &&
 947       (getCurrentThisType().isNull() ||
 948        CheckCXXThisCapture(SourceLocation(), /*Explicit*/true,
 949                            /*BuildAndDiagnose*/false)))
 950     Diag(Intro.DefaultLoc, diag::err_capture_default_non_local);
 951
 952   // Distinct capture names, for diagnostics.
 953   llvm::SmallSet<IdentifierInfo*, 8> CaptureNames;
 954
 955   // Handle explicit captures.
 956   SourceLocation PrevCaptureLoc
 957     = Intro.Default == LCD_None? Intro.Range.getBegin() : Intro.DefaultLoc;
 958   for (auto C = Intro.Captures.begin(), E = Intro.Captures.end(); C != E;
 959        PrevCaptureLoc = C->Loc, ++C) {
 960     if (C->Kind == LCK_This) {
 961       // C++11 [expr.prim.lambda]p8:
 962       //   An identifier or this shall not appear more than once in a
 963       //   lambda-capture.
 964       if (LSI->isCXXThisCaptured()) {
 965         Diag(C->Loc, diag::err_capture_more_than_once)
 966             << "'this'" << SourceRange(LSI->getCXXThisCapture().getLocation())
 967             << FixItHint::CreateRemoval(
 968                    SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
 969         continue;
 970       }
 971
 972       // C++11 [expr.prim.lambda]p8:
 973       //   If a lambda-capture includes a capture-default that is =, the
 974       //   lambda-capture shall not contain this [...].
 975       if (Intro.Default == LCD_ByCopy) {
 976         Diag(C->Loc, diag::err_this_capture_with_copy_default)
 977             << FixItHint::CreateRemoval(
 978                 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
 979         continue;
 980       }
 981
 982       // C++11 [expr.prim.lambda]p12:
 983       //   If this is captured by a local lambda expression, its nearest
 984       //   enclosing function shall be a non-static member function.
 985       QualType ThisCaptureType = getCurrentThisType();
 986       if (ThisCaptureType.isNull()) {
 987         Diag(C->Loc, diag::err_this_capture) << true;
 988         continue;
 989       }
 990
 991       CheckCXXThisCapture(C->Loc, /*Explicit=*/true);
 992       continue;
 993     }
 994
 995     assert(C->Id && "missing identifier for capture");
 996
 997     if (C->Init.isInvalid())
 998       continue;
 999
1000     VarDecl *Var = nullptr;
1001     if (C->Init.isUsable()) {
1002       Diag(C->Loc, getLangOpts().CPlusPlus1y
1003                        ? diag::warn_cxx11_compat_init_capture
1004                        : diag::ext_init_capture);
1005
1006       if (C->Init.get()->containsUnexpandedParameterPack())
1007         ContainsUnexpandedParameterPack = true;
1008       // If the initializer expression is usable, but the InitCaptureType
1009       // is not, then an error has occurred - so ignore the capture for now.
1010       // for e.g., [n{0}] { }; <-- if no <initializer_list> is included.
1011       // FIXME: we should create the init capture variable and mark it invalid
1012       // in this case.
1013       if (C->InitCaptureType.get().isNull())
1014         continue;
1015       Var = createLambdaInitCaptureVarDecl(C->Loc, C->InitCaptureType.get(),
1016             C->Id, C->Init.get());
1017       // C++1y [expr.prim.lambda]p11:
1018       //   An init-capture behaves as if it declares and explicitly
1019       //   captures a variable [...] whose declarative region is the
1020       //   lambda-expression's compound-statement
1021       if (Var)
1022         PushOnScopeChains(Var, CurScope, false);
1023     } else {
1024       // C++11 [expr.prim.lambda]p8:
1025       //   If a lambda-capture includes a capture-default that is &, the
1026       //   identifiers in the lambda-capture shall not be preceded by &.
1027       //   If a lambda-capture includes a capture-default that is =, [...]
1028       //   each identifier it contains shall be preceded by &.
1029       if (C->Kind == LCK_ByRef && Intro.Default == LCD_ByRef) {
1030         Diag(C->Loc, diag::err_reference_capture_with_reference_default)
1031             << FixItHint::CreateRemoval(
1032                 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
1033         continue;
1034       } else if (C->Kind == LCK_ByCopy && Intro.Default == LCD_ByCopy) {
1035         Diag(C->Loc, diag::err_copy_capture_with_copy_default)
1036             << FixItHint::CreateRemoval(
1037                 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
1038         continue;
1039       }
1040
1041       // C++11 [expr.prim.lambda]p10:
1042       //   The identifiers in a capture-list are looked up using the usual
1043       //   rules for unqualified name lookup (3.4.1)
1044       DeclarationNameInfo Name(C->Id, C->Loc);
1045       LookupResult R(*this, Name, LookupOrdinaryName);
1046       LookupName(R, CurScope);
1047       if (R.isAmbiguous())
1048         continue;
1049       if (R.empty()) {
1050         // FIXME: Disable corrections that would add qualification?
1051         CXXScopeSpec ScopeSpec;
1052         DeclFilterCCC<VarDecl> Validator;
1053         if (DiagnoseEmptyLookup(CurScope, ScopeSpec, R, Validator))
1054           continue;
1055       }
1056
1057       Var = R.getAsSingle<VarDecl>();
1058       if (Var && DiagnoseUseOfDecl(Var, C->Loc))
1059         continue;
1060     }
1061
1062     // C++11 [expr.prim.lambda]p8:
1063     //   An identifier or this shall not appear more than once in a
1064     //   lambda-capture.
1065     if (!CaptureNames.insert(C->Id)) {
1066       if (Var && LSI->isCaptured(Var)) {
1067         Diag(C->Loc, diag::err_capture_more_than_once)
1068             << C->Id << SourceRange(LSI->getCapture(Var).getLocation())
1069             << FixItHint::CreateRemoval(
1070                    SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
1071       } else
1072         // Previous capture captured something different (one or both was
1073         // an init-cpature): no fixit.
1074         Diag(C->Loc, diag::err_capture_more_than_once) << C->Id;
1075       continue;
1076     }
1077
1078     // C++11 [expr.prim.lambda]p10:
1079     //   [...] each such lookup shall find a variable with automatic storage
1080     //   duration declared in the reaching scope of the local lambda expression.
1081     // Note that the 'reaching scope' check happens in tryCaptureVariable().
1082     if (!Var) {
1083       Diag(C->Loc, diag::err_capture_does_not_name_variable) << C->Id;
1084       continue;
1085     }
1086
1087     // Ignore invalid decls; they'll just confuse the code later.
1088     if (Var->isInvalidDecl())
1089       continue;
1090
1091     if (!Var->hasLocalStorage()) {
1092       Diag(C->Loc, diag::err_capture_non_automatic_variable) << C->Id;
1093       Diag(Var->getLocation(), diag::note_previous_decl) << C->Id;
1094       continue;
1095     }
1096
1097     // C++11 [expr.prim.lambda]p23:
1098     //   A capture followed by an ellipsis is a pack expansion (14.5.3).
1099     SourceLocation EllipsisLoc;
1100     if (C->EllipsisLoc.isValid()) {
1101       if (Var->isParameterPack()) {
1102         EllipsisLoc = C->EllipsisLoc;
1103       } else {
1104         Diag(C->EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
1105           << SourceRange(C->Loc);
1106
1107         // Just ignore the ellipsis.
1108       }
1109     } else if (Var->isParameterPack()) {
1110       ContainsUnexpandedParameterPack = true;
1111     }
1112
1113     if (C->Init.isUsable()) {
1114       buildInitCaptureField(LSI, Var);
1115     } else {
1116       TryCaptureKind Kind = C->Kind == LCK_ByRef ? TryCapture_ExplicitByRef :
1117                                                    TryCapture_ExplicitByVal;
1118       tryCaptureVariable(Var, C->Loc, Kind, EllipsisLoc);
1119     }
1120   }
1121   finishLambdaExplicitCaptures(LSI);
1122
1123   LSI->ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
1124
1125   // Add lambda parameters into scope.
1126   addLambdaParameters(Method, CurScope);
1127
1128   // Enter a new evaluation context to insulate the lambda from any
1129   // cleanups from the enclosing full-expression.
1130   PushExpressionEvaluationContext(PotentiallyEvaluated);
1131 }
1132
1133 void Sema::ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,
1134                             bool IsInstantiation) {
1135   LambdaScopeInfo *LSI = getCurLambda();
1136
1137   // Leave the expression-evaluation context.
1138   DiscardCleanupsInEvaluationContext();
1139   PopExpressionEvaluationContext();
1140
1141   // Leave the context of the lambda.
1142   if (!IsInstantiation)
1143     PopDeclContext();
1144
1145   // Finalize the lambda.
1146   CXXRecordDecl *Class = LSI->Lambda;
1147   Class->setInvalidDecl();
1148   SmallVector<Decl*, 4> Fields(Class->fields());
1149   ActOnFields(nullptr, Class->getLocation(), Class, Fields, SourceLocation(),
1150               SourceLocation(), nullptr);
1151   CheckCompletedCXXClass(Class);
1152
1153   PopFunctionScopeInfo();
1154 }
1155
1156 /// \brief Add a lambda's conversion to function pointer, as described in
1157 /// C++11 [expr.prim.lambda]p6.
1158 static void addFunctionPointerConversion(Sema &S,
1159                                          SourceRange IntroducerRange,
1160                                          CXXRecordDecl *Class,
1161                                          CXXMethodDecl *CallOperator) {
1162   // Add the conversion to function pointer.
1163   const FunctionProtoType *CallOpProto =
1164       CallOperator->getType()->getAs<FunctionProtoType>();
1165   const FunctionProtoType::ExtProtoInfo CallOpExtInfo =
1166       CallOpProto->getExtProtoInfo();
1167   QualType PtrToFunctionTy;
1168   QualType InvokerFunctionTy;
1169   {
1170     FunctionProtoType::ExtProtoInfo InvokerExtInfo = CallOpExtInfo;
1171     CallingConv CC = S.Context.getDefaultCallingConvention(
1172         CallOpProto->isVariadic(), /*IsCXXMethod=*/false);
1173     InvokerExtInfo.ExtInfo = InvokerExtInfo.ExtInfo.withCallingConv(CC);
1174     InvokerExtInfo.TypeQuals = 0;
1175     assert(InvokerExtInfo.RefQualifier == RQ_None &&
1176         "Lambda's call operator should not have a reference qualifier");
1177     InvokerFunctionTy =
1178         S.Context.getFunctionType(CallOpProto->getReturnType(),
1179                                   CallOpProto->getParamTypes(), InvokerExtInfo);
1180     PtrToFunctionTy = S.Context.getPointerType(InvokerFunctionTy);
1181   }
1182
1183   // Create the type of the conversion function.
1184   FunctionProtoType::ExtProtoInfo ConvExtInfo(
1185       S.Context.getDefaultCallingConvention(
1186       /*IsVariadic=*/false, /*IsCXXMethod=*/true));
1187   // The conversion function is always const.
1188   ConvExtInfo.TypeQuals = Qualifiers::Const;
1189   QualType ConvTy =
1190       S.Context.getFunctionType(PtrToFunctionTy, None, ConvExtInfo);
1191
1192   SourceLocation Loc = IntroducerRange.getBegin();
1193   DeclarationName ConversionName
1194     = S.Context.DeclarationNames.getCXXConversionFunctionName(
1195         S.Context.getCanonicalType(PtrToFunctionTy));
1196   DeclarationNameLoc ConvNameLoc;
1197   // Construct a TypeSourceInfo for the conversion function, and wire
1198   // all the parameters appropriately for the FunctionProtoTypeLoc
1199   // so that everything works during transformation/instantiation of
1200   // generic lambdas.
1201   // The main reason for wiring up the parameters of the conversion
1202   // function with that of the call operator is so that constructs
1203   // like the following work:
1204   // auto L = [](auto b) {                <-- 1
1205   //   return [](auto a) -> decltype(a) { <-- 2
1206   //      return a;
1207   //   };
1208   // };
1209   // int (*fp)(int) = L(5);
1210   // Because the trailing return type can contain DeclRefExprs that refer
1211   // to the original call operator's variables, we hijack the call
1212   // operators ParmVarDecls below.
1213   TypeSourceInfo *ConvNamePtrToFunctionTSI =
1214       S.Context.getTrivialTypeSourceInfo(PtrToFunctionTy, Loc);
1215   ConvNameLoc.NamedType.TInfo = ConvNamePtrToFunctionTSI;
1216
1217   // The conversion function is a conversion to a pointer-to-function.
1218   TypeSourceInfo *ConvTSI = S.Context.getTrivialTypeSourceInfo(ConvTy, Loc);
1219   FunctionProtoTypeLoc ConvTL =
1220       ConvTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>();
1221   // Get the result of the conversion function which is a pointer-to-function.
1222   PointerTypeLoc PtrToFunctionTL =
1223       ConvTL.getReturnLoc().getAs<PointerTypeLoc>();
1224   // Do the same for the TypeSourceInfo that is used to name the conversion
1225   // operator.
1226   PointerTypeLoc ConvNamePtrToFunctionTL =
1227       ConvNamePtrToFunctionTSI->getTypeLoc().getAs<PointerTypeLoc>();
1228
1229   // Get the underlying function types that the conversion function will
1230   // be converting to (should match the type of the call operator).
1231   FunctionProtoTypeLoc CallOpConvTL =
1232       PtrToFunctionTL.getPointeeLoc().getAs<FunctionProtoTypeLoc>();
1233   FunctionProtoTypeLoc CallOpConvNameTL =
1234     ConvNamePtrToFunctionTL.getPointeeLoc().getAs<FunctionProtoTypeLoc>();
1235
1236   // Wire up the FunctionProtoTypeLocs with the call operator's parameters.
1237   // These parameter's are essentially used to transform the name and
1238   // the type of the conversion operator.  By using the same parameters
1239   // as the call operator's we don't have to fix any back references that
1240   // the trailing return type of the call operator's uses (such as
1241   // decltype(some_type<decltype(a)>::type{} + decltype(a){}) etc.)
1242   // - we can simply use the return type of the call operator, and
1243   // everything should work.
1244   SmallVector<ParmVarDecl *, 4> InvokerParams;
1245   for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) {
1246     ParmVarDecl *From = CallOperator->getParamDecl(I);
1247
1248     InvokerParams.push_back(ParmVarDecl::Create(S.Context,
1249            // Temporarily add to the TU. This is set to the invoker below.
1250                                              S.Context.getTranslationUnitDecl(),
1251                                              From->getLocStart(),
1252                                              From->getLocation(),
1253                                              From->getIdentifier(),
1254                                              From->getType(),
1255                                              From->getTypeSourceInfo(),
1256                                              From->getStorageClass(),
1257                                              /*DefaultArg=*/nullptr));
1258     CallOpConvTL.setParam(I, From);
1259     CallOpConvNameTL.setParam(I, From);
1260   }
1261
1262   CXXConversionDecl *Conversion
1263     = CXXConversionDecl::Create(S.Context, Class, Loc,
1264                                 DeclarationNameInfo(ConversionName,
1265                                   Loc, ConvNameLoc),
1266                                 ConvTy,
1267                                 ConvTSI,
1268                                 /*isInline=*/true, /*isExplicit=*/false,
1269                                 /*isConstexpr=*/false,
1270                                 CallOperator->getBody()->getLocEnd());
1271   Conversion->setAccess(AS_public);
1272   Conversion->setImplicit(true);
1273
1274   if (Class->isGenericLambda()) {
1275     // Create a template version of the conversion operator, using the template
1276     // parameter list of the function call operator.
1277     FunctionTemplateDecl *TemplateCallOperator =
1278             CallOperator->getDescribedFunctionTemplate();
1279     FunctionTemplateDecl *ConversionTemplate =
1280                   FunctionTemplateDecl::Create(S.Context, Class,
1281                                       Loc, ConversionName,
1282                                       TemplateCallOperator->getTemplateParameters(),
1283                                       Conversion);
1284     ConversionTemplate->setAccess(AS_public);
1285     ConversionTemplate->setImplicit(true);
1286     Conversion->setDescribedFunctionTemplate(ConversionTemplate);
1287     Class->addDecl(ConversionTemplate);
1288   } else
1289     Class->addDecl(Conversion);
1290   // Add a non-static member function that will be the result of
1291   // the conversion with a certain unique ID.
1292   DeclarationName InvokerName = &S.Context.Idents.get(
1293                                                  getLambdaStaticInvokerName());
1294   // FIXME: Instead of passing in the CallOperator->getTypeSourceInfo()
1295   // we should get a prebuilt TrivialTypeSourceInfo from Context
1296   // using FunctionTy & Loc and get its TypeLoc as a FunctionProtoTypeLoc
1297   // then rewire the parameters accordingly, by hoisting up the InvokeParams
1298   // loop below and then use its Params to set Invoke->setParams(...) below.
1299   // This would avoid the 'const' qualifier of the calloperator from
1300   // contaminating the type of the invoker, which is currently adjusted
1301   // in SemaTemplateDeduction.cpp:DeduceTemplateArguments.  Fixing the
1302   // trailing return type of the invoker would require a visitor to rebuild
1303   // the trailing return type and adjusting all back DeclRefExpr's to refer
1304   // to the new static invoker parameters - not the call operator's.
1305   CXXMethodDecl *Invoke
1306     = CXXMethodDecl::Create(S.Context, Class, Loc,
1307                             DeclarationNameInfo(InvokerName, Loc),
1308                             InvokerFunctionTy,
1309                             CallOperator->getTypeSourceInfo(),
1310                             SC_Static, /*IsInline=*/true,
1311                             /*IsConstexpr=*/false,
1312                             CallOperator->getBody()->getLocEnd());
1313   for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I)
1314     InvokerParams[I]->setOwningFunction(Invoke);
1315   Invoke->setParams(InvokerParams);
1316   Invoke->setAccess(AS_private);
1317   Invoke->setImplicit(true);
1318   if (Class->isGenericLambda()) {
1319     FunctionTemplateDecl *TemplateCallOperator =
1320             CallOperator->getDescribedFunctionTemplate();
1321     FunctionTemplateDecl *StaticInvokerTemplate = FunctionTemplateDecl::Create(
1322                           S.Context, Class, Loc, InvokerName,
1323                           TemplateCallOperator->getTemplateParameters(),
1324                           Invoke);
1325     StaticInvokerTemplate->setAccess(AS_private);
1326     StaticInvokerTemplate->setImplicit(true);
1327     Invoke->setDescribedFunctionTemplate(StaticInvokerTemplate);
1328     Class->addDecl(StaticInvokerTemplate);
1329   } else
1330     Class->addDecl(Invoke);
1331 }
1332
1333 /// \brief Add a lambda's conversion to block pointer.
1334 static void addBlockPointerConversion(Sema &S,
1335                                       SourceRange IntroducerRange,
1336                                       CXXRecordDecl *Class,
1337                                       CXXMethodDecl *CallOperator) {
1338   const FunctionProtoType *Proto
1339     = CallOperator->getType()->getAs<FunctionProtoType>();
1340   QualType BlockPtrTy;
1341   {
1342     FunctionProtoType::ExtProtoInfo ExtInfo = Proto->getExtProtoInfo();
1343     ExtInfo.TypeQuals = 0;
1344     QualType FunctionTy = S.Context.getFunctionType(
1345         Proto->getReturnType(), Proto->getParamTypes(), ExtInfo);
1346     BlockPtrTy = S.Context.getBlockPointerType(FunctionTy);
1347   }
1348
1349   FunctionProtoType::ExtProtoInfo ExtInfo(S.Context.getDefaultCallingConvention(
1350       /*IsVariadic=*/false, /*IsCXXMethod=*/true));
1351   ExtInfo.TypeQuals = Qualifiers::Const;
1352   QualType ConvTy = S.Context.getFunctionType(BlockPtrTy, None, ExtInfo);
1353
1354   SourceLocation Loc = IntroducerRange.getBegin();
1355   DeclarationName Name
1356     = S.Context.DeclarationNames.getCXXConversionFunctionName(
1357         S.Context.getCanonicalType(BlockPtrTy));
1358   DeclarationNameLoc NameLoc;
1359   NameLoc.NamedType.TInfo = S.Context.getTrivialTypeSourceInfo(BlockPtrTy, Loc);
1360   CXXConversionDecl *Conversion
1361     = CXXConversionDecl::Create(S.Context, Class, Loc,
1362                                 DeclarationNameInfo(Name, Loc, NameLoc),
1363                                 ConvTy,
1364                                 S.Context.getTrivialTypeSourceInfo(ConvTy, Loc),
1365                                 /*isInline=*/true, /*isExplicit=*/false,
1366                                 /*isConstexpr=*/false,
1367                                 CallOperator->getBody()->getLocEnd());
1368   Conversion->setAccess(AS_public);
1369   Conversion->setImplicit(true);
1370   Class->addDecl(Conversion);
1371 }
1372
1373 ExprResult Sema::ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body,
1374                                  Scope *CurScope,
1375                                  bool IsInstantiation) {
1376   // Collect information from the lambda scope.
1377   SmallVector<LambdaCapture, 4> Captures;
1378   SmallVector<Expr *, 4> CaptureInits;
1379   LambdaCaptureDefault CaptureDefault;
1380   SourceLocation CaptureDefaultLoc;
1381   CXXRecordDecl *Class;
1382   CXXMethodDecl *CallOperator;
1383   SourceRange IntroducerRange;
1384   bool ExplicitParams;
1385   bool ExplicitResultType;
1386   bool LambdaExprNeedsCleanups;
1387   bool ContainsUnexpandedParameterPack;
1388   SmallVector<VarDecl *, 4> ArrayIndexVars;
1389   SmallVector<unsigned, 4> ArrayIndexStarts;
1390   {
1391     LambdaScopeInfo *LSI = getCurLambda();
1392     CallOperator = LSI->CallOperator;
1393     Class = LSI->Lambda;
1394     IntroducerRange = LSI->IntroducerRange;
1395     ExplicitParams = LSI->ExplicitParams;
1396     ExplicitResultType = !LSI->HasImplicitReturnType;
1397     LambdaExprNeedsCleanups = LSI->ExprNeedsCleanups;
1398     ContainsUnexpandedParameterPack = LSI->ContainsUnexpandedParameterPack;
1399     ArrayIndexVars.swap(LSI->ArrayIndexVars);
1400     ArrayIndexStarts.swap(LSI->ArrayIndexStarts);
1401
1402     // Translate captures.
1403     for (unsigned I = 0, N = LSI->Captures.size(); I != N; ++I) {
1404       LambdaScopeInfo::Capture From = LSI->Captures[I];
1405       assert(!From.isBlockCapture() && "Cannot capture __block variables");
1406       bool IsImplicit = I >= LSI->NumExplicitCaptures;
1407
1408       // Handle 'this' capture.
1409       if (From.isThisCapture()) {
1410         Captures.push_back(
1411             LambdaCapture(From.getLocation(), IsImplicit, LCK_This));
1412         CaptureInits.push_back(new (Context) CXXThisExpr(From.getLocation(),
1413                                                          getCurrentThisType(),
1414                                                          /*isImplicit=*/true));
1415         continue;
1416       }
1417
1418       VarDecl *Var = From.getVariable();
1419       LambdaCaptureKind Kind = From.isCopyCapture()? LCK_ByCopy : LCK_ByRef;
1420       Captures.push_back(LambdaCapture(From.getLocation(), IsImplicit, Kind,
1421                                        Var, From.getEllipsisLoc()));
1422       CaptureInits.push_back(From.getInitExpr());
1423     }
1424
1425     switch (LSI->ImpCaptureStyle) {
1426     case CapturingScopeInfo::ImpCap_None:
1427       CaptureDefault = LCD_None;
1428       break;
1429
1430     case CapturingScopeInfo::ImpCap_LambdaByval:
1431       CaptureDefault = LCD_ByCopy;
1432       break;
1433
1434     case CapturingScopeInfo::ImpCap_CapturedRegion:
1435     case CapturingScopeInfo::ImpCap_LambdaByref:
1436       CaptureDefault = LCD_ByRef;
1437       break;
1438
1439     case CapturingScopeInfo::ImpCap_Block:
1440       llvm_unreachable("block capture in lambda");
1441       break;
1442     }
1443     CaptureDefaultLoc = LSI->CaptureDefaultLoc;
1444
1445     // C++11 [expr.prim.lambda]p4:
1446     //   If a lambda-expression does not include a
1447     //   trailing-return-type, it is as if the trailing-return-type
1448     //   denotes the following type:
1449     //
1450     // Skip for C++1y return type deduction semantics which uses
1451     // different machinery.
1452     // FIXME: Refactor and Merge the return type deduction machinery.
1453     // FIXME: Assumes current resolution to core issue 975.
1454     if (LSI->HasImplicitReturnType && !getLangOpts().CPlusPlus1y) {
1455       deduceClosureReturnType(*LSI);
1456
1457       //   - if there are no return statements in the
1458       //     compound-statement, or all return statements return
1459       //     either an expression of type void or no expression or
1460       //     braced-init-list, the type void;
1461       if (LSI->ReturnType.isNull()) {
1462         LSI->ReturnType = Context.VoidTy;
1463       }
1464
1465       // Create a function type with the inferred return type.
1466       const FunctionProtoType *Proto
1467         = CallOperator->getType()->getAs<FunctionProtoType>();
1468       QualType FunctionTy = Context.getFunctionType(
1469           LSI->ReturnType, Proto->getParamTypes(), Proto->getExtProtoInfo());
1470       CallOperator->setType(FunctionTy);
1471     }
1472     // C++ [expr.prim.lambda]p7:
1473     //   The lambda-expression's compound-statement yields the
1474     //   function-body (8.4) of the function call operator [...].
1475     ActOnFinishFunctionBody(CallOperator, Body, IsInstantiation);
1476     CallOperator->setLexicalDeclContext(Class);
1477     Decl *TemplateOrNonTemplateCallOperatorDecl =
1478         CallOperator->getDescribedFunctionTemplate()
1479         ? CallOperator->getDescribedFunctionTemplate()
1480         : cast<Decl>(CallOperator);
1481
1482     TemplateOrNonTemplateCallOperatorDecl->setLexicalDeclContext(Class);
1483     Class->addDecl(TemplateOrNonTemplateCallOperatorDecl);
1484
1485     PopExpressionEvaluationContext();
1486
1487     // C++11 [expr.prim.lambda]p6:
1488     //   The closure type for a lambda-expression with no lambda-capture
1489     //   has a public non-virtual non-explicit const conversion function
1490     //   to pointer to function having the same parameter and return
1491     //   types as the closure type's function call operator.
1492     if (Captures.empty() && CaptureDefault == LCD_None)
1493       addFunctionPointerConversion(*this, IntroducerRange, Class,
1494                                    CallOperator);
1495
1496     // Objective-C++:
1497     //   The closure type for a lambda-expression has a public non-virtual
1498     //   non-explicit const conversion function to a block pointer having the
1499     //   same parameter and return types as the closure type's function call
1500     //   operator.
1501     // FIXME: Fix generic lambda to block conversions.
1502     if (getLangOpts().Blocks && getLangOpts().ObjC1 &&
1503                                               !Class->isGenericLambda())
1504       addBlockPointerConversion(*this, IntroducerRange, Class, CallOperator);
1505
1506     // Finalize the lambda class.
1507     SmallVector<Decl*, 4> Fields(Class->fields());
1508     ActOnFields(nullptr, Class->getLocation(), Class, Fields, SourceLocation(),
1509                 SourceLocation(), nullptr);
1510     CheckCompletedCXXClass(Class);
1511   }
1512
1513   if (LambdaExprNeedsCleanups)
1514     ExprNeedsCleanups = true;
1515
1516   LambdaExpr *Lambda = LambdaExpr::Create(Context, Class, IntroducerRange,
1517                                           CaptureDefault, CaptureDefaultLoc,
1518                                           Captures,
1519                                           ExplicitParams, ExplicitResultType,
1520                                           CaptureInits, ArrayIndexVars,
1521                                           ArrayIndexStarts, Body->getLocEnd(),
1522                                           ContainsUnexpandedParameterPack);
1523
1524   if (!CurContext->isDependentContext()) {
1525     switch (ExprEvalContexts.back().Context) {
1526     // C++11 [expr.prim.lambda]p2:
1527     //   A lambda-expression shall not appear in an unevaluated operand
1528     //   (Clause 5).
1529     case Unevaluated:
1530     case UnevaluatedAbstract:
1531     // C++1y [expr.const]p2:
1532     //   A conditional-expression e is a core constant expression unless the
1533     //   evaluation of e, following the rules of the abstract machine, would
1534     //   evaluate [...] a lambda-expression.
1535     //
1536     // This is technically incorrect, there are some constant evaluated contexts
1537     // where this should be allowed.  We should probably fix this when DR1607 is
1538     // ratified, it lays out the exact set of conditions where we shouldn't
1539     // allow a lambda-expression.
1540     case ConstantEvaluated:
1541       // We don't actually diagnose this case immediately, because we
1542       // could be within a context where we might find out later that
1543       // the expression is potentially evaluated (e.g., for typeid).
1544       ExprEvalContexts.back().Lambdas.push_back(Lambda);
1545       break;
1546
1547     case PotentiallyEvaluated:
1548     case PotentiallyEvaluatedIfUsed:
1549       break;
1550     }
1551   }
1552
1553   return MaybeBindToTemporary(Lambda);
1554 }
1555
1556 ExprResult Sema::BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
1557                                                SourceLocation ConvLocation,
1558                                                CXXConversionDecl *Conv,
1559                                                Expr *Src) {
1560   // Make sure that the lambda call operator is marked used.
1561   CXXRecordDecl *Lambda = Conv->getParent();
1562   CXXMethodDecl *CallOperator
1563     = cast<CXXMethodDecl>(
1564         Lambda->lookup(
1565           Context.DeclarationNames.getCXXOperatorName(OO_Call)).front());
1566   CallOperator->setReferenced();
1567   CallOperator->markUsed(Context);
1568
1569   ExprResult Init = PerformCopyInitialization(
1570                       InitializedEntity::InitializeBlock(ConvLocation,
1571                                                          Src->getType(),
1572                                                          /*NRVO=*/false),
1573                       CurrentLocation, Src);
1574   if (!Init.isInvalid())
1575     Init = ActOnFinishFullExpr(Init.get());
1576
1577   if (Init.isInvalid())
1578     return ExprError();
1579
1580   // Create the new block to be returned.
1581   BlockDecl *Block = BlockDecl::Create(Context, CurContext, ConvLocation);
1582
1583   // Set the type information.
1584   Block->setSignatureAsWritten(CallOperator->getTypeSourceInfo());
1585   Block->setIsVariadic(CallOperator->isVariadic());
1586   Block->setBlockMissingReturnType(false);
1587
1588   // Add parameters.
1589   SmallVector<ParmVarDecl *, 4> BlockParams;
1590   for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) {
1591     ParmVarDecl *From = CallOperator->getParamDecl(I);
1592     BlockParams.push_back(ParmVarDecl::Create(Context, Block,
1593                                               From->getLocStart(),
1594                                               From->getLocation(),
1595                                               From->getIdentifier(),
1596                                               From->getType(),
1597                                               From->getTypeSourceInfo(),
1598                                               From->getStorageClass(),
1599                                               /*DefaultArg=*/nullptr));
1600   }
1601   Block->setParams(BlockParams);
1602
1603   Block->setIsConversionFromLambda(true);
1604
1605   // Add capture. The capture uses a fake variable, which doesn't correspond
1606   // to any actual memory location. However, the initializer copy-initializes
1607   // the lambda object.
1608   TypeSourceInfo *CapVarTSI =
1609       Context.getTrivialTypeSourceInfo(Src->getType());
1610   VarDecl *CapVar = VarDecl::Create(Context, Block, ConvLocation,
1611                                     ConvLocation, nullptr,
1612                                     Src->getType(), CapVarTSI,
1613                                     SC_None);
1614   BlockDecl::Capture Capture(/*Variable=*/CapVar, /*ByRef=*/false,
1615                              /*Nested=*/false, /*Copy=*/Init.get());
1616   Block->setCaptures(Context, &Capture, &Capture + 1,
1617                      /*CapturesCXXThis=*/false);
1618
1619   // Add a fake function body to the block. IR generation is responsible
1620   // for filling in the actual body, which cannot be expressed as an AST.
1621   Block->setBody(new (Context) CompoundStmt(ConvLocation));
1622
1623   // Create the block literal expression.
1624   Expr *BuildBlock = new (Context) BlockExpr(Block, Conv->getConversionType());
1625   ExprCleanupObjects.push_back(Block);
1626   ExprNeedsCleanups = true;
1627
1628   return BuildBlock;
1629 }