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