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