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.empty()) {
 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         llvm::makeArrayRef((NamedDecl *const *)LSI->AutoTemplateParams.data(),
 237                            LSI->AutoTemplateParams.size()),
 238         RAngleLoc);
 239   }
 240   return LSI->GLTemplateParameterList;
 241 }
 242
 243 CXXRecordDecl *Sema::createLambdaClosureType(SourceRange IntroducerRange,
 244                                              TypeSourceInfo *Info,
 245                                              bool KnownDependent,
 246                                              LambdaCaptureDefault CaptureDefault) {
 247   DeclContext *DC = CurContext;
 248   while (!(DC->isFunctionOrMethod() || DC->isRecord() || DC->isFileContext()))
 249     DC = DC->getParent();
 250   bool IsGenericLambda = getGenericLambdaTemplateParameterList(getCurLambda(),
 251                                                                *this);
 252   // Start constructing the lambda class.
 253   CXXRecordDecl *Class = CXXRecordDecl::CreateLambda(Context, DC, Info,
 254                                                      IntroducerRange.getBegin(),
 255                                                      KnownDependent,
 256                                                      IsGenericLambda,
 257                                                      CaptureDefault);
 258   DC->addDecl(Class);
 259
 260   return Class;
 261 }
 262
 263 /// \brief Determine whether the given context is or is enclosed in an inline
 264 /// function.
 265 static bool isInInlineFunction(const DeclContext *DC) {
 266   while (!DC->isFileContext()) {
 267     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DC))
 268       if (FD->isInlined())
 269         return true;
 270
 271     DC = DC->getLexicalParent();
 272   }
 273
 274   return false;
 275 }
 276
 277 MangleNumberingContext *
 278 Sema::getCurrentMangleNumberContext(const DeclContext *DC,
 279                                     Decl *&ManglingContextDecl) {
 280   // Compute the context for allocating mangling numbers in the current
 281   // expression, if the ABI requires them.
 282   ManglingContextDecl = ExprEvalContexts.back().ManglingContextDecl;
 283
 284   enum ContextKind {
 285     Normal,
 286     DefaultArgument,
 287     DataMember,
 288     StaticDataMember
 289   } Kind = Normal;
 290
 291   // Default arguments of member function parameters that appear in a class
 292   // definition, as well as the initializers of data members, receive special
 293   // treatment. Identify them.
 294   if (ManglingContextDecl) {
 295     if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(ManglingContextDecl)) {
 296       if (const DeclContext *LexicalDC
 297           = Param->getDeclContext()->getLexicalParent())
 298         if (LexicalDC->isRecord())
 299           Kind = DefaultArgument;
 300     } else if (VarDecl *Var = dyn_cast<VarDecl>(ManglingContextDecl)) {
 301       if (Var->getDeclContext()->isRecord())
 302         Kind = StaticDataMember;
 303     } else if (isa<FieldDecl>(ManglingContextDecl)) {
 304       Kind = DataMember;
 305     }
 306   }
 307
 308   // Itanium ABI [5.1.7]:
 309   //   In the following contexts [...] the one-definition rule requires closure
 310   //   types in different translation units to "correspond":
 311   bool IsInNonspecializedTemplate =
 312     !ActiveTemplateInstantiations.empty() || CurContext->isDependentContext();
 313   switch (Kind) {
 314   case Normal:
 315     //  -- the bodies of non-exported nonspecialized template functions
 316     //  -- the bodies of inline functions
 317     if ((IsInNonspecializedTemplate &&
 318          !(ManglingContextDecl && isa<ParmVarDecl>(ManglingContextDecl))) ||
 319         isInInlineFunction(CurContext)) {
 320       ManglingContextDecl = nullptr;
 321       return &Context.getManglingNumberContext(DC);
 322     }
 323
 324     ManglingContextDecl = nullptr;
 325     return nullptr;
 326
 327   case StaticDataMember:
 328     //  -- the initializers of nonspecialized static members of template classes
 329     if (!IsInNonspecializedTemplate) {
 330       ManglingContextDecl = nullptr;
 331       return nullptr;
 332     }
 333     // Fall through to get the current context.
 334
 335   case DataMember:
 336     //  -- the in-class initializers of class members
 337   case DefaultArgument:
 338     //  -- default arguments appearing in class definitions
 339     return &ExprEvalContexts.back().getMangleNumberingContext(Context);
 340   }
 341
 342   llvm_unreachable("unexpected context");
 343 }
 344
 345 MangleNumberingContext &
 346 Sema::ExpressionEvaluationContextRecord::getMangleNumberingContext(
 347     ASTContext &Ctx) {
 348   assert(ManglingContextDecl && "Need to have a context declaration");
 349   if (!MangleNumbering)
 350     MangleNumbering = Ctx.createMangleNumberingContext();
 351   return *MangleNumbering;
 352 }
 353
 354 CXXMethodDecl *Sema::startLambdaDefinition(CXXRecordDecl *Class,
 355                                            SourceRange IntroducerRange,
 356                                            TypeSourceInfo *MethodTypeInfo,
 357                                            SourceLocation EndLoc,
 358                                            ArrayRef<ParmVarDecl *> Params,
 359                                            const bool IsConstexprSpecified) {
 360   QualType MethodType = MethodTypeInfo->getType();
 361   TemplateParameterList *TemplateParams =
 362             getGenericLambdaTemplateParameterList(getCurLambda(), *this);
 363   // If a lambda appears in a dependent context or is a generic lambda (has
 364   // template parameters) and has an 'auto' return type, deduce it to a
 365   // dependent type.
 366   if (Class->isDependentContext() || TemplateParams) {
 367     const FunctionProtoType *FPT = MethodType->castAs<FunctionProtoType>();
 368     QualType Result = FPT->getReturnType();
 369     if (Result->isUndeducedType()) {
 370       Result = SubstAutoType(Result, Context.DependentTy);
 371       MethodType = Context.getFunctionType(Result, FPT->getParamTypes(),
 372                                            FPT->getExtProtoInfo());
 373     }
 374   }
 375
 376   // C++11 [expr.prim.lambda]p5:
 377   //   The closure type for a lambda-expression has a public inline function
 378   //   call operator (13.5.4) whose parameters and return type are described by
 379   //   the lambda-expression's parameter-declaration-clause and
 380   //   trailing-return-type respectively.
 381   DeclarationName MethodName
 382     = Context.DeclarationNames.getCXXOperatorName(OO_Call);
 383   DeclarationNameLoc MethodNameLoc;
 384   MethodNameLoc.CXXOperatorName.BeginOpNameLoc
 385     = IntroducerRange.getBegin().getRawEncoding();
 386   MethodNameLoc.CXXOperatorName.EndOpNameLoc
 387     = IntroducerRange.getEnd().getRawEncoding();
 388   CXXMethodDecl *Method
 389     = CXXMethodDecl::Create(Context, Class, EndLoc,
 390                             DeclarationNameInfo(MethodName,
 391                                                 IntroducerRange.getBegin(),
 392                                                 MethodNameLoc),
 393                             MethodType, MethodTypeInfo,
 394                             SC_None,
 395                             /*isInline=*/true,
 396                             IsConstexprSpecified,
 397                             EndLoc);
 398   Method->setAccess(AS_public);
 399
 400   // Temporarily set the lexical declaration context to the current
 401   // context, so that the Scope stack matches the lexical nesting.
 402   Method->setLexicalDeclContext(CurContext);
 403   // Create a function template if we have a template parameter list
 404   FunctionTemplateDecl *const TemplateMethod = TemplateParams ?
 405             FunctionTemplateDecl::Create(Context, Class,
 406                                          Method->getLocation(), MethodName,
 407                                          TemplateParams,
 408                                          Method) : nullptr;
 409   if (TemplateMethod) {
 410     TemplateMethod->setLexicalDeclContext(CurContext);
 411     TemplateMethod->setAccess(AS_public);
 412     Method->setDescribedFunctionTemplate(TemplateMethod);
 413   }
 414
 415   // Add parameters.
 416   if (!Params.empty()) {
 417     Method->setParams(Params);
 418     CheckParmsForFunctionDef(Params,
 419                              /*CheckParameterNames=*/false);
 420
 421     for (auto P : Method->parameters())
 422       P->setOwningFunction(Method);
 423   }
 424
 425   Decl *ManglingContextDecl;
 426   if (MangleNumberingContext *MCtx =
 427           getCurrentMangleNumberContext(Class->getDeclContext(),
 428                                         ManglingContextDecl)) {
 429     unsigned ManglingNumber = MCtx->getManglingNumber(Method);
 430     Class->setLambdaMangling(ManglingNumber, ManglingContextDecl);
 431   }
 432
 433   return Method;
 434 }
 435
 436 void Sema::buildLambdaScope(LambdaScopeInfo *LSI,
 437                                         CXXMethodDecl *CallOperator,
 438                                         SourceRange IntroducerRange,
 439                                         LambdaCaptureDefault CaptureDefault,
 440                                         SourceLocation CaptureDefaultLoc,
 441                                         bool ExplicitParams,
 442                                         bool ExplicitResultType,
 443                                         bool Mutable) {
 444   LSI->CallOperator = CallOperator;
 445   CXXRecordDecl *LambdaClass = CallOperator->getParent();
 446   LSI->Lambda = LambdaClass;
 447   if (CaptureDefault == LCD_ByCopy)
 448     LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByval;
 449   else if (CaptureDefault == LCD_ByRef)
 450     LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByref;
 451   LSI->CaptureDefaultLoc = CaptureDefaultLoc;
 452   LSI->IntroducerRange = IntroducerRange;
 453   LSI->ExplicitParams = ExplicitParams;
 454   LSI->Mutable = Mutable;
 455
 456   if (ExplicitResultType) {
 457     LSI->ReturnType = CallOperator->getReturnType();
 458
 459     if (!LSI->ReturnType->isDependentType() &&
 460         !LSI->ReturnType->isVoidType()) {
 461       if (RequireCompleteType(CallOperator->getLocStart(), LSI->ReturnType,
 462                               diag::err_lambda_incomplete_result)) {
 463         // Do nothing.
 464       }
 465     }
 466   } else {
 467     LSI->HasImplicitReturnType = true;
 468   }
 469 }
 470
 471 void Sema::finishLambdaExplicitCaptures(LambdaScopeInfo *LSI) {
 472   LSI->finishedExplicitCaptures();
 473 }
 474
 475 void Sema::addLambdaParameters(CXXMethodDecl *CallOperator, Scope *CurScope) {
 476   // Introduce our parameters into the function scope
 477   for (unsigned p = 0, NumParams = CallOperator->getNumParams();
 478        p < NumParams; ++p) {
 479     ParmVarDecl *Param = CallOperator->getParamDecl(p);
 480
 481     // If this has an identifier, add it to the scope stack.
 482     if (CurScope && Param->getIdentifier()) {
 483       CheckShadow(CurScope, Param);
 484
 485       PushOnScopeChains(Param, CurScope);
 486     }
 487   }
 488 }
 489
 490 /// If this expression is an enumerator-like expression of some type
 491 /// T, return the type T; otherwise, return null.
 492 ///
 493 /// Pointer comparisons on the result here should always work because
 494 /// it's derived from either the parent of an EnumConstantDecl
 495 /// (i.e. the definition) or the declaration returned by
 496 /// EnumType::getDecl() (i.e. the definition).
 497 static EnumDecl *findEnumForBlockReturn(Expr *E) {
 498   // An expression is an enumerator-like expression of type T if,
 499   // ignoring parens and parens-like expressions:
 500   E = E->IgnoreParens();
 501
 502   //  - it is an enumerator whose enum type is T or
 503   if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
 504     if (EnumConstantDecl *D
 505           = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
 506       return cast<EnumDecl>(D->getDeclContext());
 507     }
 508     return nullptr;
 509   }
 510
 511   //  - it is a comma expression whose RHS is an enumerator-like
 512   //    expression of type T or
 513   if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
 514     if (BO->getOpcode() == BO_Comma)
 515       return findEnumForBlockReturn(BO->getRHS());
 516     return nullptr;
 517   }
 518
 519   //  - it is a statement-expression whose value expression is an
 520   //    enumerator-like expression of type T or
 521   if (StmtExpr *SE = dyn_cast<StmtExpr>(E)) {
 522     if (Expr *last = dyn_cast_or_null<Expr>(SE->getSubStmt()->body_back()))
 523       return findEnumForBlockReturn(last);
 524     return nullptr;
 525   }
 526
 527   //   - it is a ternary conditional operator (not the GNU ?:
 528   //     extension) whose second and third operands are
 529   //     enumerator-like expressions of type T or
 530   if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
 531     if (EnumDecl *ED = findEnumForBlockReturn(CO->getTrueExpr()))
 532       if (ED == findEnumForBlockReturn(CO->getFalseExpr()))
 533         return ED;
 534     return nullptr;
 535   }
 536
 537   // (implicitly:)
 538   //   - it is an implicit integral conversion applied to an
 539   //     enumerator-like expression of type T or
 540   if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
 541     // We can sometimes see integral conversions in valid
 542     // enumerator-like expressions.
 543     if (ICE->getCastKind() == CK_IntegralCast)
 544       return findEnumForBlockReturn(ICE->getSubExpr());
 545
 546     // Otherwise, just rely on the type.
 547   }
 548
 549   //   - it is an expression of that formal enum type.
 550   if (const EnumType *ET = E->getType()->getAs<EnumType>()) {
 551     return ET->getDecl();
 552   }
 553
 554   // Otherwise, nope.
 555   return nullptr;
 556 }
 557
 558 /// Attempt to find a type T for which the returned expression of the
 559 /// given statement is an enumerator-like expression of that type.
 560 static EnumDecl *findEnumForBlockReturn(ReturnStmt *ret) {
 561   if (Expr *retValue = ret->getRetValue())
 562     return findEnumForBlockReturn(retValue);
 563   return nullptr;
 564 }
 565
 566 /// Attempt to find a common type T for which all of the returned
 567 /// expressions in a block are enumerator-like expressions of that
 568 /// type.
 569 static EnumDecl *findCommonEnumForBlockReturns(ArrayRef<ReturnStmt*> returns) {
 570   ArrayRef<ReturnStmt*>::iterator i = returns.begin(), e = returns.end();
 571
 572   // Try to find one for the first return.
 573   EnumDecl *ED = findEnumForBlockReturn(*i);
 574   if (!ED) return nullptr;
 575
 576   // Check that the rest of the returns have the same enum.
 577   for (++i; i != e; ++i) {
 578     if (findEnumForBlockReturn(*i) != ED)
 579       return nullptr;
 580   }
 581
 582   // Never infer an anonymous enum type.
 583   if (!ED->hasNameForLinkage()) return nullptr;
 584
 585   return ED;
 586 }
 587
 588 /// Adjust the given return statements so that they formally return
 589 /// the given type.  It should require, at most, an IntegralCast.
 590 static void adjustBlockReturnsToEnum(Sema &S, ArrayRef<ReturnStmt*> returns,
 591                                      QualType returnType) {
 592   for (ArrayRef<ReturnStmt*>::iterator
 593          i = returns.begin(), e = returns.end(); i != e; ++i) {
 594     ReturnStmt *ret = *i;
 595     Expr *retValue = ret->getRetValue();
 596     if (S.Context.hasSameType(retValue->getType(), returnType))
 597       continue;
 598
 599     // Right now we only support integral fixup casts.
 600     assert(returnType->isIntegralOrUnscopedEnumerationType());
 601     assert(retValue->getType()->isIntegralOrUnscopedEnumerationType());
 602
 603     ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(retValue);
 604
 605     Expr *E = (cleanups ? cleanups->getSubExpr() : retValue);
 606     E = ImplicitCastExpr::Create(S.Context, returnType, CK_IntegralCast,
 607                                  E, /*base path*/ nullptr, VK_RValue);
 608     if (cleanups) {
 609       cleanups->setSubExpr(E);
 610     } else {
 611       ret->setRetValue(E);
 612     }
 613   }
 614 }
 615
 616 void Sema::deduceClosureReturnType(CapturingScopeInfo &CSI) {
 617   assert(CSI.HasImplicitReturnType);
 618   // If it was ever a placeholder, it had to been deduced to DependentTy.
 619   assert(CSI.ReturnType.isNull() || !CSI.ReturnType->isUndeducedType());
 620   assert((!isa<LambdaScopeInfo>(CSI) || !getLangOpts().CPlusPlus14) &&
 621          "lambda expressions use auto deduction in C++14 onwards");
 622
 623   // C++ core issue 975:
 624   //   If a lambda-expression does not include a trailing-return-type,
 625   //   it is as if the trailing-return-type denotes the following type:
 626   //     - if there are no return statements in the compound-statement,
 627   //       or all return statements return either an expression of type
 628   //       void or no expression or braced-init-list, the type void;
 629   //     - otherwise, if all return statements return an expression
 630   //       and the types of the returned expressions after
 631   //       lvalue-to-rvalue conversion (4.1 [conv.lval]),
 632   //       array-to-pointer conversion (4.2 [conv.array]), and
 633   //       function-to-pointer conversion (4.3 [conv.func]) are the
 634   //       same, that common type;
 635   //     - otherwise, the program is ill-formed.
 636   //
 637   // C++ core issue 1048 additionally removes top-level cv-qualifiers
 638   // from the types of returned expressions to match the C++14 auto
 639   // deduction rules.
 640   //
 641   // In addition, in blocks in non-C++ modes, if all of the return
 642   // statements are enumerator-like expressions of some type T, where
 643   // T has a name for linkage, then we infer the return type of the
 644   // block to be that type.
 645
 646   // First case: no return statements, implicit void return type.
 647   ASTContext &Ctx = getASTContext();
 648   if (CSI.Returns.empty()) {
 649     // It's possible there were simply no /valid/ return statements.
 650     // In this case, the first one we found may have at least given us a type.
 651     if (CSI.ReturnType.isNull())
 652       CSI.ReturnType = Ctx.VoidTy;
 653     return;
 654   }
 655
 656   // Second case: at least one return statement has dependent type.
 657   // Delay type checking until instantiation.
 658   assert(!CSI.ReturnType.isNull() && "We should have a tentative return type.");
 659   if (CSI.ReturnType->isDependentType())
 660     return;
 661
 662   // Try to apply the enum-fuzz rule.
 663   if (!getLangOpts().CPlusPlus) {
 664     assert(isa<BlockScopeInfo>(CSI));
 665     const EnumDecl *ED = findCommonEnumForBlockReturns(CSI.Returns);
 666     if (ED) {
 667       CSI.ReturnType = Context.getTypeDeclType(ED);
 668       adjustBlockReturnsToEnum(*this, CSI.Returns, CSI.ReturnType);
 669       return;
 670     }
 671   }
 672
 673   // Third case: only one return statement. Don't bother doing extra work!
 674   SmallVectorImpl<ReturnStmt*>::iterator I = CSI.Returns.begin(),
 675                                          E = CSI.Returns.end();
 676   if (I+1 == E)
 677     return;
 678
 679   // General case: many return statements.
 680   // Check that they all have compatible return types.
 681
 682   // We require the return types to strictly match here.
 683   // Note that we've already done the required promotions as part of
 684   // processing the return statement.
 685   for (; I != E; ++I) {
 686     const ReturnStmt *RS = *I;
 687     const Expr *RetE = RS->getRetValue();
 688
 689     QualType ReturnType =
 690         (RetE ? RetE->getType() : Context.VoidTy).getUnqualifiedType();
 691     if (Context.getCanonicalFunctionResultType(ReturnType) ==
 692           Context.getCanonicalFunctionResultType(CSI.ReturnType))
 693       continue;
 694
 695     // FIXME: This is a poor diagnostic for ReturnStmts without expressions.
 696     // TODO: It's possible that the *first* return is the divergent one.
 697     Diag(RS->getLocStart(),
 698          diag::err_typecheck_missing_return_type_incompatible)
 699       << ReturnType << CSI.ReturnType
 700       << isa<LambdaScopeInfo>(CSI);
 701     // Continue iterating so that we keep emitting diagnostics.
 702   }
 703 }
 704
 705 QualType Sema::buildLambdaInitCaptureInitialization(SourceLocation Loc,
 706                                                     bool ByRef,
 707                                                     IdentifierInfo *Id,
 708                                                     bool IsDirectInit,
 709                                                     Expr *&Init) {
 710   // Create an 'auto' or 'auto&' TypeSourceInfo that we can use to
 711   // deduce against.
 712   QualType DeductType = Context.getAutoDeductType();
 713   TypeLocBuilder TLB;
 714   TLB.pushTypeSpec(DeductType).setNameLoc(Loc);
 715   if (ByRef) {
 716     DeductType = BuildReferenceType(DeductType, true, Loc, Id);
 717     assert(!DeductType.isNull() && "can't build reference to auto");
 718     TLB.push<ReferenceTypeLoc>(DeductType).setSigilLoc(Loc);
 719   }
 720   TypeSourceInfo *TSI = TLB.getTypeSourceInfo(Context, DeductType);
 721
 722   // Deduce the type of the init capture.
 723   QualType DeducedType = deduceVarTypeFromInitializer(
 724       /*VarDecl*/nullptr, DeclarationName(Id), DeductType, TSI,
 725       SourceRange(Loc, Loc), IsDirectInit, Init);
 726   if (DeducedType.isNull())
 727     return QualType();
 728
 729   // Are we a non-list direct initialization?
 730   ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init);
 731
 732   // Perform initialization analysis and ensure any implicit conversions
 733   // (such as lvalue-to-rvalue) are enforced.
 734   InitializedEntity Entity =
 735       InitializedEntity::InitializeLambdaCapture(Id, DeducedType, Loc);
 736   InitializationKind Kind =
 737       IsDirectInit
 738           ? (CXXDirectInit ? InitializationKind::CreateDirect(
 739                                  Loc, Init->getLocStart(), Init->getLocEnd())
 740                            : InitializationKind::CreateDirectList(Loc))
 741           : InitializationKind::CreateCopy(Loc, Init->getLocStart());
 742
 743   MultiExprArg Args = Init;
 744   if (CXXDirectInit)
 745     Args =
 746         MultiExprArg(CXXDirectInit->getExprs(), CXXDirectInit->getNumExprs());
 747   QualType DclT;
 748   InitializationSequence InitSeq(*this, Entity, Kind, Args);
 749   ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT);
 750
 751   if (Result.isInvalid())
 752     return QualType();
 753   Init = Result.getAs<Expr>();
 754
 755   // The init-capture initialization is a full-expression that must be
 756   // processed as one before we enter the declcontext of the lambda's
 757   // call-operator.
 758   Result = ActOnFinishFullExpr(Init, Loc, /*DiscardedValue*/ false,
 759                                /*IsConstexpr*/ false,
 760                                /*IsLambdaInitCaptureInitalizer*/ true);
 761   if (Result.isInvalid())
 762     return QualType();
 763
 764   Init = Result.getAs<Expr>();
 765   return DeducedType;
 766 }
 767
 768 VarDecl *Sema::createLambdaInitCaptureVarDecl(SourceLocation Loc,
 769                                               QualType InitCaptureType,
 770                                               IdentifierInfo *Id,
 771                                               unsigned InitStyle, Expr *Init) {
 772   TypeSourceInfo *TSI = Context.getTrivialTypeSourceInfo(InitCaptureType,
 773       Loc);
 774   // Create a dummy variable representing the init-capture. This is not actually
 775   // used as a variable, and only exists as a way to name and refer to the
 776   // init-capture.
 777   // FIXME: Pass in separate source locations for '&' and identifier.
 778   VarDecl *NewVD = VarDecl::Create(Context, CurContext, Loc,
 779                                    Loc, Id, InitCaptureType, TSI, SC_Auto);
 780   NewVD->setInitCapture(true);
 781   NewVD->setReferenced(true);
 782   // FIXME: Pass in a VarDecl::InitializationStyle.
 783   NewVD->setInitStyle(static_cast<VarDecl::InitializationStyle>(InitStyle));
 784   NewVD->markUsed(Context);
 785   NewVD->setInit(Init);
 786   return NewVD;
 787 }
 788
 789 FieldDecl *Sema::buildInitCaptureField(LambdaScopeInfo *LSI, VarDecl *Var) {
 790   FieldDecl *Field = FieldDecl::Create(
 791       Context, LSI->Lambda, Var->getLocation(), Var->getLocation(),
 792       nullptr, Var->getType(), Var->getTypeSourceInfo(), nullptr, false,
 793       ICIS_NoInit);
 794   Field->setImplicit(true);
 795   Field->setAccess(AS_private);
 796   LSI->Lambda->addDecl(Field);
 797
 798   LSI->addCapture(Var, /*isBlock*/false, Var->getType()->isReferenceType(),
 799                   /*isNested*/false, Var->getLocation(), SourceLocation(),
 800                   Var->getType(), Var->getInit());
 801   return Field;
 802 }
 803
 804 void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
 805                                         Declarator &ParamInfo,
 806                                         Scope *CurScope) {
 807   // Determine if we're within a context where we know that the lambda will
 808   // be dependent, because there are template parameters in scope.
 809   bool KnownDependent = false;
 810   LambdaScopeInfo *const LSI = getCurLambda();
 811   assert(LSI && "LambdaScopeInfo should be on stack!");
 812
 813   // The lambda-expression's closure type might be dependent even if its
 814   // semantic context isn't, if it appears within a default argument of a
 815   // function template.
 816   if (CurScope->getTemplateParamParent())
 817     KnownDependent = true;
 818
 819   // Determine the signature of the call operator.
 820   TypeSourceInfo *MethodTyInfo;
 821   bool ExplicitParams = true;
 822   bool ExplicitResultType = true;
 823   bool ContainsUnexpandedParameterPack = false;
 824   SourceLocation EndLoc;
 825   SmallVector<ParmVarDecl *, 8> Params;
 826   if (ParamInfo.getNumTypeObjects() == 0) {
 827     // C++11 [expr.prim.lambda]p4:
 828     //   If a lambda-expression does not include a lambda-declarator, it is as
 829     //   if the lambda-declarator were ().
 830     FunctionProtoType::ExtProtoInfo EPI(Context.getDefaultCallingConvention(
 831         /*IsVariadic=*/false, /*IsCXXMethod=*/true));
 832     EPI.HasTrailingReturn = true;
 833     EPI.TypeQuals |= DeclSpec::TQ_const;
 834     // C++1y [expr.prim.lambda]:
 835     //   The lambda return type is 'auto', which is replaced by the
 836     //   trailing-return type if provided and/or deduced from 'return'
 837     //   statements
 838     // We don't do this before C++1y, because we don't support deduced return
 839     // types there.
 840     QualType DefaultTypeForNoTrailingReturn =
 841         getLangOpts().CPlusPlus14 ? Context.getAutoDeductType()
 842                                   : Context.DependentTy;
 843     QualType MethodTy =
 844         Context.getFunctionType(DefaultTypeForNoTrailingReturn, None, EPI);
 845     MethodTyInfo = Context.getTrivialTypeSourceInfo(MethodTy);
 846     ExplicitParams = false;
 847     ExplicitResultType = false;
 848     EndLoc = Intro.Range.getEnd();
 849   } else {
 850     assert(ParamInfo.isFunctionDeclarator() &&
 851            "lambda-declarator is a function");
 852     DeclaratorChunk::FunctionTypeInfo &FTI = ParamInfo.getFunctionTypeInfo();
 853
 854     // C++11 [expr.prim.lambda]p5:
 855     //   This function call operator is declared const (9.3.1) if and only if
 856     //   the lambda-expression's parameter-declaration-clause is not followed
 857     //   by mutable. It is neither virtual nor declared volatile. [...]
 858     if (!FTI.hasMutableQualifier())
 859       FTI.TypeQuals |= DeclSpec::TQ_const;
 860
 861     MethodTyInfo = GetTypeForDeclarator(ParamInfo, CurScope);
 862     assert(MethodTyInfo && "no type from lambda-declarator");
 863     EndLoc = ParamInfo.getSourceRange().getEnd();
 864
 865     ExplicitResultType = FTI.hasTrailingReturnType();
 866
 867     if (FTIHasNonVoidParameters(FTI)) {
 868       Params.reserve(FTI.NumParams);
 869       for (unsigned i = 0, e = FTI.NumParams; i != e; ++i)
 870         Params.push_back(cast<ParmVarDecl>(FTI.Params[i].Param));
 871     }
 872
 873     // Check for unexpanded parameter packs in the method type.
 874     if (MethodTyInfo->getType()->containsUnexpandedParameterPack())
 875       ContainsUnexpandedParameterPack = true;
 876   }
 877
 878   CXXRecordDecl *Class = createLambdaClosureType(Intro.Range, MethodTyInfo,
 879                                                  KnownDependent, Intro.Default);
 880
 881   CXXMethodDecl *Method =
 882       startLambdaDefinition(Class, Intro.Range, MethodTyInfo, EndLoc, Params,
 883                             ParamInfo.getDeclSpec().isConstexprSpecified());
 884   if (ExplicitParams)
 885     CheckCXXDefaultArguments(Method);
 886
 887   // Attributes on the lambda apply to the method.
 888   ProcessDeclAttributes(CurScope, Method, ParamInfo);
 889
 890   // Introduce the function call operator as the current declaration context.
 891   PushDeclContext(CurScope, Method);
 892
 893   // Build the lambda scope.
 894   buildLambdaScope(LSI, Method, Intro.Range, Intro.Default, Intro.DefaultLoc,
 895                    ExplicitParams, ExplicitResultType, !Method->isConst());
 896
 897   // C++11 [expr.prim.lambda]p9:
 898   //   A lambda-expression whose smallest enclosing scope is a block scope is a
 899   //   local lambda expression; any other lambda expression shall not have a
 900   //   capture-default or simple-capture in its lambda-introducer.
 901   //
 902   // For simple-captures, this is covered by the check below that any named
 903   // entity is a variable that can be captured.
 904   //
 905   // For DR1632, we also allow a capture-default in any context where we can
 906   // odr-use 'this' (in particular, in a default initializer for a non-static
 907   // data member).
 908   if (Intro.Default != LCD_None && !Class->getParent()->isFunctionOrMethod() &&
 909       (getCurrentThisType().isNull() ||
 910        CheckCXXThisCapture(SourceLocation(), /*Explicit*/true,
 911                            /*BuildAndDiagnose*/false)))
 912     Diag(Intro.DefaultLoc, diag::err_capture_default_non_local);
 913
 914   // Distinct capture names, for diagnostics.
 915   llvm::SmallSet<IdentifierInfo*, 8> CaptureNames;
 916
 917   // Handle explicit captures.
 918   SourceLocation PrevCaptureLoc
 919     = Intro.Default == LCD_None? Intro.Range.getBegin() : Intro.DefaultLoc;
 920   for (auto C = Intro.Captures.begin(), E = Intro.Captures.end(); C != E;
 921        PrevCaptureLoc = C->Loc, ++C) {
 922     if (C->Kind == LCK_This || C->Kind == LCK_StarThis) {
 923       if (C->Kind == LCK_StarThis)
 924         Diag(C->Loc, !getLangOpts().CPlusPlus1z
 925                              ? diag::ext_star_this_lambda_capture_cxx1z
 926                              : diag::warn_cxx14_compat_star_this_lambda_capture);
 927
 928       // C++11 [expr.prim.lambda]p8:
 929       //   An identifier or this shall not appear more than once in a
 930       //   lambda-capture.
 931       if (LSI->isCXXThisCaptured()) {
 932         Diag(C->Loc, diag::err_capture_more_than_once)
 933             << "'this'" << SourceRange(LSI->getCXXThisCapture().getLocation())
 934             << FixItHint::CreateRemoval(
 935                    SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
 936         continue;
 937       }
 938
 939       // C++1z [expr.prim.lambda]p8:
 940       //  If a lambda-capture includes a capture-default that is =, each
 941       //  simple-capture of that lambda-capture shall be of the form "&
 942       //  identifier" or "* this". [ Note: The form [&,this] is redundant but
 943       //  accepted for compatibility with ISO C++14. --end note ]
 944       if (Intro.Default == LCD_ByCopy && C->Kind != LCK_StarThis) {
 945         Diag(C->Loc, diag::err_this_capture_with_copy_default)
 946             << FixItHint::CreateRemoval(
 947                 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
 948         continue;
 949       }
 950
 951       // C++11 [expr.prim.lambda]p12:
 952       //   If this is captured by a local lambda expression, its nearest
 953       //   enclosing function shall be a non-static member function.
 954       QualType ThisCaptureType = getCurrentThisType();
 955       if (ThisCaptureType.isNull()) {
 956         Diag(C->Loc, diag::err_this_capture) << true;
 957         continue;
 958       }
 959
 960       CheckCXXThisCapture(C->Loc, /*Explicit=*/true, /*BuildAndDiagnose*/ true,
 961                           /*FunctionScopeIndexToStopAtPtr*/ nullptr,
 962                           C->Kind == LCK_StarThis);
 963       continue;
 964     }
 965
 966     assert(C->Id && "missing identifier for capture");
 967
 968     if (C->Init.isInvalid())
 969       continue;
 970
 971     VarDecl *Var = nullptr;
 972     if (C->Init.isUsable()) {
 973       Diag(C->Loc, getLangOpts().CPlusPlus14
 974                        ? diag::warn_cxx11_compat_init_capture
 975                        : diag::ext_init_capture);
 976
 977       if (C->Init.get()->containsUnexpandedParameterPack())
 978         ContainsUnexpandedParameterPack = true;
 979       // If the initializer expression is usable, but the InitCaptureType
 980       // is not, then an error has occurred - so ignore the capture for now.
 981       // for e.g., [n{0}] { }; <-- if no <initializer_list> is included.
 982       // FIXME: we should create the init capture variable and mark it invalid
 983       // in this case.
 984       if (C->InitCaptureType.get().isNull())
 985         continue;
 986
 987       unsigned InitStyle;
 988       switch (C->InitKind) {
 989       case LambdaCaptureInitKind::NoInit:
 990         llvm_unreachable("not an init-capture?");
 991       case LambdaCaptureInitKind::CopyInit:
 992         InitStyle = VarDecl::CInit;
 993         break;
 994       case LambdaCaptureInitKind::DirectInit:
 995         InitStyle = VarDecl::CallInit;
 996         break;
 997       case LambdaCaptureInitKind::ListInit:
 998         InitStyle = VarDecl::ListInit;
 999         break;
1000       }
1001       Var = createLambdaInitCaptureVarDecl(C->Loc, C->InitCaptureType.get(),
1002                                            C->Id, InitStyle, C->Init.get());
1003       // C++1y [expr.prim.lambda]p11:
1004       //   An init-capture behaves as if it declares and explicitly
1005       //   captures a variable [...] whose declarative region is the
1006       //   lambda-expression's compound-statement
1007       if (Var)
1008         PushOnScopeChains(Var, CurScope, false);
1009     } else {
1010       assert(C->InitKind == LambdaCaptureInitKind::NoInit &&
1011              "init capture has valid but null init?");
1012
1013       // C++11 [expr.prim.lambda]p8:
1014       //   If a lambda-capture includes a capture-default that is &, the
1015       //   identifiers in the lambda-capture shall not be preceded by &.
1016       //   If a lambda-capture includes a capture-default that is =, [...]
1017       //   each identifier it contains shall be preceded by &.
1018       if (C->Kind == LCK_ByRef && Intro.Default == LCD_ByRef) {
1019         Diag(C->Loc, diag::err_reference_capture_with_reference_default)
1020             << FixItHint::CreateRemoval(
1021                 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
1022         continue;
1023       } else if (C->Kind == LCK_ByCopy && Intro.Default == LCD_ByCopy) {
1024         Diag(C->Loc, diag::err_copy_capture_with_copy_default)
1025             << FixItHint::CreateRemoval(
1026                 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
1027         continue;
1028       }
1029
1030       // C++11 [expr.prim.lambda]p10:
1031       //   The identifiers in a capture-list are looked up using the usual
1032       //   rules for unqualified name lookup (3.4.1)
1033       DeclarationNameInfo Name(C->Id, C->Loc);
1034       LookupResult R(*this, Name, LookupOrdinaryName);
1035       LookupName(R, CurScope);
1036       if (R.isAmbiguous())
1037         continue;
1038       if (R.empty()) {
1039         // FIXME: Disable corrections that would add qualification?
1040         CXXScopeSpec ScopeSpec;
1041         if (DiagnoseEmptyLookup(CurScope, ScopeSpec, R,
1042                                 llvm::make_unique<DeclFilterCCC<VarDecl>>()))
1043           continue;
1044       }
1045
1046       Var = R.getAsSingle<VarDecl>();
1047       if (Var && DiagnoseUseOfDecl(Var, C->Loc))
1048         continue;
1049     }
1050
1051     // C++11 [expr.prim.lambda]p8:
1052     //   An identifier or this shall not appear more than once in a
1053     //   lambda-capture.
1054     if (!CaptureNames.insert(C->Id).second) {
1055       if (Var && LSI->isCaptured(Var)) {
1056         Diag(C->Loc, diag::err_capture_more_than_once)
1057             << C->Id << SourceRange(LSI->getCapture(Var).getLocation())
1058             << FixItHint::CreateRemoval(
1059                    SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
1060       } else
1061         // Previous capture captured something different (one or both was
1062         // an init-cpature): no fixit.
1063         Diag(C->Loc, diag::err_capture_more_than_once) << C->Id;
1064       continue;
1065     }
1066
1067     // C++11 [expr.prim.lambda]p10:
1068     //   [...] each such lookup shall find a variable with automatic storage
1069     //   duration declared in the reaching scope of the local lambda expression.
1070     // Note that the 'reaching scope' check happens in tryCaptureVariable().
1071     if (!Var) {
1072       Diag(C->Loc, diag::err_capture_does_not_name_variable) << C->Id;
1073       continue;
1074     }
1075
1076     // Ignore invalid decls; they'll just confuse the code later.
1077     if (Var->isInvalidDecl())
1078       continue;
1079
1080     if (!Var->hasLocalStorage()) {
1081       Diag(C->Loc, diag::err_capture_non_automatic_variable) << C->Id;
1082       Diag(Var->getLocation(), diag::note_previous_decl) << C->Id;
1083       continue;
1084     }
1085
1086     // C++11 [expr.prim.lambda]p23:
1087     //   A capture followed by an ellipsis is a pack expansion (14.5.3).
1088     SourceLocation EllipsisLoc;
1089     if (C->EllipsisLoc.isValid()) {
1090       if (Var->isParameterPack()) {
1091         EllipsisLoc = C->EllipsisLoc;
1092       } else {
1093         Diag(C->EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
1094           << SourceRange(C->Loc);
1095
1096         // Just ignore the ellipsis.
1097       }
1098     } else if (Var->isParameterPack()) {
1099       ContainsUnexpandedParameterPack = true;
1100     }
1101
1102     if (C->Init.isUsable()) {
1103       buildInitCaptureField(LSI, Var);
1104     } else {
1105       TryCaptureKind Kind = C->Kind == LCK_ByRef ? TryCapture_ExplicitByRef :
1106                                                    TryCapture_ExplicitByVal;
1107       tryCaptureVariable(Var, C->Loc, Kind, EllipsisLoc);
1108     }
1109   }
1110   finishLambdaExplicitCaptures(LSI);
1111
1112   LSI->ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
1113
1114   // Add lambda parameters into scope.
1115   addLambdaParameters(Method, CurScope);
1116
1117   // Enter a new evaluation context to insulate the lambda from any
1118   // cleanups from the enclosing full-expression.
1119   PushExpressionEvaluationContext(PotentiallyEvaluated);
1120 }
1121
1122 void Sema::ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,
1123                             bool IsInstantiation) {
1124   LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(FunctionScopes.back());
1125
1126   // Leave the expression-evaluation context.
1127   DiscardCleanupsInEvaluationContext();
1128   PopExpressionEvaluationContext();
1129
1130   // Leave the context of the lambda.
1131   if (!IsInstantiation)
1132     PopDeclContext();
1133
1134   // Finalize the lambda.
1135   CXXRecordDecl *Class = LSI->Lambda;
1136   Class->setInvalidDecl();
1137   SmallVector<Decl*, 4> Fields(Class->fields());
1138   ActOnFields(nullptr, Class->getLocation(), Class, Fields, SourceLocation(),
1139               SourceLocation(), nullptr);
1140   CheckCompletedCXXClass(Class);
1141
1142   PopFunctionScopeInfo();
1143 }
1144
1145 /// \brief Add a lambda's conversion to function pointer, as described in
1146 /// C++11 [expr.prim.lambda]p6.
1147 static void addFunctionPointerConversion(Sema &S,
1148                                          SourceRange IntroducerRange,
1149                                          CXXRecordDecl *Class,
1150                                          CXXMethodDecl *CallOperator) {
1151   // This conversion is explicitly disabled if the lambda's function has
1152   // pass_object_size attributes on any of its parameters.
1153   if (llvm::any_of(CallOperator->parameters(),
1154                    std::mem_fn(&ParmVarDecl::hasAttr<PassObjectSizeAttr>)))
1155     return;
1156
1157   // Add the conversion to function pointer.
1158   const FunctionProtoType *CallOpProto =
1159       CallOperator->getType()->getAs<FunctionProtoType>();
1160   const FunctionProtoType::ExtProtoInfo CallOpExtInfo =
1161       CallOpProto->getExtProtoInfo();
1162   QualType PtrToFunctionTy;
1163   QualType InvokerFunctionTy;
1164   {
1165     FunctionProtoType::ExtProtoInfo InvokerExtInfo = CallOpExtInfo;
1166     CallingConv CC = S.Context.getDefaultCallingConvention(
1167         CallOpProto->isVariadic(), /*IsCXXMethod=*/false);
1168     InvokerExtInfo.ExtInfo = InvokerExtInfo.ExtInfo.withCallingConv(CC);
1169     InvokerExtInfo.TypeQuals = 0;
1170     assert(InvokerExtInfo.RefQualifier == RQ_None &&
1171         "Lambda's call operator should not have a reference qualifier");
1172     InvokerFunctionTy =
1173         S.Context.getFunctionType(CallOpProto->getReturnType(),
1174                                   CallOpProto->getParamTypes(), InvokerExtInfo);
1175     PtrToFunctionTy = S.Context.getPointerType(InvokerFunctionTy);
1176   }
1177
1178   // Create the type of the conversion function.
1179   FunctionProtoType::ExtProtoInfo ConvExtInfo(
1180       S.Context.getDefaultCallingConvention(
1181       /*IsVariadic=*/false, /*IsCXXMethod=*/true));
1182   // The conversion function is always const.
1183   ConvExtInfo.TypeQuals = Qualifiers::Const;
1184   QualType ConvTy =
1185       S.Context.getFunctionType(PtrToFunctionTy, None, ConvExtInfo);
1186
1187   SourceLocation Loc = IntroducerRange.getBegin();
1188   DeclarationName ConversionName
1189     = S.Context.DeclarationNames.getCXXConversionFunctionName(
1190         S.Context.getCanonicalType(PtrToFunctionTy));
1191   DeclarationNameLoc ConvNameLoc;
1192   // Construct a TypeSourceInfo for the conversion function, and wire
1193   // all the parameters appropriately for the FunctionProtoTypeLoc
1194   // so that everything works during transformation/instantiation of
1195   // generic lambdas.
1196   // The main reason for wiring up the parameters of the conversion
1197   // function with that of the call operator is so that constructs
1198   // like the following work:
1199   // auto L = [](auto b) {                <-- 1
1200   //   return [](auto a) -> decltype(a) { <-- 2
1201   //      return a;
1202   //   };
1203   // };
1204   // int (*fp)(int) = L(5);
1205   // Because the trailing return type can contain DeclRefExprs that refer
1206   // to the original call operator's variables, we hijack the call
1207   // operators ParmVarDecls below.
1208   TypeSourceInfo *ConvNamePtrToFunctionTSI =
1209       S.Context.getTrivialTypeSourceInfo(PtrToFunctionTy, Loc);
1210   ConvNameLoc.NamedType.TInfo = ConvNamePtrToFunctionTSI;
1211
1212   // The conversion function is a conversion to a pointer-to-function.
1213   TypeSourceInfo *ConvTSI = S.Context.getTrivialTypeSourceInfo(ConvTy, Loc);
1214   FunctionProtoTypeLoc ConvTL =
1215       ConvTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>();
1216   // Get the result of the conversion function which is a pointer-to-function.
1217   PointerTypeLoc PtrToFunctionTL =
1218       ConvTL.getReturnLoc().getAs<PointerTypeLoc>();
1219   // Do the same for the TypeSourceInfo that is used to name the conversion
1220   // operator.
1221   PointerTypeLoc ConvNamePtrToFunctionTL =
1222       ConvNamePtrToFunctionTSI->getTypeLoc().getAs<PointerTypeLoc>();
1223
1224   // Get the underlying function types that the conversion function will
1225   // be converting to (should match the type of the call operator).
1226   FunctionProtoTypeLoc CallOpConvTL =
1227       PtrToFunctionTL.getPointeeLoc().getAs<FunctionProtoTypeLoc>();
1228   FunctionProtoTypeLoc CallOpConvNameTL =
1229     ConvNamePtrToFunctionTL.getPointeeLoc().getAs<FunctionProtoTypeLoc>();
1230
1231   // Wire up the FunctionProtoTypeLocs with the call operator's parameters.
1232   // These parameter's are essentially used to transform the name and
1233   // the type of the conversion operator.  By using the same parameters
1234   // as the call operator's we don't have to fix any back references that
1235   // the trailing return type of the call operator's uses (such as
1236   // decltype(some_type<decltype(a)>::type{} + decltype(a){}) etc.)
1237   // - we can simply use the return type of the call operator, and
1238   // everything should work.
1239   SmallVector<ParmVarDecl *, 4> InvokerParams;
1240   for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) {
1241     ParmVarDecl *From = CallOperator->getParamDecl(I);
1242
1243     InvokerParams.push_back(ParmVarDecl::Create(S.Context,
1244            // Temporarily add to the TU. This is set to the invoker below.
1245                                              S.Context.getTranslationUnitDecl(),
1246                                              From->getLocStart(),
1247                                              From->getLocation(),
1248                                              From->getIdentifier(),
1249                                              From->getType(),
1250                                              From->getTypeSourceInfo(),
1251                                              From->getStorageClass(),
1252                                              /*DefaultArg=*/nullptr));
1253     CallOpConvTL.setParam(I, From);
1254     CallOpConvNameTL.setParam(I, From);
1255   }
1256
1257   CXXConversionDecl *Conversion
1258     = CXXConversionDecl::Create(S.Context, Class, Loc,
1259                                 DeclarationNameInfo(ConversionName,
1260                                   Loc, ConvNameLoc),
1261                                 ConvTy,
1262                                 ConvTSI,
1263                                 /*isInline=*/true, /*isExplicit=*/false,
1264                                 /*isConstexpr=*/false,
1265                                 CallOperator->getBody()->getLocEnd());
1266   Conversion->setAccess(AS_public);
1267   Conversion->setImplicit(true);
1268
1269   if (Class->isGenericLambda()) {
1270     // Create a template version of the conversion operator, using the template
1271     // parameter list of the function call operator.
1272     FunctionTemplateDecl *TemplateCallOperator =
1273             CallOperator->getDescribedFunctionTemplate();
1274     FunctionTemplateDecl *ConversionTemplate =
1275                   FunctionTemplateDecl::Create(S.Context, Class,
1276                                       Loc, ConversionName,
1277                                       TemplateCallOperator->getTemplateParameters(),
1278                                       Conversion);
1279     ConversionTemplate->setAccess(AS_public);
1280     ConversionTemplate->setImplicit(true);
1281     Conversion->setDescribedFunctionTemplate(ConversionTemplate);
1282     Class->addDecl(ConversionTemplate);
1283   } else
1284     Class->addDecl(Conversion);
1285   // Add a non-static member function that will be the result of
1286   // the conversion with a certain unique ID.
1287   DeclarationName InvokerName = &S.Context.Idents.get(
1288                                                  getLambdaStaticInvokerName());
1289   // FIXME: Instead of passing in the CallOperator->getTypeSourceInfo()
1290   // we should get a prebuilt TrivialTypeSourceInfo from Context
1291   // using FunctionTy & Loc and get its TypeLoc as a FunctionProtoTypeLoc
1292   // then rewire the parameters accordingly, by hoisting up the InvokeParams
1293   // loop below and then use its Params to set Invoke->setParams(...) below.
1294   // This would avoid the 'const' qualifier of the calloperator from
1295   // contaminating the type of the invoker, which is currently adjusted
1296   // in SemaTemplateDeduction.cpp:DeduceTemplateArguments.  Fixing the
1297   // trailing return type of the invoker would require a visitor to rebuild
1298   // the trailing return type and adjusting all back DeclRefExpr's to refer
1299   // to the new static invoker parameters - not the call operator's.
1300   CXXMethodDecl *Invoke
1301     = CXXMethodDecl::Create(S.Context, Class, Loc,
1302                             DeclarationNameInfo(InvokerName, Loc),
1303                             InvokerFunctionTy,
1304                             CallOperator->getTypeSourceInfo(),
1305                             SC_Static, /*IsInline=*/true,
1306                             /*IsConstexpr=*/false,
1307                             CallOperator->getBody()->getLocEnd());
1308   for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I)
1309     InvokerParams[I]->setOwningFunction(Invoke);
1310   Invoke->setParams(InvokerParams);
1311   Invoke->setAccess(AS_private);
1312   Invoke->setImplicit(true);
1313   if (Class->isGenericLambda()) {
1314     FunctionTemplateDecl *TemplateCallOperator =
1315             CallOperator->getDescribedFunctionTemplate();
1316     FunctionTemplateDecl *StaticInvokerTemplate = FunctionTemplateDecl::Create(
1317                           S.Context, Class, Loc, InvokerName,
1318                           TemplateCallOperator->getTemplateParameters(),
1319                           Invoke);
1320     StaticInvokerTemplate->setAccess(AS_private);
1321     StaticInvokerTemplate->setImplicit(true);
1322     Invoke->setDescribedFunctionTemplate(StaticInvokerTemplate);
1323     Class->addDecl(StaticInvokerTemplate);
1324   } else
1325     Class->addDecl(Invoke);
1326 }
1327
1328 /// \brief Add a lambda's conversion to block pointer.
1329 static void addBlockPointerConversion(Sema &S,
1330                                       SourceRange IntroducerRange,
1331                                       CXXRecordDecl *Class,
1332                                       CXXMethodDecl *CallOperator) {
1333   const FunctionProtoType *Proto =
1334       CallOperator->getType()->getAs<FunctionProtoType>();
1335
1336   // The function type inside the block pointer type is the same as the call
1337   // operator with some tweaks. The calling convention is the default free
1338   // function convention, and the type qualifications are lost.
1339   FunctionProtoType::ExtProtoInfo BlockEPI = Proto->getExtProtoInfo();
1340   BlockEPI.ExtInfo =
1341       BlockEPI.ExtInfo.withCallingConv(S.Context.getDefaultCallingConvention(
1342           Proto->isVariadic(), /*IsCXXMethod=*/false));
1343   BlockEPI.TypeQuals = 0;
1344   QualType FunctionTy = S.Context.getFunctionType(
1345       Proto->getReturnType(), Proto->getParamTypes(), BlockEPI);
1346   QualType BlockPtrTy = S.Context.getBlockPointerType(FunctionTy);
1347
1348   FunctionProtoType::ExtProtoInfo ConversionEPI(
1349       S.Context.getDefaultCallingConvention(
1350           /*IsVariadic=*/false, /*IsCXXMethod=*/true));
1351   ConversionEPI.TypeQuals = Qualifiers::Const;
1352   QualType ConvTy = S.Context.getFunctionType(BlockPtrTy, None, ConversionEPI);
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 static ExprResult performLambdaVarCaptureInitialization(
1374     Sema &S, LambdaScopeInfo::Capture &Capture,
1375     FieldDecl *Field,
1376     SmallVectorImpl<VarDecl *> &ArrayIndexVars,
1377     SmallVectorImpl<unsigned> &ArrayIndexStarts) {
1378   assert(Capture.isVariableCapture() && "not a variable capture");
1379
1380   auto *Var = Capture.getVariable();
1381   SourceLocation Loc = Capture.getLocation();
1382
1383   // C++11 [expr.prim.lambda]p21:
1384   //   When the lambda-expression is evaluated, the entities that
1385   //   are captured by copy are used to direct-initialize each
1386   //   corresponding non-static data member of the resulting closure
1387   //   object. (For array members, the array elements are
1388   //   direct-initialized in increasing subscript order.) These
1389   //   initializations are performed in the (unspecified) order in
1390   //   which the non-static data members are declared.
1391
1392   // C++ [expr.prim.lambda]p12:
1393   //   An entity captured by a lambda-expression is odr-used (3.2) in
1394   //   the scope containing the lambda-expression.
1395   ExprResult RefResult = S.BuildDeclarationNameExpr(
1396       CXXScopeSpec(), DeclarationNameInfo(Var->getDeclName(), Loc), Var);
1397   if (RefResult.isInvalid())
1398     return ExprError();
1399   Expr *Ref = RefResult.get();
1400
1401   QualType FieldType = Field->getType();
1402
1403   // When the variable has array type, create index variables for each
1404   // dimension of the array. We use these index variables to subscript
1405   // the source array, and other clients (e.g., CodeGen) will perform
1406   // the necessary iteration with these index variables.
1407   //
1408   // FIXME: This is dumb. Add a proper AST representation for array
1409   // copy-construction and use it here.
1410   SmallVector<VarDecl *, 4> IndexVariables;
1411   QualType BaseType = FieldType;
1412   QualType SizeType = S.Context.getSizeType();
1413   ArrayIndexStarts.push_back(ArrayIndexVars.size());
1414   while (const ConstantArrayType *Array
1415                         = S.Context.getAsConstantArrayType(BaseType)) {
1416     // Create the iteration variable for this array index.
1417     IdentifierInfo *IterationVarName = nullptr;
1418     {
1419       SmallString<8> Str;
1420       llvm::raw_svector_ostream OS(Str);
1421       OS << "__i" << IndexVariables.size();
1422       IterationVarName = &S.Context.Idents.get(OS.str());
1423     }
1424     VarDecl *IterationVar = VarDecl::Create(
1425         S.Context, S.CurContext, Loc, Loc, IterationVarName, SizeType,
1426         S.Context.getTrivialTypeSourceInfo(SizeType, Loc), SC_None);
1427     IterationVar->setImplicit();
1428     IndexVariables.push_back(IterationVar);
1429     ArrayIndexVars.push_back(IterationVar);
1430
1431     // Create a reference to the iteration variable.
1432     ExprResult IterationVarRef =
1433         S.BuildDeclRefExpr(IterationVar, SizeType, VK_LValue, Loc);
1434     assert(!IterationVarRef.isInvalid() &&
1435            "Reference to invented variable cannot fail!");
1436     IterationVarRef = S.DefaultLvalueConversion(IterationVarRef.get());
1437     assert(!IterationVarRef.isInvalid() &&
1438            "Conversion of invented variable cannot fail!");
1439
1440     // Subscript the array with this iteration variable.
1441     ExprResult Subscript =
1442         S.CreateBuiltinArraySubscriptExpr(Ref, Loc, IterationVarRef.get(), Loc);
1443     if (Subscript.isInvalid())
1444       return ExprError();
1445
1446     Ref = Subscript.get();
1447     BaseType = Array->getElementType();
1448   }
1449
1450   // Construct the entity that we will be initializing. For an array, this
1451   // will be first element in the array, which may require several levels
1452   // of array-subscript entities.
1453   SmallVector<InitializedEntity, 4> Entities;
1454   Entities.reserve(1 + IndexVariables.size());
1455   Entities.push_back(InitializedEntity::InitializeLambdaCapture(
1456       Var->getIdentifier(), FieldType, Loc));
1457   for (unsigned I = 0, N = IndexVariables.size(); I != N; ++I)
1458     Entities.push_back(
1459         InitializedEntity::InitializeElement(S.Context, 0, Entities.back()));
1460
1461   InitializationKind InitKind = InitializationKind::CreateDirect(Loc, Loc, Loc);
1462   InitializationSequence Init(S, Entities.back(), InitKind, Ref);
1463   return Init.Perform(S, Entities.back(), InitKind, Ref);
1464 }
1465
1466 ExprResult Sema::ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body,
1467                                  Scope *CurScope) {
1468   LambdaScopeInfo LSI = *cast<LambdaScopeInfo>(FunctionScopes.back());
1469   ActOnFinishFunctionBody(LSI.CallOperator, Body);
1470   return BuildLambdaExpr(StartLoc, Body->getLocEnd(), &LSI);
1471 }
1472
1473 static LambdaCaptureDefault
1474 mapImplicitCaptureStyle(CapturingScopeInfo::ImplicitCaptureStyle ICS) {
1475   switch (ICS) {
1476   case CapturingScopeInfo::ImpCap_None:
1477     return LCD_None;
1478   case CapturingScopeInfo::ImpCap_LambdaByval:
1479     return LCD_ByCopy;
1480   case CapturingScopeInfo::ImpCap_CapturedRegion:
1481   case CapturingScopeInfo::ImpCap_LambdaByref:
1482     return LCD_ByRef;
1483   case CapturingScopeInfo::ImpCap_Block:
1484     llvm_unreachable("block capture in lambda");
1485   }
1486   llvm_unreachable("Unknown implicit capture style");
1487 }
1488
1489 ExprResult Sema::BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc,
1490                                  LambdaScopeInfo *LSI) {
1491   // Collect information from the lambda scope.
1492   SmallVector<LambdaCapture, 4> Captures;
1493   SmallVector<Expr *, 4> CaptureInits;
1494   SourceLocation CaptureDefaultLoc = LSI->CaptureDefaultLoc;
1495   LambdaCaptureDefault CaptureDefault =
1496       mapImplicitCaptureStyle(LSI->ImpCaptureStyle);
1497   CXXRecordDecl *Class;
1498   CXXMethodDecl *CallOperator;
1499   SourceRange IntroducerRange;
1500   bool ExplicitParams;
1501   bool ExplicitResultType;
1502   CleanupInfo LambdaCleanup;
1503   bool ContainsUnexpandedParameterPack;
1504   SmallVector<VarDecl *, 4> ArrayIndexVars;
1505   SmallVector<unsigned, 4> ArrayIndexStarts;
1506   {
1507     CallOperator = LSI->CallOperator;
1508     Class = LSI->Lambda;
1509     IntroducerRange = LSI->IntroducerRange;
1510     ExplicitParams = LSI->ExplicitParams;
1511     ExplicitResultType = !LSI->HasImplicitReturnType;
1512     LambdaCleanup = LSI->Cleanup;
1513     ContainsUnexpandedParameterPack = LSI->ContainsUnexpandedParameterPack;
1514
1515     CallOperator->setLexicalDeclContext(Class);
1516     Decl *TemplateOrNonTemplateCallOperatorDecl =
1517         CallOperator->getDescribedFunctionTemplate()
1518         ? CallOperator->getDescribedFunctionTemplate()
1519         : cast<Decl>(CallOperator);
1520
1521     TemplateOrNonTemplateCallOperatorDecl->setLexicalDeclContext(Class);
1522     Class->addDecl(TemplateOrNonTemplateCallOperatorDecl);
1523
1524     PopExpressionEvaluationContext();
1525
1526     // Translate captures.
1527     auto CurField = Class->field_begin();
1528     for (unsigned I = 0, N = LSI->Captures.size(); I != N; ++I, ++CurField) {
1529       LambdaScopeInfo::Capture From = LSI->Captures[I];
1530       assert(!From.isBlockCapture() && "Cannot capture __block variables");
1531       bool IsImplicit = I >= LSI->NumExplicitCaptures;
1532
1533       // Handle 'this' capture.
1534       if (From.isThisCapture()) {
1535         Captures.push_back(
1536             LambdaCapture(From.getLocation(), IsImplicit,
1537                           From.isCopyCapture() ? LCK_StarThis : LCK_This));
1538         CaptureInits.push_back(From.getInitExpr());
1539         ArrayIndexStarts.push_back(ArrayIndexVars.size());
1540         continue;
1541       }
1542       if (From.isVLATypeCapture()) {
1543         Captures.push_back(
1544             LambdaCapture(From.getLocation(), IsImplicit, LCK_VLAType));
1545         CaptureInits.push_back(nullptr);
1546         ArrayIndexStarts.push_back(ArrayIndexVars.size());
1547         continue;
1548       }
1549
1550       VarDecl *Var = From.getVariable();
1551       LambdaCaptureKind Kind = From.isCopyCapture() ? LCK_ByCopy : LCK_ByRef;
1552       Captures.push_back(LambdaCapture(From.getLocation(), IsImplicit, Kind,
1553                                        Var, From.getEllipsisLoc()));
1554       Expr *Init = From.getInitExpr();
1555       if (!Init) {
1556         auto InitResult = performLambdaVarCaptureInitialization(
1557             *this, From, *CurField, ArrayIndexVars, ArrayIndexStarts);
1558         if (InitResult.isInvalid())
1559           return ExprError();
1560         Init = InitResult.get();
1561       } else {
1562         ArrayIndexStarts.push_back(ArrayIndexVars.size());
1563       }
1564       CaptureInits.push_back(Init);
1565     }
1566
1567     // C++11 [expr.prim.lambda]p6:
1568     //   The closure type for a lambda-expression with no lambda-capture
1569     //   has a public non-virtual non-explicit const conversion function
1570     //   to pointer to function having the same parameter and return
1571     //   types as the closure type's function call operator.
1572     if (Captures.empty() && CaptureDefault == LCD_None)
1573       addFunctionPointerConversion(*this, IntroducerRange, Class,
1574                                    CallOperator);
1575
1576     // Objective-C++:
1577     //   The closure type for a lambda-expression has a public non-virtual
1578     //   non-explicit const conversion function to a block pointer having the
1579     //   same parameter and return types as the closure type's function call
1580     //   operator.
1581     // FIXME: Fix generic lambda to block conversions.
1582     if (getLangOpts().Blocks && getLangOpts().ObjC1 &&
1583                                               !Class->isGenericLambda())
1584       addBlockPointerConversion(*this, IntroducerRange, Class, CallOperator);
1585
1586     // Finalize the lambda class.
1587     SmallVector<Decl*, 4> Fields(Class->fields());
1588     ActOnFields(nullptr, Class->getLocation(), Class, Fields, SourceLocation(),
1589                 SourceLocation(), nullptr);
1590     CheckCompletedCXXClass(Class);
1591   }
1592
1593   Cleanup.mergeFrom(LambdaCleanup);
1594
1595   LambdaExpr *Lambda = LambdaExpr::Create(Context, Class, IntroducerRange,
1596                                           CaptureDefault, CaptureDefaultLoc,
1597                                           Captures,
1598                                           ExplicitParams, ExplicitResultType,
1599                                           CaptureInits, ArrayIndexVars,
1600                                           ArrayIndexStarts, EndLoc,
1601                                           ContainsUnexpandedParameterPack);
1602   // If the lambda expression's call operator is not explicitly marked constexpr
1603   // and we are not in a dependent context, analyze the call operator to infer
1604   // its constexpr-ness, supressing diagnostics while doing so.
1605   if (getLangOpts().CPlusPlus1z && !CallOperator->isInvalidDecl() &&
1606       !CallOperator->isConstexpr() &&
1607       !Class->getDeclContext()->isDependentContext()) {
1608     TentativeAnalysisScope DiagnosticScopeGuard(*this);
1609     CallOperator->setConstexpr(
1610         CheckConstexprFunctionDecl(CallOperator) &&
1611         CheckConstexprFunctionBody(CallOperator, CallOperator->getBody()));
1612   }
1613
1614   if (!CurContext->isDependentContext()) {
1615     switch (ExprEvalContexts.back().Context) {
1616     // C++11 [expr.prim.lambda]p2:
1617     //   A lambda-expression shall not appear in an unevaluated operand
1618     //   (Clause 5).
1619     case Unevaluated:
1620     case UnevaluatedAbstract:
1621     // C++1y [expr.const]p2:
1622     //   A conditional-expression e is a core constant expression unless the
1623     //   evaluation of e, following the rules of the abstract machine, would
1624     //   evaluate [...] a lambda-expression.
1625     //
1626     // This is technically incorrect, there are some constant evaluated contexts
1627     // where this should be allowed.  We should probably fix this when DR1607 is
1628     // ratified, it lays out the exact set of conditions where we shouldn't
1629     // allow a lambda-expression.
1630     case ConstantEvaluated:
1631       // We don't actually diagnose this case immediately, because we
1632       // could be within a context where we might find out later that
1633       // the expression is potentially evaluated (e.g., for typeid).
1634       ExprEvalContexts.back().Lambdas.push_back(Lambda);
1635       break;
1636
1637     case DiscardedStatement:
1638     case PotentiallyEvaluated:
1639     case PotentiallyEvaluatedIfUsed:
1640       break;
1641     }
1642   }
1643
1644   return MaybeBindToTemporary(Lambda);
1645 }
1646
1647 ExprResult Sema::BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
1648                                                SourceLocation ConvLocation,
1649                                                CXXConversionDecl *Conv,
1650                                                Expr *Src) {
1651   // Make sure that the lambda call operator is marked used.
1652   CXXRecordDecl *Lambda = Conv->getParent();
1653   CXXMethodDecl *CallOperator
1654     = cast<CXXMethodDecl>(
1655         Lambda->lookup(
1656           Context.DeclarationNames.getCXXOperatorName(OO_Call)).front());
1657   CallOperator->setReferenced();
1658   CallOperator->markUsed(Context);
1659
1660   ExprResult Init = PerformCopyInitialization(
1661                       InitializedEntity::InitializeBlock(ConvLocation,
1662                                                          Src->getType(),
1663                                                          /*NRVO=*/false),
1664                       CurrentLocation, Src);
1665   if (!Init.isInvalid())
1666     Init = ActOnFinishFullExpr(Init.get());
1667
1668   if (Init.isInvalid())
1669     return ExprError();
1670
1671   // Create the new block to be returned.
1672   BlockDecl *Block = BlockDecl::Create(Context, CurContext, ConvLocation);
1673
1674   // Set the type information.
1675   Block->setSignatureAsWritten(CallOperator->getTypeSourceInfo());
1676   Block->setIsVariadic(CallOperator->isVariadic());
1677   Block->setBlockMissingReturnType(false);
1678
1679   // Add parameters.
1680   SmallVector<ParmVarDecl *, 4> BlockParams;
1681   for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) {
1682     ParmVarDecl *From = CallOperator->getParamDecl(I);
1683     BlockParams.push_back(ParmVarDecl::Create(Context, Block,
1684                                               From->getLocStart(),
1685                                               From->getLocation(),
1686                                               From->getIdentifier(),
1687                                               From->getType(),
1688                                               From->getTypeSourceInfo(),
1689                                               From->getStorageClass(),
1690                                               /*DefaultArg=*/nullptr));
1691   }
1692   Block->setParams(BlockParams);
1693
1694   Block->setIsConversionFromLambda(true);
1695
1696   // Add capture. The capture uses a fake variable, which doesn't correspond
1697   // to any actual memory location. However, the initializer copy-initializes
1698   // the lambda object.
1699   TypeSourceInfo *CapVarTSI =
1700       Context.getTrivialTypeSourceInfo(Src->getType());
1701   VarDecl *CapVar = VarDecl::Create(Context, Block, ConvLocation,
1702                                     ConvLocation, nullptr,
1703                                     Src->getType(), CapVarTSI,
1704                                     SC_None);
1705   BlockDecl::Capture Capture(/*Variable=*/CapVar, /*ByRef=*/false,
1706                              /*Nested=*/false, /*Copy=*/Init.get());
1707   Block->setCaptures(Context, Capture, /*CapturesCXXThis=*/false);
1708
1709   // Add a fake function body to the block. IR generation is responsible
1710   // for filling in the actual body, which cannot be expressed as an AST.
1711   Block->setBody(new (Context) CompoundStmt(ConvLocation));
1712
1713   // Create the block literal expression.
1714   Expr *BuildBlock = new (Context) BlockExpr(Block, Conv->getConversionType());
1715   ExprCleanupObjects.push_back(Block);
1716   Cleanup.setExprNeedsCleanups(true);
1717
1718   return BuildBlock;
1719 }