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   // Attributes on the lambda apply to the method.
918   ProcessDeclAttributes(CurScope, Method, ParamInfo);
919 
920   // CUDA lambdas get implicit attributes based on the scope in which they're
921   // declared.
922   if (getLangOpts().CUDA)
923     CUDASetLambdaAttrs(Method);
924 
925   // Introduce the function call operator as the current declaration context.
926   PushDeclContext(CurScope, Method);
927 
928   // Build the lambda scope.
929   buildLambdaScope(LSI, Method, Intro.Range, Intro.Default, Intro.DefaultLoc,
930                    ExplicitParams, ExplicitResultType, !Method->isConst());
931 
932   // C++11 [expr.prim.lambda]p9:
933   //   A lambda-expression whose smallest enclosing scope is a block scope is a
934   //   local lambda expression; any other lambda expression shall not have a
935   //   capture-default or simple-capture in its lambda-introducer.
936   //
937   // For simple-captures, this is covered by the check below that any named
938   // entity is a variable that can be captured.
939   //
940   // For DR1632, we also allow a capture-default in any context where we can
941   // odr-use 'this' (in particular, in a default initializer for a non-static
942   // data member).
943   if (Intro.Default != LCD_None && !Class->getParent()->isFunctionOrMethod() &&
944       (getCurrentThisType().isNull() ||
945        CheckCXXThisCapture(SourceLocation(), /*Explicit*/true,
946                            /*BuildAndDiagnose*/false)))
947     Diag(Intro.DefaultLoc, diag::err_capture_default_non_local);
948 
949   // Distinct capture names, for diagnostics.
950   llvm::SmallSet<IdentifierInfo*, 8> CaptureNames;
951 
952   // Handle explicit captures.
953   SourceLocation PrevCaptureLoc
954     = Intro.Default == LCD_None? Intro.Range.getBegin() : Intro.DefaultLoc;
955   for (auto C = Intro.Captures.begin(), E = Intro.Captures.end(); C != E;
956        PrevCaptureLoc = C->Loc, ++C) {
957     if (C->Kind == LCK_This || C->Kind == LCK_StarThis) {
958       if (C->Kind == LCK_StarThis)
959         Diag(C->Loc, !getLangOpts().CPlusPlus17
960                              ? diag::ext_star_this_lambda_capture_cxx17
961                              : diag::warn_cxx14_compat_star_this_lambda_capture);
962 
963       // C++11 [expr.prim.lambda]p8:
964       //   An identifier or this shall not appear more than once in a
965       //   lambda-capture.
966       if (LSI->isCXXThisCaptured()) {
967         Diag(C->Loc, diag::err_capture_more_than_once)
968             << "'this'" << SourceRange(LSI->getCXXThisCapture().getLocation())
969             << FixItHint::CreateRemoval(
970                    SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
971         continue;
972       }
973 
974       // C++2a [expr.prim.lambda]p8:
975       //  If a lambda-capture includes a capture-default that is =,
976       //  each simple-capture of that lambda-capture shall be of the form
977       //  "&identifier", "this", or "* this". [ Note: The form [&,this] is
978       //  redundant but accepted for compatibility with ISO C++14. --end note ]
979       if (Intro.Default == LCD_ByCopy && C->Kind != LCK_StarThis)
980         Diag(C->Loc, !getLangOpts().CPlusPlus2a
981                          ? diag::ext_equals_this_lambda_capture_cxx2a
982                          : diag::warn_cxx17_compat_equals_this_lambda_capture);
983 
984       // C++11 [expr.prim.lambda]p12:
985       //   If this is captured by a local lambda expression, its nearest
986       //   enclosing function shall be a non-static member function.
987       QualType ThisCaptureType = getCurrentThisType();
988       if (ThisCaptureType.isNull()) {
989         Diag(C->Loc, diag::err_this_capture) << true;
990         continue;
991       }
992 
993       CheckCXXThisCapture(C->Loc, /*Explicit=*/true, /*BuildAndDiagnose*/ true,
994                           /*FunctionScopeIndexToStopAtPtr*/ nullptr,
995                           C->Kind == LCK_StarThis);
996       continue;
997     }
998 
999     assert(C->Id && "missing identifier for capture");
1000 
1001     if (C->Init.isInvalid())
1002       continue;
1003 
1004     VarDecl *Var = nullptr;
1005     if (C->Init.isUsable()) {
1006       Diag(C->Loc, getLangOpts().CPlusPlus14
1007                        ? diag::warn_cxx11_compat_init_capture
1008                        : diag::ext_init_capture);
1009 
1010       if (C->Init.get()->containsUnexpandedParameterPack())
1011         ContainsUnexpandedParameterPack = true;
1012       // If the initializer expression is usable, but the InitCaptureType
1013       // is not, then an error has occurred - so ignore the capture for now.
1014       // for e.g., [n{0}] { }; <-- if no <initializer_list> is included.
1015       // FIXME: we should create the init capture variable and mark it invalid
1016       // in this case.
1017       if (C->InitCaptureType.get().isNull())
1018         continue;
1019 
1020       unsigned InitStyle;
1021       switch (C->InitKind) {
1022       case LambdaCaptureInitKind::NoInit:
1023         llvm_unreachable("not an init-capture?");
1024       case LambdaCaptureInitKind::CopyInit:
1025         InitStyle = VarDecl::CInit;
1026         break;
1027       case LambdaCaptureInitKind::DirectInit:
1028         InitStyle = VarDecl::CallInit;
1029         break;
1030       case LambdaCaptureInitKind::ListInit:
1031         InitStyle = VarDecl::ListInit;
1032         break;
1033       }
1034       Var = createLambdaInitCaptureVarDecl(C->Loc, C->InitCaptureType.get(),
1035                                            C->Id, InitStyle, C->Init.get());
1036       // C++1y [expr.prim.lambda]p11:
1037       //   An init-capture behaves as if it declares and explicitly
1038       //   captures a variable [...] whose declarative region is the
1039       //   lambda-expression's compound-statement
1040       if (Var)
1041         PushOnScopeChains(Var, CurScope, false);
1042     } else {
1043       assert(C->InitKind == LambdaCaptureInitKind::NoInit &&
1044              "init capture has valid but null init?");
1045 
1046       // C++11 [expr.prim.lambda]p8:
1047       //   If a lambda-capture includes a capture-default that is &, the
1048       //   identifiers in the lambda-capture shall not be preceded by &.
1049       //   If a lambda-capture includes a capture-default that is =, [...]
1050       //   each identifier it contains shall be preceded by &.
1051       if (C->Kind == LCK_ByRef && Intro.Default == LCD_ByRef) {
1052         Diag(C->Loc, diag::err_reference_capture_with_reference_default)
1053             << FixItHint::CreateRemoval(
1054                 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
1055         continue;
1056       } else if (C->Kind == LCK_ByCopy && Intro.Default == LCD_ByCopy) {
1057         Diag(C->Loc, diag::err_copy_capture_with_copy_default)
1058             << FixItHint::CreateRemoval(
1059                 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
1060         continue;
1061       }
1062 
1063       // C++11 [expr.prim.lambda]p10:
1064       //   The identifiers in a capture-list are looked up using the usual
1065       //   rules for unqualified name lookup (3.4.1)
1066       DeclarationNameInfo Name(C->Id, C->Loc);
1067       LookupResult R(*this, Name, LookupOrdinaryName);
1068       LookupName(R, CurScope);
1069       if (R.isAmbiguous())
1070         continue;
1071       if (R.empty()) {
1072         // FIXME: Disable corrections that would add qualification?
1073         CXXScopeSpec ScopeSpec;
1074         if (DiagnoseEmptyLookup(CurScope, ScopeSpec, R,
1075                                 llvm::make_unique<DeclFilterCCC<VarDecl>>()))
1076           continue;
1077       }
1078 
1079       Var = R.getAsSingle<VarDecl>();
1080       if (Var && DiagnoseUseOfDecl(Var, C->Loc))
1081         continue;
1082     }
1083 
1084     // C++11 [expr.prim.lambda]p8:
1085     //   An identifier or this shall not appear more than once in a
1086     //   lambda-capture.
1087     if (!CaptureNames.insert(C->Id).second) {
1088       if (Var && LSI->isCaptured(Var)) {
1089         Diag(C->Loc, diag::err_capture_more_than_once)
1090             << C->Id << SourceRange(LSI->getCapture(Var).getLocation())
1091             << FixItHint::CreateRemoval(
1092                    SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
1093       } else
1094         // Previous capture captured something different (one or both was
1095         // an init-cpature): no fixit.
1096         Diag(C->Loc, diag::err_capture_more_than_once) << C->Id;
1097       continue;
1098     }
1099 
1100     // C++11 [expr.prim.lambda]p10:
1101     //   [...] each such lookup shall find a variable with automatic storage
1102     //   duration declared in the reaching scope of the local lambda expression.
1103     // Note that the 'reaching scope' check happens in tryCaptureVariable().
1104     if (!Var) {
1105       Diag(C->Loc, diag::err_capture_does_not_name_variable) << C->Id;
1106       continue;
1107     }
1108 
1109     // Ignore invalid decls; they'll just confuse the code later.
1110     if (Var->isInvalidDecl())
1111       continue;
1112 
1113     if (!Var->hasLocalStorage()) {
1114       Diag(C->Loc, diag::err_capture_non_automatic_variable) << C->Id;
1115       Diag(Var->getLocation(), diag::note_previous_decl) << C->Id;
1116       continue;
1117     }
1118 
1119     // C++11 [expr.prim.lambda]p23:
1120     //   A capture followed by an ellipsis is a pack expansion (14.5.3).
1121     SourceLocation EllipsisLoc;
1122     if (C->EllipsisLoc.isValid()) {
1123       if (Var->isParameterPack()) {
1124         EllipsisLoc = C->EllipsisLoc;
1125       } else {
1126         Diag(C->EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
1127           << SourceRange(C->Loc);
1128 
1129         // Just ignore the ellipsis.
1130       }
1131     } else if (Var->isParameterPack()) {
1132       ContainsUnexpandedParameterPack = true;
1133     }
1134 
1135     if (C->Init.isUsable()) {
1136       buildInitCaptureField(LSI, Var);
1137     } else {
1138       TryCaptureKind Kind = C->Kind == LCK_ByRef ? TryCapture_ExplicitByRef :
1139                                                    TryCapture_ExplicitByVal;
1140       tryCaptureVariable(Var, C->Loc, Kind, EllipsisLoc);
1141     }
1142   }
1143   finishLambdaExplicitCaptures(LSI);
1144 
1145   LSI->ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
1146 
1147   // Add lambda parameters into scope.
1148   addLambdaParameters(Method, CurScope);
1149 
1150   // Enter a new evaluation context to insulate the lambda from any
1151   // cleanups from the enclosing full-expression.
1152   PushExpressionEvaluationContext(
1153       ExpressionEvaluationContext::PotentiallyEvaluated);
1154 }
1155 
1156 void Sema::ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,
1157                             bool IsInstantiation) {
1158   LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(FunctionScopes.back());
1159 
1160   // Leave the expression-evaluation context.
1161   DiscardCleanupsInEvaluationContext();
1162   PopExpressionEvaluationContext();
1163 
1164   // Leave the context of the lambda.
1165   if (!IsInstantiation)
1166     PopDeclContext();
1167 
1168   // Finalize the lambda.
1169   CXXRecordDecl *Class = LSI->Lambda;
1170   Class->setInvalidDecl();
1171   SmallVector<Decl*, 4> Fields(Class->fields());
1172   ActOnFields(nullptr, Class->getLocation(), Class, Fields, SourceLocation(),
1173               SourceLocation(), nullptr);
1174   CheckCompletedCXXClass(Class);
1175 
1176   PopFunctionScopeInfo();
1177 }
1178 
1179 QualType Sema::getLambdaConversionFunctionResultType(
1180     const FunctionProtoType *CallOpProto) {
1181   // The function type inside the pointer type is the same as the call
1182   // operator with some tweaks. The calling convention is the default free
1183   // function convention, and the type qualifications are lost.
1184   const FunctionProtoType::ExtProtoInfo CallOpExtInfo =
1185       CallOpProto->getExtProtoInfo();
1186   FunctionProtoType::ExtProtoInfo InvokerExtInfo = CallOpExtInfo;
1187   CallingConv CC = Context.getDefaultCallingConvention(
1188       CallOpProto->isVariadic(), /*IsCXXMethod=*/false);
1189   InvokerExtInfo.ExtInfo = InvokerExtInfo.ExtInfo.withCallingConv(CC);
1190   InvokerExtInfo.TypeQuals = 0;
1191   assert(InvokerExtInfo.RefQualifier == RQ_None &&
1192       "Lambda's call operator should not have a reference qualifier");
1193   return Context.getFunctionType(CallOpProto->getReturnType(),
1194                                  CallOpProto->getParamTypes(), InvokerExtInfo);
1195 }
1196 
1197 /// Add a lambda's conversion to function pointer, as described in
1198 /// C++11 [expr.prim.lambda]p6.
1199 static void addFunctionPointerConversion(Sema &S,
1200                                          SourceRange IntroducerRange,
1201                                          CXXRecordDecl *Class,
1202                                          CXXMethodDecl *CallOperator) {
1203   // This conversion is explicitly disabled if the lambda's function has
1204   // pass_object_size attributes on any of its parameters.
1205   auto HasPassObjectSizeAttr = [](const ParmVarDecl *P) {
1206     return P->hasAttr<PassObjectSizeAttr>();
1207   };
1208   if (llvm::any_of(CallOperator->parameters(), HasPassObjectSizeAttr))
1209     return;
1210 
1211   // Add the conversion to function pointer.
1212   QualType InvokerFunctionTy = S.getLambdaConversionFunctionResultType(
1213       CallOperator->getType()->castAs<FunctionProtoType>());
1214   QualType PtrToFunctionTy = S.Context.getPointerType(InvokerFunctionTy);
1215 
1216   // Create the type of the conversion function.
1217   FunctionProtoType::ExtProtoInfo ConvExtInfo(
1218       S.Context.getDefaultCallingConvention(
1219       /*IsVariadic=*/false, /*IsCXXMethod=*/true));
1220   // The conversion function is always const.
1221   ConvExtInfo.TypeQuals = Qualifiers::Const;
1222   QualType ConvTy =
1223       S.Context.getFunctionType(PtrToFunctionTy, None, ConvExtInfo);
1224 
1225   SourceLocation Loc = IntroducerRange.getBegin();
1226   DeclarationName ConversionName
1227     = S.Context.DeclarationNames.getCXXConversionFunctionName(
1228         S.Context.getCanonicalType(PtrToFunctionTy));
1229   DeclarationNameLoc ConvNameLoc;
1230   // Construct a TypeSourceInfo for the conversion function, and wire
1231   // all the parameters appropriately for the FunctionProtoTypeLoc
1232   // so that everything works during transformation/instantiation of
1233   // generic lambdas.
1234   // The main reason for wiring up the parameters of the conversion
1235   // function with that of the call operator is so that constructs
1236   // like the following work:
1237   // auto L = [](auto b) {                <-- 1
1238   //   return [](auto a) -> decltype(a) { <-- 2
1239   //      return a;
1240   //   };
1241   // };
1242   // int (*fp)(int) = L(5);
1243   // Because the trailing return type can contain DeclRefExprs that refer
1244   // to the original call operator's variables, we hijack the call
1245   // operators ParmVarDecls below.
1246   TypeSourceInfo *ConvNamePtrToFunctionTSI =
1247       S.Context.getTrivialTypeSourceInfo(PtrToFunctionTy, Loc);
1248   ConvNameLoc.NamedType.TInfo = ConvNamePtrToFunctionTSI;
1249 
1250   // The conversion function is a conversion to a pointer-to-function.
1251   TypeSourceInfo *ConvTSI = S.Context.getTrivialTypeSourceInfo(ConvTy, Loc);
1252   FunctionProtoTypeLoc ConvTL =
1253       ConvTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>();
1254   // Get the result of the conversion function which is a pointer-to-function.
1255   PointerTypeLoc PtrToFunctionTL =
1256       ConvTL.getReturnLoc().getAs<PointerTypeLoc>();
1257   // Do the same for the TypeSourceInfo that is used to name the conversion
1258   // operator.
1259   PointerTypeLoc ConvNamePtrToFunctionTL =
1260       ConvNamePtrToFunctionTSI->getTypeLoc().getAs<PointerTypeLoc>();
1261 
1262   // Get the underlying function types that the conversion function will
1263   // be converting to (should match the type of the call operator).
1264   FunctionProtoTypeLoc CallOpConvTL =
1265       PtrToFunctionTL.getPointeeLoc().getAs<FunctionProtoTypeLoc>();
1266   FunctionProtoTypeLoc CallOpConvNameTL =
1267     ConvNamePtrToFunctionTL.getPointeeLoc().getAs<FunctionProtoTypeLoc>();
1268 
1269   // Wire up the FunctionProtoTypeLocs with the call operator's parameters.
1270   // These parameter's are essentially used to transform the name and
1271   // the type of the conversion operator.  By using the same parameters
1272   // as the call operator's we don't have to fix any back references that
1273   // the trailing return type of the call operator's uses (such as
1274   // decltype(some_type<decltype(a)>::type{} + decltype(a){}) etc.)
1275   // - we can simply use the return type of the call operator, and
1276   // everything should work.
1277   SmallVector<ParmVarDecl *, 4> InvokerParams;
1278   for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) {
1279     ParmVarDecl *From = CallOperator->getParamDecl(I);
1280 
1281     InvokerParams.push_back(ParmVarDecl::Create(S.Context,
1282            // Temporarily add to the TU. This is set to the invoker below.
1283                                              S.Context.getTranslationUnitDecl(),
1284                                              From->getLocStart(),
1285                                              From->getLocation(),
1286                                              From->getIdentifier(),
1287                                              From->getType(),
1288                                              From->getTypeSourceInfo(),
1289                                              From->getStorageClass(),
1290                                              /*DefaultArg=*/nullptr));
1291     CallOpConvTL.setParam(I, From);
1292     CallOpConvNameTL.setParam(I, From);
1293   }
1294 
1295   CXXConversionDecl *Conversion
1296     = CXXConversionDecl::Create(S.Context, Class, Loc,
1297                                 DeclarationNameInfo(ConversionName,
1298                                   Loc, ConvNameLoc),
1299                                 ConvTy,
1300                                 ConvTSI,
1301                                 /*isInline=*/true, /*isExplicit=*/false,
1302                                 /*isConstexpr=*/S.getLangOpts().CPlusPlus17,
1303                                 CallOperator->getBody()->getLocEnd());
1304   Conversion->setAccess(AS_public);
1305   Conversion->setImplicit(true);
1306 
1307   if (Class->isGenericLambda()) {
1308     // Create a template version of the conversion operator, using the template
1309     // parameter list of the function call operator.
1310     FunctionTemplateDecl *TemplateCallOperator =
1311             CallOperator->getDescribedFunctionTemplate();
1312     FunctionTemplateDecl *ConversionTemplate =
1313                   FunctionTemplateDecl::Create(S.Context, Class,
1314                                       Loc, ConversionName,
1315                                       TemplateCallOperator->getTemplateParameters(),
1316                                       Conversion);
1317     ConversionTemplate->setAccess(AS_public);
1318     ConversionTemplate->setImplicit(true);
1319     Conversion->setDescribedFunctionTemplate(ConversionTemplate);
1320     Class->addDecl(ConversionTemplate);
1321   } else
1322     Class->addDecl(Conversion);
1323   // Add a non-static member function that will be the result of
1324   // the conversion with a certain unique ID.
1325   DeclarationName InvokerName = &S.Context.Idents.get(
1326                                                  getLambdaStaticInvokerName());
1327   // FIXME: Instead of passing in the CallOperator->getTypeSourceInfo()
1328   // we should get a prebuilt TrivialTypeSourceInfo from Context
1329   // using FunctionTy & Loc and get its TypeLoc as a FunctionProtoTypeLoc
1330   // then rewire the parameters accordingly, by hoisting up the InvokeParams
1331   // loop below and then use its Params to set Invoke->setParams(...) below.
1332   // This would avoid the 'const' qualifier of the calloperator from
1333   // contaminating the type of the invoker, which is currently adjusted
1334   // in SemaTemplateDeduction.cpp:DeduceTemplateArguments.  Fixing the
1335   // trailing return type of the invoker would require a visitor to rebuild
1336   // the trailing return type and adjusting all back DeclRefExpr's to refer
1337   // to the new static invoker parameters - not the call operator's.
1338   CXXMethodDecl *Invoke
1339     = CXXMethodDecl::Create(S.Context, Class, Loc,
1340                             DeclarationNameInfo(InvokerName, Loc),
1341                             InvokerFunctionTy,
1342                             CallOperator->getTypeSourceInfo(),
1343                             SC_Static, /*IsInline=*/true,
1344                             /*IsConstexpr=*/false,
1345                             CallOperator->getBody()->getLocEnd());
1346   for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I)
1347     InvokerParams[I]->setOwningFunction(Invoke);
1348   Invoke->setParams(InvokerParams);
1349   Invoke->setAccess(AS_private);
1350   Invoke->setImplicit(true);
1351   if (Class->isGenericLambda()) {
1352     FunctionTemplateDecl *TemplateCallOperator =
1353             CallOperator->getDescribedFunctionTemplate();
1354     FunctionTemplateDecl *StaticInvokerTemplate = FunctionTemplateDecl::Create(
1355                           S.Context, Class, Loc, InvokerName,
1356                           TemplateCallOperator->getTemplateParameters(),
1357                           Invoke);
1358     StaticInvokerTemplate->setAccess(AS_private);
1359     StaticInvokerTemplate->setImplicit(true);
1360     Invoke->setDescribedFunctionTemplate(StaticInvokerTemplate);
1361     Class->addDecl(StaticInvokerTemplate);
1362   } else
1363     Class->addDecl(Invoke);
1364 }
1365 
1366 /// Add a lambda's conversion to block pointer.
1367 static void addBlockPointerConversion(Sema &S,
1368                                       SourceRange IntroducerRange,
1369                                       CXXRecordDecl *Class,
1370                                       CXXMethodDecl *CallOperator) {
1371   QualType FunctionTy = S.getLambdaConversionFunctionResultType(
1372       CallOperator->getType()->castAs<FunctionProtoType>());
1373   QualType BlockPtrTy = S.Context.getBlockPointerType(FunctionTy);
1374 
1375   FunctionProtoType::ExtProtoInfo ConversionEPI(
1376       S.Context.getDefaultCallingConvention(
1377           /*IsVariadic=*/false, /*IsCXXMethod=*/true));
1378   ConversionEPI.TypeQuals = Qualifiers::Const;
1379   QualType ConvTy = S.Context.getFunctionType(BlockPtrTy, None, ConversionEPI);
1380 
1381   SourceLocation Loc = IntroducerRange.getBegin();
1382   DeclarationName Name
1383     = S.Context.DeclarationNames.getCXXConversionFunctionName(
1384         S.Context.getCanonicalType(BlockPtrTy));
1385   DeclarationNameLoc NameLoc;
1386   NameLoc.NamedType.TInfo = S.Context.getTrivialTypeSourceInfo(BlockPtrTy, Loc);
1387   CXXConversionDecl *Conversion
1388     = CXXConversionDecl::Create(S.Context, Class, Loc,
1389                                 DeclarationNameInfo(Name, Loc, NameLoc),
1390                                 ConvTy,
1391                                 S.Context.getTrivialTypeSourceInfo(ConvTy, Loc),
1392                                 /*isInline=*/true, /*isExplicit=*/false,
1393                                 /*isConstexpr=*/false,
1394                                 CallOperator->getBody()->getLocEnd());
1395   Conversion->setAccess(AS_public);
1396   Conversion->setImplicit(true);
1397   Class->addDecl(Conversion);
1398 }
1399 
1400 static ExprResult performLambdaVarCaptureInitialization(Sema &S,
1401                                                         const Capture &Capture,
1402                                                         FieldDecl *Field) {
1403   assert(Capture.isVariableCapture() && "not a variable capture");
1404 
1405   auto *Var = Capture.getVariable();
1406   SourceLocation Loc = Capture.getLocation();
1407 
1408   // C++11 [expr.prim.lambda]p21:
1409   //   When the lambda-expression is evaluated, the entities that
1410   //   are captured by copy are used to direct-initialize each
1411   //   corresponding non-static data member of the resulting closure
1412   //   object. (For array members, the array elements are
1413   //   direct-initialized in increasing subscript order.) These
1414   //   initializations are performed in the (unspecified) order in
1415   //   which the non-static data members are declared.
1416 
1417   // C++ [expr.prim.lambda]p12:
1418   //   An entity captured by a lambda-expression is odr-used (3.2) in
1419   //   the scope containing the lambda-expression.
1420   ExprResult RefResult = S.BuildDeclarationNameExpr(
1421       CXXScopeSpec(), DeclarationNameInfo(Var->getDeclName(), Loc), Var);
1422   if (RefResult.isInvalid())
1423     return ExprError();
1424   Expr *Ref = RefResult.get();
1425 
1426   auto Entity = InitializedEntity::InitializeLambdaCapture(
1427       Var->getIdentifier(), Field->getType(), Loc);
1428   InitializationKind InitKind = InitializationKind::CreateDirect(Loc, Loc, Loc);
1429   InitializationSequence Init(S, Entity, InitKind, Ref);
1430   return Init.Perform(S, Entity, InitKind, Ref);
1431 }
1432 
1433 ExprResult Sema::ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body,
1434                                  Scope *CurScope) {
1435   LambdaScopeInfo LSI = *cast<LambdaScopeInfo>(FunctionScopes.back());
1436   ActOnFinishFunctionBody(LSI.CallOperator, Body);
1437   return BuildLambdaExpr(StartLoc, Body->getLocEnd(), &LSI);
1438 }
1439 
1440 static LambdaCaptureDefault
1441 mapImplicitCaptureStyle(CapturingScopeInfo::ImplicitCaptureStyle ICS) {
1442   switch (ICS) {
1443   case CapturingScopeInfo::ImpCap_None:
1444     return LCD_None;
1445   case CapturingScopeInfo::ImpCap_LambdaByval:
1446     return LCD_ByCopy;
1447   case CapturingScopeInfo::ImpCap_CapturedRegion:
1448   case CapturingScopeInfo::ImpCap_LambdaByref:
1449     return LCD_ByRef;
1450   case CapturingScopeInfo::ImpCap_Block:
1451     llvm_unreachable("block capture in lambda");
1452   }
1453   llvm_unreachable("Unknown implicit capture style");
1454 }
1455 
1456 bool Sema::CaptureHasSideEffects(const Capture &From) {
1457   if (!From.isVLATypeCapture()) {
1458     Expr *Init = From.getInitExpr();
1459     if (Init && Init->HasSideEffects(Context))
1460       return true;
1461   }
1462 
1463   if (!From.isCopyCapture())
1464     return false;
1465 
1466   const QualType T = From.isThisCapture()
1467                          ? getCurrentThisType()->getPointeeType()
1468                          : From.getCaptureType();
1469 
1470   if (T.isVolatileQualified())
1471     return true;
1472 
1473   const Type *BaseT = T->getBaseElementTypeUnsafe();
1474   if (const CXXRecordDecl *RD = BaseT->getAsCXXRecordDecl())
1475     return !RD->isCompleteDefinition() || !RD->hasTrivialCopyConstructor() ||
1476            !RD->hasTrivialDestructor();
1477 
1478   return false;
1479 }
1480 
1481 void Sema::DiagnoseUnusedLambdaCapture(const Capture &From) {
1482   if (CaptureHasSideEffects(From))
1483     return;
1484 
1485   if (From.isVLATypeCapture())
1486     return;
1487 
1488   auto diag = Diag(From.getLocation(), diag::warn_unused_lambda_capture);
1489   if (From.isThisCapture())
1490     diag << "'this'";
1491   else
1492     diag << From.getVariable();
1493   diag << From.isNonODRUsed();
1494 }
1495 
1496 ExprResult Sema::BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc,
1497                                  LambdaScopeInfo *LSI) {
1498   // Collect information from the lambda scope.
1499   SmallVector<LambdaCapture, 4> Captures;
1500   SmallVector<Expr *, 4> CaptureInits;
1501   SourceLocation CaptureDefaultLoc = LSI->CaptureDefaultLoc;
1502   LambdaCaptureDefault CaptureDefault =
1503       mapImplicitCaptureStyle(LSI->ImpCaptureStyle);
1504   CXXRecordDecl *Class;
1505   CXXMethodDecl *CallOperator;
1506   SourceRange IntroducerRange;
1507   bool ExplicitParams;
1508   bool ExplicitResultType;
1509   CleanupInfo LambdaCleanup;
1510   bool ContainsUnexpandedParameterPack;
1511   bool IsGenericLambda;
1512   {
1513     CallOperator = LSI->CallOperator;
1514     Class = LSI->Lambda;
1515     IntroducerRange = LSI->IntroducerRange;
1516     ExplicitParams = LSI->ExplicitParams;
1517     ExplicitResultType = !LSI->HasImplicitReturnType;
1518     LambdaCleanup = LSI->Cleanup;
1519     ContainsUnexpandedParameterPack = LSI->ContainsUnexpandedParameterPack;
1520     IsGenericLambda = Class->isGenericLambda();
1521 
1522     CallOperator->setLexicalDeclContext(Class);
1523     Decl *TemplateOrNonTemplateCallOperatorDecl =
1524         CallOperator->getDescribedFunctionTemplate()
1525         ? CallOperator->getDescribedFunctionTemplate()
1526         : cast<Decl>(CallOperator);
1527 
1528     TemplateOrNonTemplateCallOperatorDecl->setLexicalDeclContext(Class);
1529     Class->addDecl(TemplateOrNonTemplateCallOperatorDecl);
1530 
1531     PopExpressionEvaluationContext();
1532 
1533     // Translate captures.
1534     auto CurField = Class->field_begin();
1535     for (unsigned I = 0, N = LSI->Captures.size(); I != N; ++I, ++CurField) {
1536       const Capture &From = LSI->Captures[I];
1537       assert(!From.isBlockCapture() && "Cannot capture __block variables");
1538       bool IsImplicit = I >= LSI->NumExplicitCaptures;
1539 
1540       // Warn about unused explicit captures.
1541       if (!CurContext->isDependentContext() && !IsImplicit && !From.isODRUsed()) {
1542         // Initialized captures that are non-ODR used may not be eliminated.
1543         bool NonODRUsedInitCapture =
1544             IsGenericLambda && From.isNonODRUsed() && From.getInitExpr();
1545         if (!NonODRUsedInitCapture)
1546           DiagnoseUnusedLambdaCapture(From);
1547       }
1548 
1549       // Handle 'this' capture.
1550       if (From.isThisCapture()) {
1551         Captures.push_back(
1552             LambdaCapture(From.getLocation(), IsImplicit,
1553                           From.isCopyCapture() ? LCK_StarThis : LCK_This));
1554         CaptureInits.push_back(From.getInitExpr());
1555         continue;
1556       }
1557       if (From.isVLATypeCapture()) {
1558         Captures.push_back(
1559             LambdaCapture(From.getLocation(), IsImplicit, LCK_VLAType));
1560         CaptureInits.push_back(nullptr);
1561         continue;
1562       }
1563 
1564       VarDecl *Var = From.getVariable();
1565       LambdaCaptureKind Kind = From.isCopyCapture() ? LCK_ByCopy : LCK_ByRef;
1566       Captures.push_back(LambdaCapture(From.getLocation(), IsImplicit, Kind,
1567                                        Var, From.getEllipsisLoc()));
1568       Expr *Init = From.getInitExpr();
1569       if (!Init) {
1570         auto InitResult =
1571             performLambdaVarCaptureInitialization(*this, From, *CurField);
1572         if (InitResult.isInvalid())
1573           return ExprError();
1574         Init = InitResult.get();
1575       }
1576       CaptureInits.push_back(Init);
1577     }
1578 
1579     // C++11 [expr.prim.lambda]p6:
1580     //   The closure type for a lambda-expression with no lambda-capture
1581     //   has a public non-virtual non-explicit const conversion function
1582     //   to pointer to function having the same parameter and return
1583     //   types as the closure type's function call operator.
1584     if (Captures.empty() && CaptureDefault == LCD_None)
1585       addFunctionPointerConversion(*this, IntroducerRange, Class,
1586                                    CallOperator);
1587 
1588     // Objective-C++:
1589     //   The closure type for a lambda-expression has a public non-virtual
1590     //   non-explicit const conversion function to a block pointer having the
1591     //   same parameter and return types as the closure type's function call
1592     //   operator.
1593     // FIXME: Fix generic lambda to block conversions.
1594     if (getLangOpts().Blocks && getLangOpts().ObjC1 && !IsGenericLambda)
1595       addBlockPointerConversion(*this, IntroducerRange, Class, CallOperator);
1596 
1597     // Finalize the lambda class.
1598     SmallVector<Decl*, 4> Fields(Class->fields());
1599     ActOnFields(nullptr, Class->getLocation(), Class, Fields, SourceLocation(),
1600                 SourceLocation(), nullptr);
1601     CheckCompletedCXXClass(Class);
1602   }
1603 
1604   Cleanup.mergeFrom(LambdaCleanup);
1605 
1606   LambdaExpr *Lambda = LambdaExpr::Create(Context, Class, IntroducerRange,
1607                                           CaptureDefault, CaptureDefaultLoc,
1608                                           Captures,
1609                                           ExplicitParams, ExplicitResultType,
1610                                           CaptureInits, EndLoc,
1611                                           ContainsUnexpandedParameterPack);
1612   // If the lambda expression's call operator is not explicitly marked constexpr
1613   // and we are not in a dependent context, analyze the call operator to infer
1614   // its constexpr-ness, suppressing diagnostics while doing so.
1615   if (getLangOpts().CPlusPlus17 && !CallOperator->isInvalidDecl() &&
1616       !CallOperator->isConstexpr() &&
1617       !isa<CoroutineBodyStmt>(CallOperator->getBody()) &&
1618       !Class->getDeclContext()->isDependentContext()) {
1619     TentativeAnalysisScope DiagnosticScopeGuard(*this);
1620     CallOperator->setConstexpr(
1621         CheckConstexprFunctionDecl(CallOperator) &&
1622         CheckConstexprFunctionBody(CallOperator, CallOperator->getBody()));
1623   }
1624 
1625   // Emit delayed shadowing warnings now that the full capture list is known.
1626   DiagnoseShadowingLambdaDecls(LSI);
1627 
1628   if (!CurContext->isDependentContext()) {
1629     switch (ExprEvalContexts.back().Context) {
1630     // C++11 [expr.prim.lambda]p2:
1631     //   A lambda-expression shall not appear in an unevaluated operand
1632     //   (Clause 5).
1633     case ExpressionEvaluationContext::Unevaluated:
1634     case ExpressionEvaluationContext::UnevaluatedList:
1635     case ExpressionEvaluationContext::UnevaluatedAbstract:
1636     // C++1y [expr.const]p2:
1637     //   A conditional-expression e is a core constant expression unless the
1638     //   evaluation of e, following the rules of the abstract machine, would
1639     //   evaluate [...] a lambda-expression.
1640     //
1641     // This is technically incorrect, there are some constant evaluated contexts
1642     // where this should be allowed.  We should probably fix this when DR1607 is
1643     // ratified, it lays out the exact set of conditions where we shouldn't
1644     // allow a lambda-expression.
1645     case ExpressionEvaluationContext::ConstantEvaluated:
1646       // We don't actually diagnose this case immediately, because we
1647       // could be within a context where we might find out later that
1648       // the expression is potentially evaluated (e.g., for typeid).
1649       ExprEvalContexts.back().Lambdas.push_back(Lambda);
1650       break;
1651 
1652     case ExpressionEvaluationContext::DiscardedStatement:
1653     case ExpressionEvaluationContext::PotentiallyEvaluated:
1654     case ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
1655       break;
1656     }
1657   }
1658 
1659   return MaybeBindToTemporary(Lambda);
1660 }
1661 
1662 ExprResult Sema::BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
1663                                                SourceLocation ConvLocation,
1664                                                CXXConversionDecl *Conv,
1665                                                Expr *Src) {
1666   // Make sure that the lambda call operator is marked used.
1667   CXXRecordDecl *Lambda = Conv->getParent();
1668   CXXMethodDecl *CallOperator
1669     = cast<CXXMethodDecl>(
1670         Lambda->lookup(
1671           Context.DeclarationNames.getCXXOperatorName(OO_Call)).front());
1672   CallOperator->setReferenced();
1673   CallOperator->markUsed(Context);
1674 
1675   ExprResult Init = PerformCopyInitialization(
1676       InitializedEntity::InitializeLambdaToBlock(ConvLocation, Src->getType(),
1677                                                  /*NRVO=*/false),
1678       CurrentLocation, Src);
1679   if (!Init.isInvalid())
1680     Init = ActOnFinishFullExpr(Init.get());
1681 
1682   if (Init.isInvalid())
1683     return ExprError();
1684 
1685   // Create the new block to be returned.
1686   BlockDecl *Block = BlockDecl::Create(Context, CurContext, ConvLocation);
1687 
1688   // Set the type information.
1689   Block->setSignatureAsWritten(CallOperator->getTypeSourceInfo());
1690   Block->setIsVariadic(CallOperator->isVariadic());
1691   Block->setBlockMissingReturnType(false);
1692 
1693   // Add parameters.
1694   SmallVector<ParmVarDecl *, 4> BlockParams;
1695   for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) {
1696     ParmVarDecl *From = CallOperator->getParamDecl(I);
1697     BlockParams.push_back(ParmVarDecl::Create(Context, Block,
1698                                               From->getLocStart(),
1699                                               From->getLocation(),
1700                                               From->getIdentifier(),
1701                                               From->getType(),
1702                                               From->getTypeSourceInfo(),
1703                                               From->getStorageClass(),
1704                                               /*DefaultArg=*/nullptr));
1705   }
1706   Block->setParams(BlockParams);
1707 
1708   Block->setIsConversionFromLambda(true);
1709 
1710   // Add capture. The capture uses a fake variable, which doesn't correspond
1711   // to any actual memory location. However, the initializer copy-initializes
1712   // the lambda object.
1713   TypeSourceInfo *CapVarTSI =
1714       Context.getTrivialTypeSourceInfo(Src->getType());
1715   VarDecl *CapVar = VarDecl::Create(Context, Block, ConvLocation,
1716                                     ConvLocation, nullptr,
1717                                     Src->getType(), CapVarTSI,
1718                                     SC_None);
1719   BlockDecl::Capture Capture(/*Variable=*/CapVar, /*ByRef=*/false,
1720                              /*Nested=*/false, /*Copy=*/Init.get());
1721   Block->setCaptures(Context, Capture, /*CapturesCXXThis=*/false);
1722 
1723   // Add a fake function body to the block. IR generation is responsible
1724   // for filling in the actual body, which cannot be expressed as an AST.
1725   Block->setBody(new (Context) CompoundStmt(ConvLocation));
1726 
1727   // Create the block literal expression.
1728   Expr *BuildBlock = new (Context) BlockExpr(Block, Conv->getConversionType());
1729   ExprCleanupObjects.push_back(Block);
1730   Cleanup.setExprNeedsCleanups(true);
1731 
1732   return BuildBlock;
1733 }
1734