1//===--- SemaLambda.cpp - Semantic Analysis for C++11 Lambdas -------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements semantic analysis for C++ lambda expressions.
10//
11//===----------------------------------------------------------------------===//
12#include "clang/Sema/SemaLambda.h"
13#include "TypeLocBuilder.h"
14#include "clang/AST/ASTLambda.h"
15#include "clang/AST/CXXInheritance.h"
16#include "clang/AST/ExprCXX.h"
17#include "clang/AST/MangleNumberingContext.h"
18#include "clang/Basic/TargetInfo.h"
19#include "clang/Sema/DeclSpec.h"
20#include "clang/Sema/Initialization.h"
21#include "clang/Sema/Lookup.h"
22#include "clang/Sema/Scope.h"
23#include "clang/Sema/ScopeInfo.h"
24#include "clang/Sema/SemaARM.h"
25#include "clang/Sema/SemaCUDA.h"
26#include "clang/Sema/SemaInternal.h"
27#include "clang/Sema/SemaOpenMP.h"
28#include "clang/Sema/SemaSYCL.h"
29#include "clang/Sema/Template.h"
30#include "llvm/ADT/STLExtras.h"
31#include <optional>
32using namespace clang;
33using namespace sema;
34
35/// Examines the FunctionScopeInfo stack to determine the nearest
36/// enclosing lambda (to the current lambda) that is 'capture-ready' for
37/// the variable referenced in the current lambda (i.e. \p VarToCapture).
38/// If successful, returns the index into Sema's FunctionScopeInfo stack
39/// of the capture-ready lambda's LambdaScopeInfo.
40///
41/// Climbs down the stack of lambdas (deepest nested lambda - i.e. current
42/// lambda - is on top) to determine the index of the nearest enclosing/outer
43/// lambda that is ready to capture the \p VarToCapture being referenced in
44/// the current lambda.
45/// As we climb down the stack, we want the index of the first such lambda -
46/// that is the lambda with the highest index that is 'capture-ready'.
47///
48/// A lambda 'L' is capture-ready for 'V' (var or this) if:
49/// - its enclosing context is non-dependent
50/// - and if the chain of lambdas between L and the lambda in which
51/// V is potentially used (i.e. the lambda at the top of the scope info
52/// stack), can all capture or have already captured V.
53/// If \p VarToCapture is 'null' then we are trying to capture 'this'.
54///
55/// Note that a lambda that is deemed 'capture-ready' still needs to be checked
56/// for whether it is 'capture-capable' (see
57/// getStackIndexOfNearestEnclosingCaptureCapableLambda), before it can truly
58/// capture.
59///
60/// \param FunctionScopes - Sema's stack of nested FunctionScopeInfo's (which a
61/// LambdaScopeInfo inherits from). The current/deepest/innermost lambda
62/// is at the top of the stack and has the highest index.
63/// \param VarToCapture - the variable to capture. If NULL, capture 'this'.
64///
65/// \returns An UnsignedOrNone Index that if evaluates to 'true'
66/// contains the index (into Sema's FunctionScopeInfo stack) of the innermost
67/// lambda which is capture-ready. If the return value evaluates to 'false'
68/// then no lambda is capture-ready for \p VarToCapture.
69
70static inline UnsignedOrNone getStackIndexOfNearestEnclosingCaptureReadyLambda(
71 ArrayRef<const clang::sema::FunctionScopeInfo *> FunctionScopes,
72 ValueDecl *VarToCapture) {
73 // Label failure to capture.
74 const UnsignedOrNone NoLambdaIsCaptureReady = std::nullopt;
75
76 // Ignore all inner captured regions.
77 unsigned CurScopeIndex = FunctionScopes.size() - 1;
78 while (CurScopeIndex > 0 && isa<clang::sema::CapturedRegionScopeInfo>(
79 Val: FunctionScopes[CurScopeIndex]))
80 --CurScopeIndex;
81 assert(
82 isa<clang::sema::LambdaScopeInfo>(FunctionScopes[CurScopeIndex]) &&
83 "The function on the top of sema's function-info stack must be a lambda");
84
85 // If VarToCapture is null, we are attempting to capture 'this'.
86 const bool IsCapturingThis = !VarToCapture;
87 const bool IsCapturingVariable = !IsCapturingThis;
88
89 // Start with the current lambda at the top of the stack (highest index).
90 DeclContext *EnclosingDC =
91 cast<sema::LambdaScopeInfo>(Val: FunctionScopes[CurScopeIndex])->CallOperator;
92
93 do {
94 const clang::sema::LambdaScopeInfo *LSI =
95 cast<sema::LambdaScopeInfo>(Val: FunctionScopes[CurScopeIndex]);
96 // IF we have climbed down to an intervening enclosing lambda that contains
97 // the variable declaration - it obviously can/must not capture the
98 // variable.
99 // Since its enclosing DC is dependent, all the lambdas between it and the
100 // innermost nested lambda are dependent (otherwise we wouldn't have
101 // arrived here) - so we don't yet have a lambda that can capture the
102 // variable.
103 if (IsCapturingVariable && VarToCapture->getDeclContext()
104 ->getEnclosingNonExpansionStatementContext()
105 ->Equals(DC: EnclosingDC))
106 return NoLambdaIsCaptureReady;
107
108 // For an enclosing lambda to be capture ready for an entity, all
109 // intervening lambda's have to be able to capture that entity. If even
110 // one of the intervening lambda's is not capable of capturing the entity
111 // then no enclosing lambda can ever capture that entity.
112 // For e.g.
113 // const int x = 10;
114 // [=](auto a) { #1
115 // [](auto b) { #2 <-- an intervening lambda that can never capture 'x'
116 // [=](auto c) { #3
117 // f(x, c); <-- can not lead to x's speculative capture by #1 or #2
118 // }; }; };
119 // If they do not have a default implicit capture, check to see
120 // if the entity has already been explicitly captured.
121 // If even a single dependent enclosing lambda lacks the capability
122 // to ever capture this variable, there is no further enclosing
123 // non-dependent lambda that can capture this variable.
124 if (LSI->ImpCaptureStyle == sema::LambdaScopeInfo::ImpCap_None) {
125 if (IsCapturingVariable && !LSI->isCaptured(Var: VarToCapture))
126 return NoLambdaIsCaptureReady;
127 if (IsCapturingThis && !LSI->isCXXThisCaptured())
128 return NoLambdaIsCaptureReady;
129 }
130 EnclosingDC = getLambdaAwareParentOfDeclContext(DC: EnclosingDC)
131 ->getEnclosingNonExpansionStatementContext();
132
133 assert(CurScopeIndex);
134 --CurScopeIndex;
135 } while (!EnclosingDC->isTranslationUnit() &&
136 EnclosingDC->isDependentContext() &&
137 isLambdaCallOperator(DC: EnclosingDC));
138
139 assert(CurScopeIndex < (FunctionScopes.size() - 1));
140 // If the enclosingDC is not dependent, then the immediately nested lambda
141 // (one index above) is capture-ready.
142 if (!EnclosingDC->isDependentContext())
143 return CurScopeIndex + 1;
144 return NoLambdaIsCaptureReady;
145}
146
147/// Examines the FunctionScopeInfo stack to determine the nearest
148/// enclosing lambda (to the current lambda) that is 'capture-capable' for
149/// the variable referenced in the current lambda (i.e. \p VarToCapture).
150/// If successful, returns the index into Sema's FunctionScopeInfo stack
151/// of the capture-capable lambda's LambdaScopeInfo.
152///
153/// Given the current stack of lambdas being processed by Sema and
154/// the variable of interest, to identify the nearest enclosing lambda (to the
155/// current lambda at the top of the stack) that can truly capture
156/// a variable, it has to have the following two properties:
157/// a) 'capture-ready' - be the innermost lambda that is 'capture-ready':
158/// - climb down the stack (i.e. starting from the innermost and examining
159/// each outer lambda step by step) checking if each enclosing
160/// lambda can either implicitly or explicitly capture the variable.
161/// Record the first such lambda that is enclosed in a non-dependent
162/// context. If no such lambda currently exists return failure.
163/// b) 'capture-capable' - make sure the 'capture-ready' lambda can truly
164/// capture the variable by checking all its enclosing lambdas:
165/// - check if all outer lambdas enclosing the 'capture-ready' lambda
166/// identified above in 'a' can also capture the variable (this is done
167/// via tryCaptureVariable for variables and CheckCXXThisCapture for
168/// 'this' by passing in the index of the Lambda identified in step 'a')
169///
170/// \param FunctionScopes - Sema's stack of nested FunctionScopeInfo's (which a
171/// LambdaScopeInfo inherits from). The current/deepest/innermost lambda
172/// is at the top of the stack.
173///
174/// \param VarToCapture - the variable to capture. If NULL, capture 'this'.
175///
176///
177/// \returns An UnsignedOrNone Index that if evaluates to 'true'
178/// contains the index (into Sema's FunctionScopeInfo stack) of the innermost
179/// lambda which is capture-capable. If the return value evaluates to 'false'
180/// then no lambda is capture-capable for \p VarToCapture.
181
182UnsignedOrNone clang::getStackIndexOfNearestEnclosingCaptureCapableLambda(
183 ArrayRef<const sema::FunctionScopeInfo *> FunctionScopes,
184 ValueDecl *VarToCapture, Sema &S) {
185
186 const UnsignedOrNone NoLambdaIsCaptureCapable = std::nullopt;
187
188 const UnsignedOrNone OptionalStackIndex =
189 getStackIndexOfNearestEnclosingCaptureReadyLambda(FunctionScopes,
190 VarToCapture);
191 if (!OptionalStackIndex)
192 return NoLambdaIsCaptureCapable;
193
194 const unsigned IndexOfCaptureReadyLambda = *OptionalStackIndex;
195 const sema::LambdaScopeInfo *const CaptureReadyLambdaLSI =
196 cast<sema::LambdaScopeInfo>(Val: FunctionScopes[IndexOfCaptureReadyLambda]);
197
198 // If VarToCapture is null, we are attempting to capture 'this'
199 const bool IsCapturingThis = !VarToCapture;
200 const bool IsCapturingVariable = !IsCapturingThis;
201
202 if (IsCapturingVariable) {
203 // Check if the capture-ready lambda can truly capture the variable, by
204 // checking whether all enclosing lambdas of the capture-ready lambda allow
205 // the capture - i.e. make sure it is capture-capable.
206 QualType CaptureType, DeclRefType;
207 const bool CanCaptureVariable = !S.tryCaptureVariable(
208 Var: VarToCapture,
209 /*ExprVarIsUsedInLoc*/ Loc: SourceLocation(), Kind: TryCaptureKind::Implicit,
210 /*EllipsisLoc*/ SourceLocation(),
211 /*BuildAndDiagnose*/ false, CaptureType, DeclRefType,
212 FunctionScopeIndexToStopAt: &IndexOfCaptureReadyLambda);
213 if (!CanCaptureVariable)
214 return NoLambdaIsCaptureCapable;
215 } else {
216 // Check if the capture-ready lambda can truly capture 'this' by checking
217 // whether all enclosing lambdas of the capture-ready lambda can capture
218 // 'this'.
219 const bool CanCaptureThis =
220 !S.CheckCXXThisCapture(
221 Loc: CaptureReadyLambdaLSI->PotentialThisCaptureLocation,
222 /*Explicit*/ false, /*BuildAndDiagnose*/ false,
223 FunctionScopeIndexToStopAt: &IndexOfCaptureReadyLambda);
224 if (!CanCaptureThis)
225 return NoLambdaIsCaptureCapable;
226 }
227 return IndexOfCaptureReadyLambda;
228}
229
230static inline TemplateParameterList *
231getGenericLambdaTemplateParameterList(LambdaScopeInfo *LSI, Sema &SemaRef) {
232 if (!LSI->GLTemplateParameterList && !LSI->TemplateParams.empty()) {
233 LSI->GLTemplateParameterList = TemplateParameterList::Create(
234 C: SemaRef.Context,
235 /*Begin loc of the lambda expression*/ TemplateLoc: LSI->IntroducerRange.getBegin(),
236 /*L angle loc*/ LAngleLoc: LSI->ExplicitTemplateParamsRange.getBegin(),
237 Params: LSI->TemplateParams,
238 /*R angle loc*/ RAngleLoc: LSI->ExplicitTemplateParamsRange.getEnd(),
239 RequiresClause: LSI->RequiresClause.get());
240 }
241 return LSI->GLTemplateParameterList;
242}
243
244CXXRecordDecl *
245Sema::createLambdaClosureType(SourceRange IntroducerRange, TypeSourceInfo *Info,
246 unsigned LambdaDependencyKind,
247 LambdaCaptureDefault CaptureDefault) {
248 DeclContext *DC = CurContext->getEnclosingNonExpansionStatementContext();
249
250 bool IsGenericLambda =
251 Info && getGenericLambdaTemplateParameterList(LSI: getCurLambda(), SemaRef&: *this);
252 // Start constructing the lambda class.
253 CXXRecordDecl *Class = CXXRecordDecl::CreateLambda(
254 C: Context, DC, Info, Loc: IntroducerRange.getBegin(), DependencyKind: LambdaDependencyKind,
255 IsGeneric: IsGenericLambda, CaptureDefault);
256 DC->addDecl(D: Class);
257
258 return Class;
259}
260
261std::tuple<MangleNumberingContext *, Decl *>
262Sema::getCurrentMangleNumberContext(const DeclContext *DC) {
263 // Compute the context for allocating mangling numbers in the current
264 // expression, if the ABI requires them.
265 Decl *ManglingContextDecl = ExprEvalContexts.back().ManglingContextDecl;
266
267 enum ContextKind {
268 Normal,
269 DefaultArgument,
270 DataMember,
271 InlineVariable,
272 TemplatedVariable,
273 ExternallyVisibleVariableInModulePurview,
274 Concept,
275 } Kind = Normal;
276
277 bool IsInNonspecializedTemplate =
278 inTemplateInstantiation() || CurContext->isDependentContext();
279
280 // Checks if a VarDecl or FunctionDecl is from a module purview and externally
281 // visible. These Decls should be treated as "inline" for the purpose of
282 // mangling in the code below.
283 //
284 // See discussion in https://github.com/itanium-cxx-abi/cxx-abi/issues/186
285 //
286 // zygoloid:
287 // Yeah, I think the only cases left where lambdas don't need a
288 // mangling are when they have (effectively) internal linkage or
289 // appear in a non-inline function in a non-module translation unit.
290 static constexpr auto IsExternallyVisibleInModulePurview =
291 [](const NamedDecl *ND) -> bool {
292 return (ND->isInNamedModule() || ND->isFromGlobalModule()) &&
293 ND->isExternallyVisible();
294 };
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 Kind = [&]() {
300 if (!ManglingContextDecl)
301 return Normal;
302
303 if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Val: ManglingContextDecl)) {
304 if (const DeclContext *LexicalDC
305 = Param->getDeclContext()->getLexicalParent())
306 if (LexicalDC->isRecord())
307 return DefaultArgument;
308 } else if (VarDecl *Var = dyn_cast<VarDecl>(Val: ManglingContextDecl)) {
309 if (Var->getMostRecentDecl()->isInline())
310 return InlineVariable;
311
312 if (IsExternallyVisibleInModulePurview(Var))
313 return ExternallyVisibleVariableInModulePurview;
314
315 if (Var->getDeclContext()->isRecord() && IsInNonspecializedTemplate)
316 return TemplatedVariable;
317
318 if (Var->getDescribedVarTemplate())
319 return TemplatedVariable;
320
321 if (auto *VTS = dyn_cast<VarTemplateSpecializationDecl>(Val: Var)) {
322 if (!VTS->isExplicitSpecialization())
323 return TemplatedVariable;
324 }
325 } else if (isa<FieldDecl>(Val: ManglingContextDecl)) {
326 return DataMember;
327 } else if (isa<ImplicitConceptSpecializationDecl, ConceptDecl>(
328 Val: ManglingContextDecl)) {
329 return Concept;
330 }
331
332 return Normal;
333 }();
334
335 // Determine whether the given context is or is enclosed in a function that
336 // requires Decl's inside to be mangled, so either:
337 // - an inline function
338 // - or a function in a module purview that is externally visible
339 static constexpr auto IsInFunctionThatRequiresMangling =
340 [](const DeclContext *DC) -> bool {
341 while (!DC->isFileContext()) {
342 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Val: DC))
343 if (FD->isInlined() || IsExternallyVisibleInModulePurview(FD))
344 return true;
345
346 DC = DC->getLexicalParent();
347 }
348
349 return false;
350 };
351
352 // Itanium ABI [5.1.8]:
353 // In the following contexts [...] the one-definition rule requires closure
354 // types in different translation units to "correspond":
355 switch (Kind) {
356 case Normal: {
357 // -- the bodies of inline or templated functions
358 // -- the bodies of externally visible functions in a module purview
359 // (note: this is not yet part of the Itanium ABI, see the linked Github
360 // discussion above)
361 if ((IsInNonspecializedTemplate &&
362 !(ManglingContextDecl && isa<ParmVarDecl>(Val: ManglingContextDecl))) ||
363 IsInFunctionThatRequiresMangling(CurContext)) {
364 while (auto *CD = dyn_cast<CapturedDecl>(Val: DC))
365 DC = CD->getParent();
366 return std::make_tuple(args: &Context.getManglingNumberContext(DC), args: nullptr);
367 }
368
369 return std::make_tuple(args: nullptr, args: nullptr);
370 }
371
372 case Concept:
373 // Concept definitions aren't code generated and thus aren't mangled,
374 // however the ManglingContextDecl is important for the purposes of
375 // re-forming the template argument list of the lambda for constraint
376 // evaluation.
377 case DataMember:
378 // -- default member initializers
379 case DefaultArgument:
380 // -- default arguments appearing in class definitions
381 case InlineVariable:
382 case ExternallyVisibleVariableInModulePurview:
383 case TemplatedVariable:
384 // -- the initializers of inline or templated variables
385 // -- the initializers of externally visible variables in a module purview
386 // (note: this is not yet part of the Itanium ABI, see the linked Github
387 // discussion above)
388 return std::make_tuple(
389 args: &Context.getManglingNumberContext(ASTContext::NeedExtraManglingDecl,
390 D: ManglingContextDecl),
391 args&: ManglingContextDecl);
392 }
393
394 llvm_unreachable("unexpected context");
395}
396
397static QualType
398buildTypeForLambdaCallOperator(Sema &S, clang::CXXRecordDecl *Class,
399 TemplateParameterList *TemplateParams,
400 TypeSourceInfo *MethodTypeInfo) {
401 assert(MethodTypeInfo && "expected a non null type");
402
403 QualType MethodType = MethodTypeInfo->getType();
404 // If a lambda appears in a dependent context or is a generic lambda (has
405 // template parameters) and has an 'auto' return type, deduce it to a
406 // dependent type.
407 if (Class->isDependentContext() || TemplateParams) {
408 const FunctionProtoType *FPT = MethodType->castAs<FunctionProtoType>();
409 QualType Result = FPT->getReturnType();
410 if (Result->isUndeducedType()) {
411 Result = S.SubstAutoTypeDependent(TypeWithAuto: Result);
412 MethodType = S.Context.getFunctionType(ResultTy: Result, Args: FPT->getParamTypes(),
413 EPI: FPT->getExtProtoInfo());
414 }
415 }
416 return MethodType;
417}
418
419// [C++2b] [expr.prim.lambda.closure] p4
420// Given a lambda with a lambda-capture, the type of the explicit object
421// parameter, if any, of the lambda's function call operator (possibly
422// instantiated from a function call operator template) shall be either:
423// - the closure type,
424// - class type publicly and unambiguously derived from the closure type, or
425// - a reference to a possibly cv-qualified such type.
426bool Sema::DiagnoseInvalidExplicitObjectParameterInLambda(
427 CXXMethodDecl *Method, SourceLocation CallLoc) {
428 if (!isLambdaCallWithExplicitObjectParameter(DC: Method))
429 return false;
430 CXXRecordDecl *RD = Method->getParent();
431 if (Method->getType()->isDependentType())
432 return false;
433 if (RD->isCapturelessLambda())
434 return false;
435
436 ParmVarDecl *Param = Method->getParamDecl(i: 0);
437 QualType ExplicitObjectParameterType = Param->getType()
438 .getNonReferenceType()
439 .getUnqualifiedType()
440 .getDesugaredType(Context: getASTContext());
441 CanQualType LambdaType = getASTContext().getCanonicalTagType(TD: RD);
442 if (LambdaType == ExplicitObjectParameterType)
443 return false;
444
445 // Don't check the same instantiation twice.
446 //
447 // If this call operator is ill-formed, there is no point in issuing
448 // a diagnostic every time it is called because the problem is in the
449 // definition of the derived type, not at the call site.
450 //
451 // FIXME: Move this check to where we instantiate the method? This should
452 // be possible, but the naive approach of just marking the method as invalid
453 // leads to us emitting more diagnostics than we should have to for this case
454 // (1 error here *and* 1 error about there being no matching overload at the
455 // call site). It might be possible to avoid that by also checking if there
456 // is an empty cast path for the method stored in the context (signalling that
457 // we've already diagnosed it) and then just not building the call, but that
458 // doesn't really seem any simpler than diagnosing it at the call site...
459 auto [It, Inserted] = Context.LambdaCastPaths.try_emplace(Key: Method);
460 if (!Inserted)
461 return It->second.empty();
462
463 CXXCastPath &Path = It->second;
464 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
465 /*DetectVirtual=*/false);
466 if (!IsDerivedFrom(Loc: RD->getLocation(), Derived: ExplicitObjectParameterType, Base: LambdaType,
467 Paths)) {
468 Diag(Loc: Param->getLocation(), DiagID: diag::err_invalid_explicit_object_type_in_lambda)
469 << ExplicitObjectParameterType;
470 return true;
471 }
472
473 if (Paths.isAmbiguous(BaseType: LambdaType)) {
474 std::string PathsDisplay = getAmbiguousPathsDisplayString(Paths);
475 Diag(Loc: CallLoc, DiagID: diag::err_explicit_object_lambda_ambiguous_base)
476 << LambdaType << PathsDisplay;
477 return true;
478 }
479
480 if (CheckBaseClassAccess(AccessLoc: CallLoc, Base: LambdaType, Derived: ExplicitObjectParameterType,
481 Path: Paths.front(),
482 DiagID: diag::err_explicit_object_lambda_inaccessible_base))
483 return true;
484
485 BuildBasePathArray(Paths, BasePath&: Path);
486 return false;
487}
488
489void Sema::handleLambdaNumbering(
490 CXXRecordDecl *Class, CXXMethodDecl *Method,
491 std::optional<CXXRecordDecl::LambdaNumbering> NumberingOverride) {
492 ContextRAII ManglingContext(*this, Class->getDeclContext());
493
494 auto getMangleNumberingContext =
495 [this](CXXRecordDecl *Class,
496 Decl *ManglingContextDecl) -> MangleNumberingContext * {
497 // Get mangle numbering context if there's any extra decl context.
498 if (ManglingContextDecl)
499 return &Context.getManglingNumberContext(
500 ASTContext::NeedExtraManglingDecl, D: ManglingContextDecl);
501 // Otherwise, from that lambda's decl context.
502 auto DC = Class->getDeclContext();
503 while (auto *CD = dyn_cast<CapturedDecl>(Val: DC))
504 DC = CD->getParent();
505 return &Context.getManglingNumberContext(DC);
506 };
507
508 MangleNumberingContext *MCtx;
509 Decl *ContextDecl;
510 std::tie(args&: MCtx, args&: ContextDecl) =
511 getCurrentMangleNumberContext(DC: Class->getDeclContext());
512 // getManglingNumber(Method) below may trigger mangling of dependent types
513 // that reference init-captures. Publish the lambda context declaration early
514 // so such mangling can resolve the surrounding context without recursing
515 // through the lambda call operator. This avoids publishing provisional
516 // numbering state before final numbering is assigned below.
517 if (ContextDecl)
518 Class->setLambdaContextDecl(ContextDecl);
519
520 CXXRecordDecl::LambdaNumbering Numbering;
521 if (!MCtx && (getLangOpts().CUDA || getLangOpts().SYCLIsDevice ||
522 getLangOpts().SYCLIsHost)) {
523 // Force lambda numbering in CUDA/HIP as we need to name lambdas following
524 // ODR. Both device- and host-compilation need to have a consistent naming
525 // on kernel functions. As lambdas are potential part of these `__global__`
526 // function names, they needs numbering following ODR.
527 // Also force for SYCL, since we need this for the
528 // __builtin_sycl_unique_stable_name implementation, which depends on lambda
529 // mangling.
530 MCtx = getMangleNumberingContext(Class, ContextDecl);
531 assert(MCtx && "Retrieving mangle numbering context failed!");
532 Numbering.HasKnownInternalLinkage = true;
533 }
534
535 if (!MCtx) {
536 // This lambda doesn't need a mangle numbering.
537 return;
538 }
539
540 if (NumberingOverride) {
541 Numbering = *NumberingOverride;
542 } else {
543 Numbering.IndexInContext = MCtx->getNextLambdaIndex();
544 Numbering.ManglingNumber = MCtx->getManglingNumber(CallOperator: Method);
545 Numbering.DeviceManglingNumber = MCtx->getDeviceManglingNumber(Method);
546 }
547
548 Class->setLambdaNumbering(Numbering);
549
550 // If there is no context declaration (e.g. this lambda is defined at the
551 // top-level in the global namespace), there is no need to register it for
552 // merging.
553 if (!ContextDecl) {
554 return;
555 }
556
557 // This lambda might redeclare a previous lambda if this is not the first
558 // definition of the context declaration. We might have a definition from
559 // another translation unit.
560 auto *&Slot = Context.getLambdaDeclarationSlotForMerging(
561 ContextDecl, IndexInContext: Numbering.IndexInContext);
562 if (auto *Previous = Slot) {
563 Class->setPreviousDecl(Previous);
564 makeMergedDefinitionVisible(ND: Previous);
565 } else {
566 // Keep track of this lambda so it can be merged with another lambda that is
567 // parsed or loaded later.
568 Slot = Class;
569 }
570}
571
572static void buildLambdaScopeReturnType(Sema &S, LambdaScopeInfo *LSI,
573 CXXMethodDecl *CallOperator,
574 bool ExplicitResultType) {
575 if (ExplicitResultType) {
576 LSI->HasImplicitReturnType = false;
577 LSI->ReturnType = CallOperator->getReturnType();
578 if (!LSI->ReturnType->isDependentType() && !LSI->ReturnType->isVoidType())
579 S.RequireCompleteType(Loc: CallOperator->getBeginLoc(), T: LSI->ReturnType,
580 DiagID: diag::err_lambda_incomplete_result);
581 } else {
582 LSI->HasImplicitReturnType = true;
583 }
584}
585
586void Sema::buildLambdaScope(LambdaScopeInfo *LSI, CXXMethodDecl *CallOperator,
587 SourceRange IntroducerRange,
588 LambdaCaptureDefault CaptureDefault,
589 SourceLocation CaptureDefaultLoc,
590 bool ExplicitParams, bool Mutable) {
591 LSI->CallOperator = CallOperator;
592 CXXRecordDecl *LambdaClass = CallOperator->getParent();
593 LSI->Lambda = LambdaClass;
594 if (CaptureDefault == LCD_ByCopy)
595 LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByval;
596 else if (CaptureDefault == LCD_ByRef)
597 LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByref;
598 LSI->CaptureDefaultLoc = CaptureDefaultLoc;
599 LSI->IntroducerRange = IntroducerRange;
600 LSI->ExplicitParams = ExplicitParams;
601 LSI->Mutable = Mutable;
602}
603
604void Sema::finishLambdaExplicitCaptures(LambdaScopeInfo *LSI) {
605 LSI->finishedExplicitCaptures();
606}
607
608void Sema::ActOnLambdaExplicitTemplateParameterList(
609 LambdaIntroducer &Intro, SourceLocation LAngleLoc,
610 ArrayRef<NamedDecl *> TParams, SourceLocation RAngleLoc,
611 ExprResult RequiresClause) {
612 LambdaScopeInfo *LSI = getCurLambda();
613 assert(LSI && "Expected a lambda scope");
614 assert(LSI->NumExplicitTemplateParams == 0 &&
615 "Already acted on explicit template parameters");
616 assert(LSI->TemplateParams.empty() &&
617 "Explicit template parameters should come "
618 "before invented (auto) ones");
619 assert(!TParams.empty() &&
620 "No template parameters to act on");
621 LSI->TemplateParams.append(in_start: TParams.begin(), in_end: TParams.end());
622 LSI->NumExplicitTemplateParams = TParams.size();
623 LSI->ExplicitTemplateParamsRange = {LAngleLoc, RAngleLoc};
624 LSI->RequiresClause = RequiresClause;
625}
626
627/// If this expression is an enumerator-like expression of some type
628/// T, return the type T; otherwise, return null.
629///
630/// Pointer comparisons on the result here should always work because
631/// it's derived from either the parent of an EnumConstantDecl
632/// (i.e. the definition) or the declaration returned by
633/// EnumType::getDecl() (i.e. the definition).
634static EnumDecl *findEnumForBlockReturn(Expr *E) {
635 // An expression is an enumerator-like expression of type T if,
636 // ignoring parens and parens-like expressions:
637 E = E->IgnoreParens();
638
639 // - it is an enumerator whose enum type is T or
640 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Val: E)) {
641 if (EnumConstantDecl *D
642 = dyn_cast<EnumConstantDecl>(Val: DRE->getDecl())) {
643 return cast<EnumDecl>(Val: D->getDeclContext());
644 }
645 return nullptr;
646 }
647
648 // - it is a comma expression whose RHS is an enumerator-like
649 // expression of type T or
650 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(Val: E)) {
651 if (BO->getOpcode() == BO_Comma)
652 return findEnumForBlockReturn(E: BO->getRHS());
653 return nullptr;
654 }
655
656 // - it is a statement-expression whose value expression is an
657 // enumerator-like expression of type T or
658 if (StmtExpr *SE = dyn_cast<StmtExpr>(Val: E)) {
659 if (Expr *last = dyn_cast_or_null<Expr>(Val: SE->getSubStmt()->body_back()))
660 return findEnumForBlockReturn(E: last);
661 return nullptr;
662 }
663
664 // - it is a ternary conditional operator (not the GNU ?:
665 // extension) whose second and third operands are
666 // enumerator-like expressions of type T or
667 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(Val: E)) {
668 if (EnumDecl *ED = findEnumForBlockReturn(E: CO->getTrueExpr()))
669 if (ED == findEnumForBlockReturn(E: CO->getFalseExpr()))
670 return ED;
671 return nullptr;
672 }
673
674 // (implicitly:)
675 // - it is an implicit integral conversion applied to an
676 // enumerator-like expression of type T or
677 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Val: E)) {
678 // We can sometimes see integral conversions in valid
679 // enumerator-like expressions.
680 if (ICE->getCastKind() == CK_IntegralCast)
681 return findEnumForBlockReturn(E: ICE->getSubExpr());
682
683 // Otherwise, just rely on the type.
684 }
685
686 // - it is an expression of that formal enum type.
687 if (auto *ED = E->getType()->getAsEnumDecl())
688 return ED;
689
690 // Otherwise, nope.
691 return nullptr;
692}
693
694/// Attempt to find a type T for which the returned expression of the
695/// given statement is an enumerator-like expression of that type.
696static EnumDecl *findEnumForBlockReturn(ReturnStmt *ret) {
697 if (Expr *retValue = ret->getRetValue())
698 return findEnumForBlockReturn(E: retValue);
699 return nullptr;
700}
701
702/// Attempt to find a common type T for which all of the returned
703/// expressions in a block are enumerator-like expressions of that
704/// type.
705static EnumDecl *findCommonEnumForBlockReturns(ArrayRef<ReturnStmt*> returns) {
706 ArrayRef<ReturnStmt*>::iterator i = returns.begin(), e = returns.end();
707
708 // Try to find one for the first return.
709 EnumDecl *ED = findEnumForBlockReturn(ret: *i);
710 if (!ED) return nullptr;
711
712 // Check that the rest of the returns have the same enum.
713 for (++i; i != e; ++i) {
714 if (findEnumForBlockReturn(ret: *i) != ED)
715 return nullptr;
716 }
717
718 // Never infer an anonymous enum type.
719 if (!ED->hasNameForLinkage()) return nullptr;
720
721 return ED;
722}
723
724/// Adjust the given return statements so that they formally return
725/// the given type. It should require, at most, an IntegralCast.
726static void adjustBlockReturnsToEnum(Sema &S, ArrayRef<ReturnStmt*> returns,
727 QualType returnType) {
728 for (ArrayRef<ReturnStmt*>::iterator
729 i = returns.begin(), e = returns.end(); i != e; ++i) {
730 ReturnStmt *ret = *i;
731 Expr *retValue = ret->getRetValue();
732 if (S.Context.hasSameType(T1: retValue->getType(), T2: returnType))
733 continue;
734
735 // Right now we only support integral fixup casts.
736 assert(returnType->isIntegralOrUnscopedEnumerationType());
737 assert(retValue->getType()->isIntegralOrUnscopedEnumerationType());
738
739 ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(Val: retValue);
740
741 Expr *E = (cleanups ? cleanups->getSubExpr() : retValue);
742 E = ImplicitCastExpr::Create(Context: S.Context, T: returnType, Kind: CK_IntegralCast, Operand: E,
743 /*base path*/ BasePath: nullptr, Cat: VK_PRValue,
744 FPO: FPOptionsOverride());
745 if (cleanups) {
746 cleanups->setSubExpr(E);
747 } else {
748 ret->setRetValue(E);
749 }
750 }
751}
752
753void Sema::deduceClosureReturnType(CapturingScopeInfo &CSI) {
754 assert(CSI.HasImplicitReturnType);
755 // If it was ever a placeholder, it had to been deduced to DependentTy.
756 assert(CSI.ReturnType.isNull() || !CSI.ReturnType->isUndeducedType());
757 assert((!isa<LambdaScopeInfo>(CSI) || !getLangOpts().CPlusPlus14) &&
758 "lambda expressions use auto deduction in C++14 onwards");
759
760 // C++ core issue 975:
761 // If a lambda-expression does not include a trailing-return-type,
762 // it is as if the trailing-return-type denotes the following type:
763 // - if there are no return statements in the compound-statement,
764 // or all return statements return either an expression of type
765 // void or no expression or braced-init-list, the type void;
766 // - otherwise, if all return statements return an expression
767 // and the types of the returned expressions after
768 // lvalue-to-rvalue conversion (4.1 [conv.lval]),
769 // array-to-pointer conversion (4.2 [conv.array]), and
770 // function-to-pointer conversion (4.3 [conv.func]) are the
771 // same, that common type;
772 // - otherwise, the program is ill-formed.
773 //
774 // C++ core issue 1048 additionally removes top-level cv-qualifiers
775 // from the types of returned expressions to match the C++14 auto
776 // deduction rules.
777 //
778 // In addition, in blocks in non-C++ modes, if all of the return
779 // statements are enumerator-like expressions of some type T, where
780 // T has a name for linkage, then we infer the return type of the
781 // block to be that type.
782
783 // First case: no return statements, implicit void return type.
784 ASTContext &Ctx = getASTContext();
785 if (CSI.Returns.empty()) {
786 // It's possible there were simply no /valid/ return statements.
787 // In this case, the first one we found may have at least given us a type.
788 if (CSI.ReturnType.isNull())
789 CSI.ReturnType = Ctx.VoidTy;
790 return;
791 }
792
793 // Second case: at least one return statement has dependent type.
794 // Delay type checking until instantiation.
795 assert(!CSI.ReturnType.isNull() && "We should have a tentative return type.");
796 if (CSI.ReturnType->isDependentType())
797 return;
798
799 // Try to apply the enum-fuzz rule.
800 if (!getLangOpts().CPlusPlus) {
801 assert(isa<BlockScopeInfo>(CSI));
802 const EnumDecl *ED = findCommonEnumForBlockReturns(returns: CSI.Returns);
803 if (ED) {
804 CSI.ReturnType = Context.getCanonicalTagType(TD: ED);
805 adjustBlockReturnsToEnum(S&: *this, returns: CSI.Returns, returnType: CSI.ReturnType);
806 return;
807 }
808 }
809
810 // Third case: only one return statement. Don't bother doing extra work!
811 if (CSI.Returns.size() == 1)
812 return;
813
814 // General case: many return statements.
815 // Check that they all have compatible return types.
816
817 // We require the return types to strictly match here.
818 // Note that we've already done the required promotions as part of
819 // processing the return statement.
820 for (const ReturnStmt *RS : CSI.Returns) {
821 const Expr *RetE = RS->getRetValue();
822
823 QualType ReturnType =
824 (RetE ? RetE->getType() : Context.VoidTy).getUnqualifiedType();
825 if (Context.getCanonicalFunctionResultType(ResultType: ReturnType) ==
826 Context.getCanonicalFunctionResultType(ResultType: CSI.ReturnType)) {
827 // Use the return type with the strictest possible nullability annotation.
828 auto RetTyNullability = ReturnType->getNullability();
829 auto BlockNullability = CSI.ReturnType->getNullability();
830 if (BlockNullability &&
831 (!RetTyNullability ||
832 hasWeakerNullability(L: *RetTyNullability, R: *BlockNullability)))
833 CSI.ReturnType = ReturnType;
834 continue;
835 }
836
837 // FIXME: This is a poor diagnostic for ReturnStmts without expressions.
838 // TODO: It's possible that the *first* return is the divergent one.
839 Diag(Loc: RS->getBeginLoc(),
840 DiagID: diag::err_typecheck_missing_return_type_incompatible)
841 << ReturnType << CSI.ReturnType << isa<LambdaScopeInfo>(Val: CSI);
842 // Continue iterating so that we keep emitting diagnostics.
843 }
844}
845
846QualType Sema::buildLambdaInitCaptureInitialization(
847 SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc,
848 UnsignedOrNone NumExpansions, IdentifierInfo *Id, bool IsDirectInit,
849 Expr *&Init) {
850 // Create an 'auto' or 'auto&' TypeSourceInfo that we can use to
851 // deduce against.
852 QualType DeductType = Context.getAutoDeductType();
853 TypeLocBuilder TLB;
854 AutoTypeLoc TL = TLB.push<AutoTypeLoc>(T: DeductType);
855 TL.setNameLoc(Loc);
856 if (ByRef) {
857 DeductType = BuildReferenceType(T: DeductType, LValueRef: true, Loc, Entity: Id);
858 assert(!DeductType.isNull() && "can't build reference to auto");
859 TLB.push<ReferenceTypeLoc>(T: DeductType).setSigilLoc(Loc);
860 }
861 if (EllipsisLoc.isValid()) {
862 if (Init->containsUnexpandedParameterPack()) {
863 DiagCompat(Loc: EllipsisLoc, CompatDiagId: diag_compat::init_capture_pack);
864 DeductType = Context.getPackExpansionType(Pattern: DeductType, NumExpansions,
865 /*ExpectPackInType=*/false);
866 TLB.push<PackExpansionTypeLoc>(T: DeductType).setEllipsisLoc(EllipsisLoc);
867 } else {
868 // Just ignore the ellipsis for now and form a non-pack variable. We'll
869 // diagnose this later when we try to capture it.
870 }
871 }
872 TypeSourceInfo *TSI = TLB.getTypeSourceInfo(Context, T: DeductType);
873
874 // Deduce the type of the init capture.
875 QualType DeducedType = deduceVarTypeFromInitializer(
876 /*VarDecl*/VDecl: nullptr, Name: DeclarationName(Id), Type: DeductType, TSI,
877 Range: SourceRange(Loc, Loc), DirectInit: IsDirectInit, Init);
878 if (DeducedType.isNull())
879 return QualType();
880
881 // Are we a non-list direct initialization?
882 ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Val: Init);
883
884 // Perform initialization analysis and ensure any implicit conversions
885 // (such as lvalue-to-rvalue) are enforced.
886 InitializedEntity Entity =
887 InitializedEntity::InitializeLambdaCapture(VarID: Id, FieldType: DeducedType, Loc);
888 InitializationKind Kind =
889 IsDirectInit
890 ? (CXXDirectInit ? InitializationKind::CreateDirect(
891 InitLoc: Loc, LParenLoc: Init->getBeginLoc(), RParenLoc: Init->getEndLoc())
892 : InitializationKind::CreateDirectList(InitLoc: Loc))
893 : InitializationKind::CreateCopy(InitLoc: Loc, EqualLoc: Init->getBeginLoc());
894
895 MultiExprArg Args = Init;
896 if (CXXDirectInit)
897 Args =
898 MultiExprArg(CXXDirectInit->getExprs(), CXXDirectInit->getNumExprs());
899 QualType DclT;
900 InitializationSequence InitSeq(*this, Entity, Kind, Args);
901 ExprResult Result = InitSeq.Perform(S&: *this, Entity, Kind, Args, ResultType: &DclT);
902
903 if (Result.isInvalid())
904 return QualType();
905
906 Init = Result.getAs<Expr>();
907 return DeducedType;
908}
909
910VarDecl *Sema::createLambdaInitCaptureVarDecl(
911 SourceLocation Loc, QualType InitCaptureType, SourceLocation EllipsisLoc,
912 IdentifierInfo *Id, unsigned InitStyle, Expr *Init, DeclContext *DeclCtx) {
913 // FIXME: Retain the TypeSourceInfo from buildLambdaInitCaptureInitialization
914 // rather than reconstructing it here.
915 TypeSourceInfo *TSI = Context.getTrivialTypeSourceInfo(T: InitCaptureType, Loc);
916 if (auto PETL = TSI->getTypeLoc().getAs<PackExpansionTypeLoc>())
917 PETL.setEllipsisLoc(EllipsisLoc);
918
919 // Create a dummy variable representing the init-capture. This is not actually
920 // used as a variable, and only exists as a way to name and refer to the
921 // init-capture.
922 // FIXME: Pass in separate source locations for '&' and identifier.
923 VarDecl *NewVD = VarDecl::Create(C&: Context, DC: DeclCtx, StartLoc: Loc, IdLoc: Loc, Id,
924 T: InitCaptureType, TInfo: TSI, S: SC_Auto);
925 NewVD->setInitCapture(true);
926 NewVD->setReferenced(true);
927 // FIXME: Pass in a VarDecl::InitializationStyle.
928 NewVD->setInitStyle(static_cast<VarDecl::InitializationStyle>(InitStyle));
929 NewVD->markUsed(C&: Context);
930 NewVD->setInit(Init);
931 if (NewVD->isParameterPack())
932 getCurLambda()->LocalPacks.push_back(Elt: NewVD);
933 return NewVD;
934}
935
936void Sema::addInitCapture(LambdaScopeInfo *LSI, VarDecl *Var, bool ByRef) {
937 assert(Var->isInitCapture() && "init capture flag should be set");
938 LSI->addCapture(Var, /*isBlock=*/false, isByref: ByRef,
939 /*isNested=*/false, Loc: Var->getLocation(), EllipsisLoc: SourceLocation(),
940 CaptureType: Var->getType(), /*Invalid=*/false);
941}
942
943// Unlike getCurLambda, getCurrentLambdaScopeUnsafe doesn't
944// check that the current lambda is in a consistent or fully constructed state.
945static LambdaScopeInfo *getCurrentLambdaScopeUnsafe(Sema &S) {
946 assert(!S.FunctionScopes.empty());
947 return cast<LambdaScopeInfo>(Val: S.FunctionScopes[S.FunctionScopes.size() - 1]);
948}
949
950static TypeSourceInfo *
951getDummyLambdaType(Sema &S, SourceLocation Loc = SourceLocation()) {
952 // C++11 [expr.prim.lambda]p4:
953 // If a lambda-expression does not include a lambda-declarator, it is as
954 // if the lambda-declarator were ().
955 FunctionProtoType::ExtProtoInfo EPI(S.Context.getDefaultCallingConvention(
956 /*IsVariadic=*/false, /*IsCXXMethod=*/true));
957 EPI.HasTrailingReturn = true;
958 EPI.TypeQuals.addConst();
959 LangAS AS = S.getDefaultCXXMethodAddrSpace();
960 if (AS != LangAS::Default)
961 EPI.TypeQuals.addAddressSpace(space: AS);
962
963 // C++1y [expr.prim.lambda]:
964 // The lambda return type is 'auto', which is replaced by the
965 // trailing-return type if provided and/or deduced from 'return'
966 // statements
967 // We don't do this before C++1y, because we don't support deduced return
968 // types there.
969 QualType DefaultTypeForNoTrailingReturn = S.getLangOpts().CPlusPlus14
970 ? S.Context.getAutoDeductType()
971 : S.Context.DependentTy;
972 QualType MethodTy =
973 S.Context.getFunctionType(ResultTy: DefaultTypeForNoTrailingReturn, Args: {}, EPI);
974 return S.Context.getTrivialTypeSourceInfo(T: MethodTy, Loc);
975}
976
977static TypeSourceInfo *getLambdaType(Sema &S, LambdaIntroducer &Intro,
978 Declarator &ParamInfo, Scope *CurScope,
979 SourceLocation Loc,
980 bool &ExplicitResultType) {
981
982 ExplicitResultType = false;
983
984 assert(
985 (ParamInfo.getDeclSpec().getStorageClassSpec() ==
986 DeclSpec::SCS_unspecified ||
987 ParamInfo.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static) &&
988 "Unexpected storage specifier");
989 bool IsLambdaStatic =
990 ParamInfo.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static;
991
992 TypeSourceInfo *MethodTyInfo;
993
994 if (ParamInfo.getNumTypeObjects() == 0) {
995 MethodTyInfo = getDummyLambdaType(S, Loc);
996 } else {
997 // Check explicit parameters
998 S.CheckExplicitObjectLambda(D&: ParamInfo);
999
1000 DeclaratorChunk::FunctionTypeInfo &FTI = ParamInfo.getFunctionTypeInfo();
1001
1002 bool HasExplicitObjectParameter =
1003 ParamInfo.isExplicitObjectMemberFunction();
1004
1005 ExplicitResultType = FTI.hasTrailingReturnType();
1006 if (!FTI.hasMutableQualifier() && !IsLambdaStatic &&
1007 !HasExplicitObjectParameter)
1008 FTI.getOrCreateMethodQualifiers().SetTypeQual(T: DeclSpec::TQ_const, Loc);
1009
1010 if (ExplicitResultType && S.getLangOpts().HLSL) {
1011 QualType RetTy = FTI.getTrailingReturnType().get();
1012 if (!RetTy.isNull()) {
1013 // HLSL does not support specifying an address space on a lambda return
1014 // type.
1015 LangAS AddressSpace = RetTy.getAddressSpace();
1016 if (AddressSpace != LangAS::Default)
1017 S.Diag(Loc: FTI.getTrailingReturnTypeLoc(),
1018 DiagID: diag::err_return_value_with_address_space);
1019 }
1020 }
1021
1022 MethodTyInfo = S.GetTypeForDeclarator(D&: ParamInfo);
1023 assert(MethodTyInfo && "no type from lambda-declarator");
1024
1025 // Check for unexpanded parameter packs in the method type.
1026 if (MethodTyInfo->getType()->containsUnexpandedParameterPack())
1027 S.DiagnoseUnexpandedParameterPack(Loc: Intro.Range.getBegin(), T: MethodTyInfo,
1028 UPPC: S.UPPC_DeclarationType);
1029 }
1030 return MethodTyInfo;
1031}
1032
1033CXXMethodDecl *Sema::CreateLambdaCallOperator(SourceRange IntroducerRange,
1034 CXXRecordDecl *Class) {
1035
1036 // C++20 [expr.prim.lambda.closure]p3:
1037 // The closure type for a lambda-expression has a public inline function
1038 // call operator (for a non-generic lambda) or function call operator
1039 // template (for a generic lambda) whose parameters and return type are
1040 // described by the lambda-expression's parameter-declaration-clause
1041 // and trailing-return-type respectively.
1042 DeclarationName MethodName =
1043 Context.DeclarationNames.getCXXOperatorName(Op: OO_Call);
1044 DeclarationNameLoc MethodNameLoc =
1045 DeclarationNameLoc::makeCXXOperatorNameLoc(Range: IntroducerRange.getBegin());
1046 CXXMethodDecl *Method = CXXMethodDecl::Create(
1047 C&: Context, RD: Class, StartLoc: SourceLocation(),
1048 NameInfo: DeclarationNameInfo(MethodName, IntroducerRange.getBegin(),
1049 MethodNameLoc),
1050 T: QualType(), /*Tinfo=*/TInfo: nullptr, SC: SC_None,
1051 UsesFPIntrin: getCurFPFeatures().isFPConstrained(),
1052 /*isInline=*/true, ConstexprKind: ConstexprSpecKind::Unspecified, EndLocation: SourceLocation(),
1053 /*TrailingRequiresClause=*/{});
1054 Method->setAccess(AS_public);
1055 return Method;
1056}
1057
1058void Sema::AddTemplateParametersToLambdaCallOperator(
1059 CXXMethodDecl *CallOperator, CXXRecordDecl *Class,
1060 TemplateParameterList *TemplateParams) {
1061 assert(TemplateParams && "no template parameters");
1062 FunctionTemplateDecl *TemplateMethod = FunctionTemplateDecl::Create(
1063 C&: Context, DC: Class, L: CallOperator->getLocation(), Name: CallOperator->getDeclName(),
1064 Params: TemplateParams, Decl: CallOperator);
1065 TemplateMethod->setAccess(AS_public);
1066 CallOperator->setDescribedFunctionTemplate(TemplateMethod);
1067}
1068
1069void Sema::CompleteLambdaCallOperator(
1070 CXXMethodDecl *Method, SourceLocation LambdaLoc,
1071 SourceLocation CallOperatorLoc,
1072 const AssociatedConstraint &TrailingRequiresClause,
1073 TypeSourceInfo *MethodTyInfo, ConstexprSpecKind ConstexprKind,
1074 StorageClass SC, ArrayRef<ParmVarDecl *> Params,
1075 bool HasExplicitResultType) {
1076
1077 LambdaScopeInfo *LSI = getCurrentLambdaScopeUnsafe(S&: *this);
1078
1079 if (TrailingRequiresClause)
1080 Method->setTrailingRequiresClause(TrailingRequiresClause);
1081
1082 TemplateParameterList *TemplateParams =
1083 getGenericLambdaTemplateParameterList(LSI, SemaRef&: *this);
1084
1085 DeclContext *DC = Method->getLexicalDeclContext();
1086 // DeclContext::addDecl() assumes that the DeclContext we're adding to is the
1087 // lexical context of the Method. Do so.
1088 Method->setLexicalDeclContext(LSI->Lambda);
1089 if (TemplateParams) {
1090 FunctionTemplateDecl *TemplateMethod =
1091 Method->getDescribedFunctionTemplate();
1092 assert(TemplateMethod &&
1093 "AddTemplateParametersToLambdaCallOperator should have been called");
1094
1095 LSI->Lambda->addDecl(D: TemplateMethod);
1096 TemplateMethod->setLexicalDeclContext(DC);
1097 } else {
1098 LSI->Lambda->addDecl(D: Method);
1099 }
1100 LSI->Lambda->setLambdaIsGeneric(TemplateParams);
1101 LSI->Lambda->setLambdaTypeInfo(MethodTyInfo);
1102
1103 Method->setLexicalDeclContext(DC);
1104 Method->setLocation(LambdaLoc);
1105 Method->setInnerLocStart(CallOperatorLoc);
1106 Method->setTypeSourceInfo(MethodTyInfo);
1107 Method->setType(buildTypeForLambdaCallOperator(S&: *this, Class: LSI->Lambda,
1108 TemplateParams, MethodTypeInfo: MethodTyInfo));
1109 Method->setConstexprKind(ConstexprKind);
1110 Method->setStorageClass(SC);
1111 if (!Params.empty()) {
1112 CheckParmsForFunctionDef(Parameters: Params, /*CheckParameterNames=*/false);
1113 Method->setParams(Params);
1114 for (auto P : Method->parameters()) {
1115 assert(P && "null in a parameter list");
1116 P->setOwningFunction(Method);
1117 }
1118 }
1119
1120 buildLambdaScopeReturnType(S&: *this, LSI, CallOperator: Method, ExplicitResultType: HasExplicitResultType);
1121
1122 // Not built by ActOnFunctionDeclarator, so tag it here.
1123 addImplicitCallingConvAbiTag(FD: Method);
1124}
1125
1126void Sema::ActOnLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro,
1127 Scope *CurrentScope) {
1128
1129 LambdaScopeInfo *LSI = getCurLambda();
1130 assert(LSI && "LambdaScopeInfo should be on stack!");
1131
1132 if (Intro.Default == LCD_ByCopy)
1133 LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByval;
1134 else if (Intro.Default == LCD_ByRef)
1135 LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByref;
1136 LSI->CaptureDefaultLoc = Intro.DefaultLoc;
1137 LSI->IntroducerRange = Intro.Range;
1138 LSI->AfterParameterList = false;
1139
1140 assert(LSI->NumExplicitTemplateParams == 0);
1141
1142 // Determine if we're within a context where we know that the lambda will
1143 // be dependent, because there are template parameters in scope.
1144 CXXRecordDecl::LambdaDependencyKind LambdaDependencyKind =
1145 CXXRecordDecl::LDK_Unknown;
1146 if (CurScope->getTemplateParamParent() != nullptr) {
1147 LambdaDependencyKind = CXXRecordDecl::LDK_AlwaysDependent;
1148 } else if (Scope *ParentScope = CurScope->getParent()) {
1149 // Given a lambda defined inside a requires expression,
1150 //
1151 // struct S {
1152 // S(auto var) requires requires { [&] -> decltype(var) { }; }
1153 // {}
1154 // };
1155 //
1156 // The parameter var is not injected into the function Decl at the point of
1157 // parsing lambda. In such scenarios, perceiving it as dependent could
1158 // result in the constraint being evaluated, which matches what GCC does.
1159 Scope *LookupScope = ParentScope;
1160 while (LookupScope->getEntity() &&
1161 LookupScope->getEntity()->isRequiresExprBody())
1162 LookupScope = LookupScope->getParent();
1163
1164 if (LookupScope != ParentScope &&
1165 LookupScope->isFunctionDeclarationScope() &&
1166 llvm::any_of(Range: LookupScope->decls(), P: [](Decl *D) {
1167 return isa<ParmVarDecl>(Val: D) &&
1168 cast<ParmVarDecl>(Val: D)->getType()->isTemplateTypeParmType();
1169 }))
1170 LambdaDependencyKind = CXXRecordDecl::LDK_AlwaysDependent;
1171 }
1172
1173 CXXRecordDecl *Class = createLambdaClosureType(
1174 IntroducerRange: Intro.Range, /*Info=*/nullptr, LambdaDependencyKind, CaptureDefault: Intro.Default);
1175 LSI->Lambda = Class;
1176
1177 CXXMethodDecl *Method = CreateLambdaCallOperator(IntroducerRange: Intro.Range, Class);
1178 LSI->CallOperator = Method;
1179 // Temporarily set the lexical declaration context to the current
1180 // context, so that the Scope stack matches the lexical nesting.
1181 Method->setLexicalDeclContext(CurContext);
1182
1183 PushDeclContext(S: CurScope, DC: Method);
1184
1185 bool ContainsUnexpandedParameterPack = false;
1186
1187 // Distinct capture names, for diagnostics.
1188 llvm::DenseMap<IdentifierInfo *, ValueDecl *> CaptureNames;
1189
1190 // Handle explicit captures.
1191 SourceLocation PrevCaptureLoc =
1192 Intro.Default == LCD_None ? Intro.Range.getBegin() : Intro.DefaultLoc;
1193 for (auto C = Intro.Captures.begin(), E = Intro.Captures.end(); C != E;
1194 PrevCaptureLoc = C->Loc, ++C) {
1195 if (C->Kind == LCK_This || C->Kind == LCK_StarThis) {
1196 if (C->Kind == LCK_StarThis)
1197 DiagCompat(Loc: C->Loc, CompatDiagId: diag_compat::star_this_lambda_capture);
1198
1199 // C++11 [expr.prim.lambda]p8:
1200 // An identifier or this shall not appear more than once in a
1201 // lambda-capture.
1202 if (LSI->isCXXThisCaptured()) {
1203 Diag(Loc: C->Loc, DiagID: diag::err_capture_more_than_once)
1204 << "'this'" << SourceRange(LSI->getCXXThisCapture().getLocation())
1205 << FixItHint::CreateRemoval(
1206 RemoveRange: SourceRange(getLocForEndOfToken(Loc: PrevCaptureLoc), C->Loc));
1207 continue;
1208 }
1209
1210 // C++20 [expr.prim.lambda]p8:
1211 // If a lambda-capture includes a capture-default that is =,
1212 // each simple-capture of that lambda-capture shall be of the form
1213 // "&identifier", "this", or "* this". [ Note: The form [&,this] is
1214 // redundant but accepted for compatibility with ISO C++14. --end note ]
1215 if (Intro.Default == LCD_ByCopy && C->Kind != LCK_StarThis)
1216 DiagCompat(Loc: C->Loc, CompatDiagId: diag_compat::equals_this_lambda_capture);
1217
1218 // C++11 [expr.prim.lambda]p12:
1219 // If this is captured by a local lambda expression, its nearest
1220 // enclosing function shall be a non-static member function.
1221 QualType ThisCaptureType = getCurrentThisType();
1222 if (ThisCaptureType.isNull()) {
1223 Diag(Loc: C->Loc, DiagID: diag::err_this_capture) << true;
1224 continue;
1225 }
1226
1227 CheckCXXThisCapture(Loc: C->Loc, /*Explicit=*/true, /*BuildAndDiagnose*/ true,
1228 /*FunctionScopeIndexToStopAtPtr*/ FunctionScopeIndexToStopAt: nullptr,
1229 ByCopy: C->Kind == LCK_StarThis);
1230 if (!LSI->Captures.empty())
1231 LSI->ExplicitCaptureRanges[LSI->Captures.size() - 1] = C->ExplicitRange;
1232 continue;
1233 }
1234
1235 assert(C->Id && "missing identifier for capture");
1236
1237 if (C->Init.isInvalid())
1238 continue;
1239
1240 ValueDecl *Var = nullptr;
1241 if (C->Init.isUsable()) {
1242 DiagCompat(Loc: C->Loc, CompatDiagId: diag_compat::init_capture);
1243
1244 // If the initializer expression is usable, but the InitCaptureType
1245 // is not, then an error has occurred - so ignore the capture for now.
1246 // for e.g., [n{0}] { }; <-- if no <initializer_list> is included.
1247 // FIXME: we should create the init capture variable and mark it invalid
1248 // in this case.
1249 if (C->InitCaptureType.get().isNull())
1250 continue;
1251
1252 if (C->Init.get()->containsUnexpandedParameterPack() &&
1253 !C->InitCaptureType.get()->getAs<PackExpansionType>())
1254 DiagnoseUnexpandedParameterPack(E: C->Init.get(), UPPC: UPPC_Initializer);
1255
1256 unsigned InitStyle;
1257 switch (C->InitKind) {
1258 case LambdaCaptureInitKind::NoInit:
1259 llvm_unreachable("not an init-capture?");
1260 case LambdaCaptureInitKind::CopyInit:
1261 InitStyle = VarDecl::CInit;
1262 break;
1263 case LambdaCaptureInitKind::DirectInit:
1264 InitStyle = VarDecl::CallInit;
1265 break;
1266 case LambdaCaptureInitKind::ListInit:
1267 InitStyle = VarDecl::ListInit;
1268 break;
1269 }
1270 Var = createLambdaInitCaptureVarDecl(Loc: C->Loc, InitCaptureType: C->InitCaptureType.get(),
1271 EllipsisLoc: C->EllipsisLoc, Id: C->Id, InitStyle,
1272 Init: C->Init.get(), DeclCtx: Method);
1273 assert(Var && "createLambdaInitCaptureVarDecl returned a null VarDecl?");
1274 if (auto *V = dyn_cast<VarDecl>(Val: Var))
1275 CheckShadow(S: CurrentScope, D: V);
1276 PushOnScopeChains(D: Var, S: CurrentScope, AddToContext: false);
1277 } else {
1278 assert(C->InitKind == LambdaCaptureInitKind::NoInit &&
1279 "init capture has valid but null init?");
1280
1281 // C++11 [expr.prim.lambda]p8:
1282 // If a lambda-capture includes a capture-default that is &, the
1283 // identifiers in the lambda-capture shall not be preceded by &.
1284 // If a lambda-capture includes a capture-default that is =, [...]
1285 // each identifier it contains shall be preceded by &.
1286 if (C->Kind == LCK_ByRef && Intro.Default == LCD_ByRef) {
1287 Diag(Loc: C->Loc, DiagID: diag::err_reference_capture_with_reference_default)
1288 << FixItHint::CreateRemoval(
1289 RemoveRange: SourceRange(getLocForEndOfToken(Loc: PrevCaptureLoc), C->Loc));
1290 continue;
1291 } else if (C->Kind == LCK_ByCopy && Intro.Default == LCD_ByCopy) {
1292 Diag(Loc: C->Loc, DiagID: diag::err_copy_capture_with_copy_default)
1293 << FixItHint::CreateRemoval(
1294 RemoveRange: SourceRange(getLocForEndOfToken(Loc: PrevCaptureLoc), C->Loc));
1295 continue;
1296 }
1297
1298 // C++11 [expr.prim.lambda]p10:
1299 // The identifiers in a capture-list are looked up using the usual
1300 // rules for unqualified name lookup (3.4.1)
1301 DeclarationNameInfo Name(C->Id, C->Loc);
1302 LookupResult R(*this, Name, LookupOrdinaryName);
1303 LookupName(R, S: CurScope);
1304 if (R.isAmbiguous())
1305 continue;
1306 if (R.empty()) {
1307 // FIXME: Disable corrections that would add qualification?
1308 CXXScopeSpec ScopeSpec;
1309 DeclFilterCCC<VarDecl> Validator{};
1310 if (DiagnoseEmptyLookup(S: CurScope, SS&: ScopeSpec, R, CCC&: Validator))
1311 continue;
1312 }
1313
1314 if (auto *BD = R.getAsSingle<BindingDecl>())
1315 Var = BD;
1316 else if (R.getAsSingle<FieldDecl>()) {
1317 Diag(Loc: C->Loc, DiagID: diag::err_capture_class_member_does_not_name_variable)
1318 << C->Id;
1319 continue;
1320 } else
1321 Var = R.getAsSingle<VarDecl>();
1322 if (Var && DiagnoseUseOfDecl(D: Var, Locs: C->Loc))
1323 continue;
1324 }
1325
1326 // C++11 [expr.prim.lambda]p10:
1327 // [...] each such lookup shall find a variable with automatic storage
1328 // duration declared in the reaching scope of the local lambda expression.
1329 // Note that the 'reaching scope' check happens in tryCaptureVariable().
1330 if (!Var) {
1331 Diag(Loc: C->Loc, DiagID: diag::err_capture_does_not_name_variable) << C->Id;
1332 continue;
1333 }
1334
1335 // C++11 [expr.prim.lambda]p8:
1336 // An identifier or this shall not appear more than once in a
1337 // lambda-capture.
1338 if (auto [It, Inserted] = CaptureNames.insert(KV: std::pair{C->Id, Var});
1339 !Inserted) {
1340 if (C->InitKind == LambdaCaptureInitKind::NoInit &&
1341 !Var->isInitCapture()) {
1342 Diag(Loc: C->Loc, DiagID: diag::err_capture_more_than_once)
1343 << C->Id << It->second->getBeginLoc()
1344 << FixItHint::CreateRemoval(
1345 RemoveRange: SourceRange(getLocForEndOfToken(Loc: PrevCaptureLoc), C->Loc));
1346 Var->setInvalidDecl();
1347 } else if (Var && Var->isPlaceholderVar(LangOpts: getLangOpts())) {
1348 DiagPlaceholderVariableDefinition(Loc: C->Loc);
1349 } else {
1350 // Previous capture captured something different (one or both was
1351 // an init-capture): no fixit.
1352 Diag(Loc: C->Loc, DiagID: diag::err_capture_more_than_once) << C->Id;
1353 continue;
1354 }
1355 }
1356
1357 // Ignore invalid decls; they'll just confuse the code later.
1358 if (Var->isInvalidDecl())
1359 continue;
1360
1361 VarDecl *Underlying = Var->getPotentiallyDecomposedVarDecl();
1362
1363 if (!Underlying->hasLocalStorage()) {
1364 Diag(Loc: C->Loc, DiagID: diag::err_capture_non_automatic_variable) << C->Id;
1365 Diag(Loc: Var->getLocation(), DiagID: diag::note_previous_decl) << C->Id;
1366 continue;
1367 }
1368
1369 // C++11 [expr.prim.lambda]p23:
1370 // A capture followed by an ellipsis is a pack expansion (14.5.3).
1371 SourceLocation EllipsisLoc;
1372 if (C->EllipsisLoc.isValid()) {
1373 if (Var->isParameterPack()) {
1374 EllipsisLoc = C->EllipsisLoc;
1375 } else {
1376 Diag(Loc: C->EllipsisLoc, DiagID: diag::err_pack_expansion_without_parameter_packs)
1377 << (C->Init.isUsable() ? C->Init.get()->getSourceRange()
1378 : SourceRange(C->Loc));
1379
1380 // Just ignore the ellipsis.
1381 }
1382 } else if (Var->isParameterPack()) {
1383 ContainsUnexpandedParameterPack = true;
1384 }
1385
1386 if (C->Init.isUsable()) {
1387 addInitCapture(LSI, Var: cast<VarDecl>(Val: Var), ByRef: C->Kind == LCK_ByRef);
1388 } else {
1389 TryCaptureKind Kind = C->Kind == LCK_ByRef
1390 ? TryCaptureKind::ExplicitByRef
1391 : TryCaptureKind::ExplicitByVal;
1392 tryCaptureVariable(Var, Loc: C->Loc, Kind, EllipsisLoc);
1393 }
1394 if (!LSI->Captures.empty())
1395 LSI->ExplicitCaptureRanges[LSI->Captures.size() - 1] = C->ExplicitRange;
1396 }
1397 finishLambdaExplicitCaptures(LSI);
1398 LSI->ContainsUnexpandedParameterPack |= ContainsUnexpandedParameterPack;
1399 PopDeclContext();
1400}
1401
1402void Sema::ActOnLambdaClosureQualifiers(LambdaIntroducer &Intro,
1403 SourceLocation MutableLoc) {
1404
1405 LambdaScopeInfo *LSI = getCurrentLambdaScopeUnsafe(S&: *this);
1406 LSI->Mutable = MutableLoc.isValid();
1407 ContextRAII Context(*this, LSI->CallOperator, /*NewThisContext*/ false);
1408
1409 // C++11 [expr.prim.lambda]p9:
1410 // A lambda-expression whose smallest enclosing scope is a block scope is a
1411 // local lambda expression; any other lambda expression shall not have a
1412 // capture-default or simple-capture in its lambda-introducer.
1413 //
1414 // For simple-captures, this is covered by the check below that any named
1415 // entity is a variable that can be captured.
1416 //
1417 // For DR1632, we also allow a capture-default in any context where we can
1418 // odr-use 'this' (in particular, in a default initializer for a non-static
1419 // data member).
1420 if (Intro.Default != LCD_None &&
1421 !LSI->Lambda->getParent()
1422 ->getEnclosingNonExpansionStatementContext()
1423 ->isFunctionOrMethod() &&
1424 (getCurrentThisType().isNull() ||
1425 CheckCXXThisCapture(Loc: SourceLocation(), /*Explicit=*/true,
1426 /*BuildAndDiagnose=*/false)))
1427 Diag(Loc: Intro.DefaultLoc, DiagID: diag::err_capture_default_non_local);
1428}
1429
1430void Sema::ActOnLambdaClosureParameters(
1431 Scope *LambdaScope, MutableArrayRef<DeclaratorChunk::ParamInfo> Params) {
1432 LambdaScopeInfo *LSI = getCurrentLambdaScopeUnsafe(S&: *this);
1433 PushDeclContext(S: LambdaScope, DC: LSI->CallOperator);
1434
1435 for (const DeclaratorChunk::ParamInfo &P : Params) {
1436 auto *Param = cast<ParmVarDecl>(Val: P.Param);
1437 Param->setOwningFunction(LSI->CallOperator);
1438 if (Param->getIdentifier())
1439 PushOnScopeChains(D: Param, S: LambdaScope, AddToContext: false);
1440 }
1441
1442 // After the parameter list, we may parse a noexcept/requires/trailing return
1443 // type which need to know whether the call operator constiture a dependent
1444 // context, so we need to setup the FunctionTemplateDecl of generic lambdas
1445 // now.
1446 TemplateParameterList *TemplateParams =
1447 getGenericLambdaTemplateParameterList(LSI, SemaRef&: *this);
1448 if (TemplateParams) {
1449 AddTemplateParametersToLambdaCallOperator(CallOperator: LSI->CallOperator, Class: LSI->Lambda,
1450 TemplateParams);
1451 LSI->Lambda->setLambdaIsGeneric(true);
1452 LSI->ContainsUnexpandedParameterPack |=
1453 TemplateParams->containsUnexpandedParameterPack();
1454 }
1455 LSI->AfterParameterList = true;
1456}
1457
1458void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
1459 Declarator &ParamInfo,
1460 const DeclSpec &DS) {
1461
1462 LambdaScopeInfo *LSI = getCurrentLambdaScopeUnsafe(S&: *this);
1463 LSI->CallOperator->setConstexprKind(DS.getConstexprSpecifier());
1464 LSI->BeforeCompoundStatement = false;
1465
1466 SmallVector<ParmVarDecl *, 8> Params;
1467 bool ExplicitResultType;
1468
1469 SourceLocation TypeLoc, CallOperatorLoc;
1470 if (ParamInfo.getNumTypeObjects() == 0) {
1471 CallOperatorLoc = TypeLoc = Intro.Range.getEnd();
1472 } else {
1473 unsigned Index;
1474 ParamInfo.isFunctionDeclarator(idx&: Index);
1475 const auto &Object = ParamInfo.getTypeObject(i: Index);
1476 TypeLoc =
1477 Object.Loc.isValid() ? Object.Loc : ParamInfo.getSourceRange().getEnd();
1478 CallOperatorLoc = ParamInfo.getSourceRange().getEnd();
1479 }
1480
1481 CXXRecordDecl *Class = LSI->Lambda;
1482 CXXMethodDecl *Method = LSI->CallOperator;
1483
1484 TypeSourceInfo *MethodTyInfo = getLambdaType(
1485 S&: *this, Intro, ParamInfo, CurScope: getCurScope(), Loc: TypeLoc, ExplicitResultType);
1486
1487 if (ParamInfo.isFunctionDeclarator() != 0) {
1488 const auto &FTI = ParamInfo.getFunctionTypeInfo();
1489 LSI->ExplicitParams = FTI.getLParenLoc().isValid();
1490 if (!FTIHasSingleVoidParameter(FTI)) {
1491 Params.reserve(N: Params.size());
1492 for (unsigned I = 0; I < FTI.NumParams; ++I) {
1493 auto *Param = cast<ParmVarDecl>(Val: FTI.Params[I].Param);
1494 Param->setScopeInfo(scopeDepth: 0, parameterIndex: Params.size());
1495 Params.push_back(Elt: Param);
1496 }
1497 }
1498 }
1499
1500 bool IsLambdaStatic =
1501 ParamInfo.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static;
1502
1503 CompleteLambdaCallOperator(
1504 Method, LambdaLoc: Intro.Range.getBegin(), CallOperatorLoc,
1505 TrailingRequiresClause: AssociatedConstraint(ParamInfo.getTrailingRequiresClause()), MethodTyInfo,
1506 ConstexprKind: ParamInfo.getDeclSpec().getConstexprSpecifier(),
1507 SC: IsLambdaStatic ? SC_Static : SC_None, Params, HasExplicitResultType: ExplicitResultType);
1508
1509 CheckCXXDefaultArguments(FD: Method);
1510
1511 // code_seg attribute on lambda apply to the method.
1512 if (Attr *A = getImplicitCodeSegOrSectionAttrForFunction(
1513 FD: Method, /*IsDefinition=*/true))
1514 Method->addAttr(A);
1515
1516 // Attributes on the lambda apply to the method.
1517 ProcessDeclAttributes(S: CurScope, D: Method, PD: ParamInfo);
1518
1519 // This represents the function body for the lambda function, check if we
1520 // have to apply optnone due to a pragma.
1521 AddRangeBasedOptnone(FD: Method);
1522
1523 if (Context.getTargetInfo().getTriple().isAArch64())
1524 ARM().CheckSMEFunctionDefAttributes(FD: Method);
1525
1526 // CUDA lambdas get implicit host and device attributes.
1527 if (getLangOpts().CUDA)
1528 CUDA().SetLambdaAttrs(Method);
1529
1530 // OpenMP lambdas might get assumumption attributes.
1531 if (LangOpts.OpenMP)
1532 OpenMP().ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(D: Method);
1533
1534 handleLambdaNumbering(Class, Method);
1535
1536 for (auto &&C : LSI->Captures) {
1537 if (!C.isVariableCapture())
1538 continue;
1539 ValueDecl *Var = C.getVariable();
1540 if (Var && Var->isInitCapture()) {
1541 PushOnScopeChains(D: Var, S: CurScope, AddToContext: false);
1542 }
1543 }
1544
1545 auto CheckRedefinition = [&](ParmVarDecl *Param) {
1546 for (const auto &Capture : Intro.Captures) {
1547 if (Capture.Id == Param->getIdentifier()) {
1548 Diag(Loc: Param->getLocation(), DiagID: diag::err_parameter_shadow_capture);
1549 Diag(Loc: Capture.Loc, DiagID: diag::note_var_explicitly_captured_here)
1550 << Capture.Id << true;
1551 return false;
1552 }
1553 }
1554 return true;
1555 };
1556
1557 for (ParmVarDecl *P : Params) {
1558 if (!P->getIdentifier())
1559 continue;
1560 if (CheckRedefinition(P))
1561 CheckShadow(S: CurScope, D: P);
1562 PushOnScopeChains(D: P, S: CurScope);
1563 }
1564
1565 // C++23 [expr.prim.lambda.capture]p5:
1566 // If an identifier in a capture appears as the declarator-id of a parameter
1567 // of the lambda-declarator's parameter-declaration-clause or as the name of a
1568 // template parameter of the lambda-expression's template-parameter-list, the
1569 // program is ill-formed.
1570 TemplateParameterList *TemplateParams =
1571 getGenericLambdaTemplateParameterList(LSI, SemaRef&: *this);
1572 if (TemplateParams) {
1573 for (const auto *TP : TemplateParams->asArray()) {
1574 if (!TP->getIdentifier())
1575 continue;
1576 for (const auto &Capture : Intro.Captures) {
1577 if (Capture.Id == TP->getIdentifier()) {
1578 Diag(Loc: Capture.Loc, DiagID: diag::err_template_param_shadow) << Capture.Id;
1579 NoteTemplateParameterLocation(Decl: *TP);
1580 }
1581 }
1582 }
1583 }
1584
1585 // C++20: dcl.decl.general p4:
1586 // The optional requires-clause ([temp.pre]) in an init-declarator or
1587 // member-declarator shall be present only if the declarator declares a
1588 // templated function ([dcl.fct]).
1589 if (const AssociatedConstraint &TRC = Method->getTrailingRequiresClause()) {
1590 // [temp.pre]/8:
1591 // An entity is templated if it is
1592 // - a template,
1593 // - an entity defined ([basic.def]) or created ([class.temporary]) in a
1594 // templated entity,
1595 // - a member of a templated entity,
1596 // - an enumerator for an enumeration that is a templated entity, or
1597 // - the closure type of a lambda-expression ([expr.prim.lambda.closure])
1598 // appearing in the declaration of a templated entity. [Note 6: A local
1599 // class, a local or block variable, or a friend function defined in a
1600 // templated entity is a templated entity. — end note]
1601 //
1602 // A templated function is a function template or a function that is
1603 // templated. A templated class is a class template or a class that is
1604 // templated. A templated variable is a variable template or a variable
1605 // that is templated.
1606
1607 // Note: we only have to check if this is defined in a template entity, OR
1608 // if we are a template, since the rest don't apply. The requires clause
1609 // applies to the call operator, which we already know is a member function,
1610 // AND defined.
1611 if (!Method->getDescribedFunctionTemplate() && !Method->isTemplated()) {
1612 Diag(Loc: TRC.ConstraintExpr->getBeginLoc(),
1613 DiagID: diag::err_constrained_non_templated_function);
1614 }
1615 }
1616
1617 // Enter a new evaluation context to insulate the lambda from any
1618 // cleanups from the enclosing full-expression.
1619 PushExpressionEvaluationContextForFunction(
1620 NewContext: ExpressionEvaluationContext::PotentiallyEvaluated, FD: LSI->CallOperator);
1621}
1622
1623void Sema::ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,
1624 bool IsInstantiation) {
1625 LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(Val: FunctionScopes.back());
1626
1627 // Leave the expression-evaluation context.
1628 DiscardCleanupsInEvaluationContext();
1629 PopExpressionEvaluationContext();
1630
1631 // Leave the context of the lambda.
1632 if (!IsInstantiation)
1633 PopDeclContext();
1634
1635 // Finalize the lambda.
1636 CXXRecordDecl *Class = LSI->Lambda;
1637 Class->setInvalidDecl();
1638 SmallVector<Decl*, 4> Fields(Class->fields());
1639 ActOnFields(S: nullptr, RecLoc: Class->getLocation(), TagDecl: Class, Fields, LBrac: SourceLocation(),
1640 RBrac: SourceLocation(), AttrList: ParsedAttributesView());
1641 CheckCompletedCXXClass(S: nullptr, Record: Class);
1642
1643 PopFunctionScopeInfo();
1644}
1645
1646template <typename Func>
1647static void repeatForLambdaConversionFunctionCallingConvs(
1648 Sema &S, const FunctionProtoType &CallOpProto, Func F) {
1649 CallingConv DefaultFree = S.Context.getDefaultCallingConvention(
1650 IsVariadic: CallOpProto.isVariadic(), /*IsCXXMethod=*/false);
1651 CallingConv DefaultMember = S.Context.getDefaultCallingConvention(
1652 IsVariadic: CallOpProto.isVariadic(), /*IsCXXMethod=*/true);
1653 CallingConv CallOpCC = CallOpProto.getCallConv();
1654
1655 /// Implement emitting a version of the operator for many of the calling
1656 /// conventions for MSVC, as described here:
1657 /// https://devblogs.microsoft.com/oldnewthing/20150220-00/?p=44623.
1658 /// Experimentally, we determined that cdecl, stdcall, fastcall, and
1659 /// vectorcall are generated by MSVC when it is supported by the target.
1660 /// Additionally, we are ensuring that the default-free/default-member and
1661 /// call-operator calling convention are generated as well.
1662 /// NOTE: We intentionally generate a 'thiscall' on Win32 implicitly from the
1663 /// 'member default', despite MSVC not doing so. We do this in order to ensure
1664 /// that someone who intentionally places 'thiscall' on the lambda call
1665 /// operator will still get that overload, since we don't have the a way of
1666 /// detecting the attribute by the time we get here.
1667 if (S.getLangOpts().MSVCCompat) {
1668 CallingConv Convs[] = {
1669 CC_C, CC_X86StdCall, CC_X86FastCall, CC_X86VectorCall,
1670 DefaultFree, DefaultMember, CallOpCC};
1671 llvm::sort(C&: Convs);
1672 llvm::iterator_range<CallingConv *> Range(std::begin(arr&: Convs),
1673 llvm::unique(R&: Convs));
1674 const TargetInfo &TI = S.getASTContext().getTargetInfo();
1675
1676 for (CallingConv C : Range) {
1677 if (TI.checkCallingConvention(CC: C) == TargetInfo::CCCR_OK)
1678 F(C);
1679 }
1680 return;
1681 }
1682
1683 if (CallOpCC == DefaultMember && DefaultMember != DefaultFree) {
1684 F(DefaultFree);
1685 F(DefaultMember);
1686 } else {
1687 F(CallOpCC);
1688 }
1689}
1690
1691// Returns the 'standard' calling convention to be used for the lambda
1692// conversion function, that is, the 'free' function calling convention unless
1693// it is overridden by a non-default calling convention attribute.
1694static CallingConv
1695getLambdaConversionFunctionCallConv(Sema &S,
1696 const FunctionProtoType *CallOpProto) {
1697 CallingConv DefaultFree = S.Context.getDefaultCallingConvention(
1698 IsVariadic: CallOpProto->isVariadic(), /*IsCXXMethod=*/false);
1699 CallingConv DefaultMember = S.Context.getDefaultCallingConvention(
1700 IsVariadic: CallOpProto->isVariadic(), /*IsCXXMethod=*/true);
1701 CallingConv CallOpCC = CallOpProto->getCallConv();
1702
1703 // If the call-operator hasn't been changed, return both the 'free' and
1704 // 'member' function calling convention.
1705 if (CallOpCC == DefaultMember && DefaultMember != DefaultFree)
1706 return DefaultFree;
1707 return CallOpCC;
1708}
1709
1710QualType Sema::getLambdaConversionFunctionResultType(
1711 const FunctionProtoType *CallOpProto, CallingConv CC) {
1712 const FunctionProtoType::ExtProtoInfo CallOpExtInfo =
1713 CallOpProto->getExtProtoInfo();
1714 FunctionProtoType::ExtProtoInfo InvokerExtInfo = CallOpExtInfo;
1715 InvokerExtInfo.ExtInfo = InvokerExtInfo.ExtInfo.withCallingConv(cc: CC);
1716 InvokerExtInfo.TypeQuals = Qualifiers();
1717 assert(InvokerExtInfo.RefQualifier == RQ_None &&
1718 "Lambda's call operator should not have a reference qualifier");
1719 return Context.getFunctionType(ResultTy: CallOpProto->getReturnType(),
1720 Args: CallOpProto->getParamTypes(), EPI: InvokerExtInfo);
1721}
1722
1723/// Add a lambda's conversion to function pointer, as described in
1724/// C++11 [expr.prim.lambda]p6.
1725static void addFunctionPointerConversion(Sema &S, SourceRange IntroducerRange,
1726 CXXRecordDecl *Class,
1727 CXXMethodDecl *CallOperator,
1728 QualType InvokerFunctionTy) {
1729 // This conversion is explicitly disabled if the lambda's function has
1730 // pass_object_size attributes on any of its parameters.
1731 auto HasPassObjectSizeAttr = [](const ParmVarDecl *P) {
1732 return P->hasAttr<PassObjectSizeAttr>();
1733 };
1734 if (llvm::any_of(Range: CallOperator->parameters(), P: HasPassObjectSizeAttr))
1735 return;
1736
1737 // Add the conversion to function pointer.
1738 QualType PtrToFunctionTy = S.Context.getPointerType(T: InvokerFunctionTy);
1739
1740 // Create the type of the conversion function.
1741 FunctionProtoType::ExtProtoInfo ConvExtInfo(
1742 S.Context.getDefaultCallingConvention(
1743 /*IsVariadic=*/false, /*IsCXXMethod=*/true));
1744 // The conversion function is always const and noexcept.
1745 ConvExtInfo.TypeQuals = Qualifiers();
1746 ConvExtInfo.TypeQuals.addConst();
1747 ConvExtInfo.ExceptionSpec.Type = EST_BasicNoexcept;
1748 QualType ConvTy = S.Context.getFunctionType(ResultTy: PtrToFunctionTy, Args: {}, EPI: ConvExtInfo);
1749
1750 SourceLocation Loc = IntroducerRange.getBegin();
1751 DeclarationName ConversionName
1752 = S.Context.DeclarationNames.getCXXConversionFunctionName(
1753 Ty: S.Context.getCanonicalType(T: PtrToFunctionTy));
1754 // Construct a TypeSourceInfo for the conversion function, and wire
1755 // all the parameters appropriately for the FunctionProtoTypeLoc
1756 // so that everything works during transformation/instantiation of
1757 // generic lambdas.
1758 // The main reason for wiring up the parameters of the conversion
1759 // function with that of the call operator is so that constructs
1760 // like the following work:
1761 // auto L = [](auto b) { <-- 1
1762 // return [](auto a) -> decltype(a) { <-- 2
1763 // return a;
1764 // };
1765 // };
1766 // int (*fp)(int) = L(5);
1767 // Because the trailing return type can contain DeclRefExprs that refer
1768 // to the original call operator's variables, we hijack the call
1769 // operators ParmVarDecls below.
1770 TypeSourceInfo *ConvNamePtrToFunctionTSI =
1771 S.Context.getTrivialTypeSourceInfo(T: PtrToFunctionTy, Loc);
1772 DeclarationNameLoc ConvNameLoc =
1773 DeclarationNameLoc::makeNamedTypeLoc(TInfo: ConvNamePtrToFunctionTSI);
1774
1775 // The conversion function is a conversion to a pointer-to-function.
1776 TypeSourceInfo *ConvTSI = S.Context.getTrivialTypeSourceInfo(T: ConvTy, Loc);
1777 FunctionProtoTypeLoc ConvTL =
1778 ConvTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>();
1779 // Get the result of the conversion function which is a pointer-to-function.
1780 PointerTypeLoc PtrToFunctionTL =
1781 ConvTL.getReturnLoc().getAs<PointerTypeLoc>();
1782 // Do the same for the TypeSourceInfo that is used to name the conversion
1783 // operator.
1784 PointerTypeLoc ConvNamePtrToFunctionTL =
1785 ConvNamePtrToFunctionTSI->getTypeLoc().getAs<PointerTypeLoc>();
1786
1787 // Get the underlying function types that the conversion function will
1788 // be converting to (should match the type of the call operator).
1789 FunctionProtoTypeLoc CallOpConvTL =
1790 PtrToFunctionTL.getPointeeLoc().getAs<FunctionProtoTypeLoc>();
1791 FunctionProtoTypeLoc CallOpConvNameTL =
1792 ConvNamePtrToFunctionTL.getPointeeLoc().getAs<FunctionProtoTypeLoc>();
1793
1794 // Wire up the FunctionProtoTypeLocs with the call operator's parameters.
1795 // These parameter's are essentially used to transform the name and
1796 // the type of the conversion operator. By using the same parameters
1797 // as the call operator's we don't have to fix any back references that
1798 // the trailing return type of the call operator's uses (such as
1799 // decltype(some_type<decltype(a)>::type{} + decltype(a){}) etc.)
1800 // - we can simply use the return type of the call operator, and
1801 // everything should work.
1802 SmallVector<ParmVarDecl *, 4> InvokerParams;
1803 for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) {
1804 ParmVarDecl *From = CallOperator->getParamDecl(i: I);
1805
1806 InvokerParams.push_back(Elt: ParmVarDecl::Create(
1807 C&: S.Context,
1808 // Temporarily add to the TU. This is set to the invoker below.
1809 DC: S.Context.getTranslationUnitDecl(), StartLoc: From->getBeginLoc(),
1810 IdLoc: From->getLocation(), Id: From->getIdentifier(), T: From->getType(),
1811 TInfo: From->getTypeSourceInfo(), S: From->getStorageClass(),
1812 /*DefArg=*/nullptr));
1813 CallOpConvTL.setParam(i: I, VD: From);
1814 CallOpConvNameTL.setParam(i: I, VD: From);
1815 }
1816
1817 CXXConversionDecl *Conversion = CXXConversionDecl::Create(
1818 C&: S.Context, RD: Class, StartLoc: Loc,
1819 NameInfo: DeclarationNameInfo(ConversionName, Loc, ConvNameLoc), T: ConvTy, TInfo: ConvTSI,
1820 UsesFPIntrin: S.getCurFPFeatures().isFPConstrained(),
1821 /*isInline=*/true, ES: ExplicitSpecifier(),
1822 ConstexprKind: S.getLangOpts().CPlusPlus17 ? ConstexprSpecKind::Constexpr
1823 : ConstexprSpecKind::Unspecified,
1824 EndLocation: CallOperator->getBody()->getEndLoc());
1825 Conversion->setAccess(AS_public);
1826 Conversion->setImplicit(true);
1827
1828 // A non-generic lambda may still be a templated entity. We need to preserve
1829 // constraints when converting the lambda to a function pointer. See GH63181.
1830 if (const AssociatedConstraint &Requires =
1831 CallOperator->getTrailingRequiresClause())
1832 Conversion->setTrailingRequiresClause(Requires);
1833
1834 if (Class->isGenericLambda()) {
1835 // Create a template version of the conversion operator, using the template
1836 // parameter list of the function call operator.
1837 FunctionTemplateDecl *TemplateCallOperator =
1838 CallOperator->getDescribedFunctionTemplate();
1839 FunctionTemplateDecl *ConversionTemplate =
1840 FunctionTemplateDecl::Create(C&: S.Context, DC: Class,
1841 L: Loc, Name: ConversionName,
1842 Params: TemplateCallOperator->getTemplateParameters(),
1843 Decl: Conversion);
1844 ConversionTemplate->setAccess(AS_public);
1845 ConversionTemplate->setImplicit(true);
1846 Conversion->setDescribedFunctionTemplate(ConversionTemplate);
1847 Class->addDecl(D: ConversionTemplate);
1848 } else
1849 Class->addDecl(D: Conversion);
1850
1851 // If the lambda is not static, we need to add a static member
1852 // function that will be the result of the conversion with a
1853 // certain unique ID.
1854 // When it is static we just return the static call operator instead.
1855 if (CallOperator->isImplicitObjectMemberFunction()) {
1856 DeclarationName InvokerName =
1857 &S.Context.Idents.get(Name: getLambdaStaticInvokerName());
1858 // FIXME: Instead of passing in the CallOperator->getTypeSourceInfo()
1859 // we should get a prebuilt TrivialTypeSourceInfo from Context
1860 // using FunctionTy & Loc and get its TypeLoc as a FunctionProtoTypeLoc
1861 // then rewire the parameters accordingly, by hoisting up the InvokeParams
1862 // loop below and then use its Params to set Invoke->setParams(...) below.
1863 // This would avoid the 'const' qualifier of the calloperator from
1864 // contaminating the type of the invoker, which is currently adjusted
1865 // in SemaTemplateDeduction.cpp:DeduceTemplateArguments. Fixing the
1866 // trailing return type of the invoker would require a visitor to rebuild
1867 // the trailing return type and adjusting all back DeclRefExpr's to refer
1868 // to the new static invoker parameters - not the call operator's.
1869 CXXMethodDecl *Invoke = CXXMethodDecl::Create(
1870 C&: S.Context, RD: Class, StartLoc: Loc, NameInfo: DeclarationNameInfo(InvokerName, Loc),
1871 T: InvokerFunctionTy, TInfo: CallOperator->getTypeSourceInfo(), SC: SC_Static,
1872 UsesFPIntrin: S.getCurFPFeatures().isFPConstrained(),
1873 /*isInline=*/true, ConstexprKind: CallOperator->getConstexprKind(),
1874 EndLocation: CallOperator->getBody()->getEndLoc());
1875 for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I)
1876 InvokerParams[I]->setOwningFunction(Invoke);
1877 Invoke->setParams(InvokerParams);
1878 Invoke->setAccess(AS_private);
1879 Invoke->setImplicit(true);
1880 if (Class->isGenericLambda()) {
1881 FunctionTemplateDecl *TemplateCallOperator =
1882 CallOperator->getDescribedFunctionTemplate();
1883 FunctionTemplateDecl *StaticInvokerTemplate =
1884 FunctionTemplateDecl::Create(
1885 C&: S.Context, DC: Class, L: Loc, Name: InvokerName,
1886 Params: TemplateCallOperator->getTemplateParameters(), Decl: Invoke);
1887 StaticInvokerTemplate->setAccess(AS_private);
1888 StaticInvokerTemplate->setImplicit(true);
1889 Invoke->setDescribedFunctionTemplate(StaticInvokerTemplate);
1890 Class->addDecl(D: StaticInvokerTemplate);
1891 } else
1892 Class->addDecl(D: Invoke);
1893 }
1894}
1895
1896/// Add a lambda's conversion to function pointers, as described in
1897/// C++11 [expr.prim.lambda]p6. Note that in most cases, this should emit only a
1898/// single pointer conversion. In the event that the default calling convention
1899/// for free and member functions is different, it will emit both conventions.
1900static void addFunctionPointerConversions(Sema &S, SourceRange IntroducerRange,
1901 CXXRecordDecl *Class,
1902 CXXMethodDecl *CallOperator) {
1903 const FunctionProtoType *CallOpProto =
1904 CallOperator->getType()->castAs<FunctionProtoType>();
1905
1906 repeatForLambdaConversionFunctionCallingConvs(
1907 S, CallOpProto: *CallOpProto, F: [&](CallingConv CC) {
1908 QualType InvokerFunctionTy =
1909 S.getLambdaConversionFunctionResultType(CallOpProto, CC);
1910 addFunctionPointerConversion(S, IntroducerRange, Class, CallOperator,
1911 InvokerFunctionTy);
1912 });
1913}
1914
1915/// Add a lambda's conversion to block pointer.
1916static void addBlockPointerConversion(Sema &S,
1917 SourceRange IntroducerRange,
1918 CXXRecordDecl *Class,
1919 CXXMethodDecl *CallOperator) {
1920 const FunctionProtoType *CallOpProto =
1921 CallOperator->getType()->castAs<FunctionProtoType>();
1922 QualType FunctionTy = S.getLambdaConversionFunctionResultType(
1923 CallOpProto, CC: getLambdaConversionFunctionCallConv(S, CallOpProto));
1924 QualType BlockPtrTy = S.Context.getBlockPointerType(T: FunctionTy);
1925
1926 FunctionProtoType::ExtProtoInfo ConversionEPI(
1927 S.Context.getDefaultCallingConvention(
1928 /*IsVariadic=*/false, /*IsCXXMethod=*/true));
1929 ConversionEPI.TypeQuals = Qualifiers();
1930 ConversionEPI.TypeQuals.addConst();
1931 QualType ConvTy = S.Context.getFunctionType(ResultTy: BlockPtrTy, Args: {}, EPI: ConversionEPI);
1932
1933 SourceLocation Loc = IntroducerRange.getBegin();
1934 DeclarationName Name
1935 = S.Context.DeclarationNames.getCXXConversionFunctionName(
1936 Ty: S.Context.getCanonicalType(T: BlockPtrTy));
1937 DeclarationNameLoc NameLoc = DeclarationNameLoc::makeNamedTypeLoc(
1938 TInfo: S.Context.getTrivialTypeSourceInfo(T: BlockPtrTy, Loc));
1939 CXXConversionDecl *Conversion = CXXConversionDecl::Create(
1940 C&: S.Context, RD: Class, StartLoc: Loc, NameInfo: DeclarationNameInfo(Name, Loc, NameLoc), T: ConvTy,
1941 TInfo: S.Context.getTrivialTypeSourceInfo(T: ConvTy, Loc),
1942 UsesFPIntrin: S.getCurFPFeatures().isFPConstrained(),
1943 /*isInline=*/true, ES: ExplicitSpecifier(), ConstexprKind: ConstexprSpecKind::Unspecified,
1944 EndLocation: CallOperator->getBody()->getEndLoc());
1945 Conversion->setAccess(AS_public);
1946 Conversion->setImplicit(true);
1947 Class->addDecl(D: Conversion);
1948}
1949
1950ExprResult Sema::BuildCaptureInit(const Capture &Cap,
1951 SourceLocation ImplicitCaptureLoc,
1952 bool IsOpenMPMapping) {
1953 // VLA captures don't have a stored initialization expression.
1954 if (Cap.isVLATypeCapture())
1955 return ExprResult();
1956
1957 // An init-capture is initialized directly from its stored initializer.
1958 if (Cap.isInitCapture())
1959 return cast<VarDecl>(Val: Cap.getVariable())->getInit();
1960
1961 // For anything else, build an initialization expression. For an implicit
1962 // capture, the capture notionally happens at the capture-default, so use
1963 // that location here.
1964 SourceLocation Loc =
1965 ImplicitCaptureLoc.isValid() ? ImplicitCaptureLoc : Cap.getLocation();
1966
1967 // C++11 [expr.prim.lambda]p21:
1968 // When the lambda-expression is evaluated, the entities that
1969 // are captured by copy are used to direct-initialize each
1970 // corresponding non-static data member of the resulting closure
1971 // object. (For array members, the array elements are
1972 // direct-initialized in increasing subscript order.) These
1973 // initializations are performed in the (unspecified) order in
1974 // which the non-static data members are declared.
1975
1976 // C++ [expr.prim.lambda]p12:
1977 // An entity captured by a lambda-expression is odr-used (3.2) in
1978 // the scope containing the lambda-expression.
1979 ExprResult Init;
1980 IdentifierInfo *Name = nullptr;
1981 if (Cap.isThisCapture()) {
1982 QualType ThisTy = getCurrentThisType();
1983 Expr *This = BuildCXXThisExpr(Loc, Type: ThisTy, IsImplicit: ImplicitCaptureLoc.isValid());
1984 if (Cap.isCopyCapture())
1985 Init = CreateBuiltinUnaryOp(OpLoc: Loc, Opc: UO_Deref, InputExpr: This);
1986 else
1987 Init = This;
1988 } else {
1989 assert(Cap.isVariableCapture() && "unknown kind of capture");
1990 ValueDecl *Var = Cap.getVariable();
1991 Name = Var->getIdentifier();
1992 Init = BuildDeclarationNameExpr(
1993 SS: CXXScopeSpec(), NameInfo: DeclarationNameInfo(Var->getDeclName(), Loc), D: Var);
1994 }
1995
1996 // In OpenMP, the capture kind doesn't actually describe how to capture:
1997 // variables are "mapped" onto the device in a process that does not formally
1998 // make a copy, even for a "copy capture".
1999 if (IsOpenMPMapping)
2000 return Init;
2001
2002 if (Init.isInvalid())
2003 return ExprError();
2004
2005 Expr *InitExpr = Init.get();
2006 InitializedEntity Entity = InitializedEntity::InitializeLambdaCapture(
2007 VarID: Name, FieldType: Cap.getCaptureType(), Loc);
2008 InitializationKind InitKind =
2009 InitializationKind::CreateDirect(InitLoc: Loc, LParenLoc: Loc, RParenLoc: Loc);
2010 InitializationSequence InitSeq(*this, Entity, InitKind, InitExpr);
2011 return InitSeq.Perform(S&: *this, Entity, Kind: InitKind, Args: InitExpr);
2012}
2013
2014ExprResult Sema::ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body) {
2015 LambdaScopeInfo &LSI = *cast<LambdaScopeInfo>(Val: FunctionScopes.back());
2016
2017 if (LSI.CallOperator->hasAttr<SYCLKernelEntryPointAttr>())
2018 SYCL().CheckSYCLEntryPointFunctionDecl(FD: LSI.CallOperator);
2019
2020 ActOnFinishFunctionBody(Decl: LSI.CallOperator, Body, /*IsInstantiation=*/false,
2021 /*RetainFunctionScopeInfo=*/true);
2022
2023 return BuildLambdaExpr(StartLoc, EndLoc: Body->getEndLoc());
2024}
2025
2026static LambdaCaptureDefault
2027mapImplicitCaptureStyle(CapturingScopeInfo::ImplicitCaptureStyle ICS) {
2028 switch (ICS) {
2029 case CapturingScopeInfo::ImpCap_None:
2030 return LCD_None;
2031 case CapturingScopeInfo::ImpCap_LambdaByval:
2032 return LCD_ByCopy;
2033 case CapturingScopeInfo::ImpCap_CapturedRegion:
2034 case CapturingScopeInfo::ImpCap_LambdaByref:
2035 return LCD_ByRef;
2036 case CapturingScopeInfo::ImpCap_Block:
2037 llvm_unreachable("block capture in lambda");
2038 }
2039 llvm_unreachable("Unknown implicit capture style");
2040}
2041
2042bool Sema::CaptureHasSideEffects(const Capture &From) {
2043 if (From.isInitCapture()) {
2044 Expr *Init = cast<VarDecl>(Val: From.getVariable())->getInit();
2045 if (Init && Init->HasSideEffects(Ctx: Context))
2046 return true;
2047 }
2048
2049 if (!From.isCopyCapture())
2050 return false;
2051
2052 const QualType T = From.isThisCapture()
2053 ? getCurrentThisType()->getPointeeType()
2054 : From.getCaptureType();
2055
2056 if (T.isVolatileQualified())
2057 return true;
2058
2059 const Type *BaseT = T->getBaseElementTypeUnsafe();
2060 if (const CXXRecordDecl *RD = BaseT->getAsCXXRecordDecl())
2061 return !RD->isCompleteDefinition() || !RD->hasTrivialCopyConstructor() ||
2062 !RD->hasTrivialDestructor();
2063
2064 return false;
2065}
2066
2067bool Sema::DiagnoseUnusedLambdaCapture(SourceRange CaptureRange,
2068 SourceRange FixItRange,
2069 const Capture &From) {
2070 if (CaptureHasSideEffects(From))
2071 return false;
2072
2073 if (From.isVLATypeCapture())
2074 return false;
2075
2076 // FIXME: maybe we should warn on these if we can find a sensible diagnostic
2077 // message
2078 if (From.isInitCapture() &&
2079 From.getVariable()->isPlaceholderVar(LangOpts: getLangOpts()))
2080 return false;
2081
2082 auto diag = Diag(Loc: From.getLocation(), DiagID: diag::warn_unused_lambda_capture);
2083 if (From.isThisCapture())
2084 diag << "'this'";
2085 else
2086 diag << From.getVariable();
2087 diag << From.isNonODRUsed();
2088 // If we were able to resolve the fixit range we'll create a fixit,
2089 // otherwise we just use the raw capture range for the diagnostic.
2090 if (FixItRange.isValid())
2091 diag << FixItHint::CreateRemoval(RemoveRange: FixItRange);
2092 else
2093 diag << CaptureRange;
2094 return true;
2095}
2096
2097/// Create a field within the lambda class or captured statement record for the
2098/// given capture.
2099FieldDecl *Sema::BuildCaptureField(RecordDecl *RD,
2100 const sema::Capture &Capture) {
2101 SourceLocation Loc = Capture.getLocation();
2102 QualType FieldType = Capture.getCaptureType();
2103
2104 TypeSourceInfo *TSI = nullptr;
2105 if (Capture.isVariableCapture()) {
2106 const auto *Var = dyn_cast_or_null<VarDecl>(Val: Capture.getVariable());
2107 if (Var && Var->isInitCapture())
2108 TSI = Var->getTypeSourceInfo();
2109 }
2110
2111 // FIXME: Should we really be doing this? A null TypeSourceInfo seems more
2112 // appropriate, at least for an implicit capture.
2113 if (!TSI)
2114 TSI = Context.getTrivialTypeSourceInfo(T: FieldType, Loc);
2115
2116 // Build the non-static data member.
2117 FieldDecl *Field =
2118 FieldDecl::Create(C: Context, DC: RD, /*StartLoc=*/Loc, /*IdLoc=*/Loc,
2119 /*Id=*/nullptr, T: FieldType, TInfo: TSI, /*BW=*/nullptr,
2120 /*Mutable=*/false, InitStyle: ICIS_NoInit);
2121 // If the variable being captured has an invalid type, mark the class as
2122 // invalid as well.
2123 if (!FieldType->isDependentType()) {
2124 if (RequireCompleteSizedType(Loc, T: FieldType,
2125 DiagID: diag::err_field_incomplete_or_sizeless)) {
2126 RD->setInvalidDecl();
2127 Field->setInvalidDecl();
2128 } else {
2129 NamedDecl *Def;
2130 FieldType->isIncompleteType(Def: &Def);
2131 if (Def && Def->isInvalidDecl()) {
2132 RD->setInvalidDecl();
2133 Field->setInvalidDecl();
2134 }
2135 }
2136 }
2137 Field->setImplicit(true);
2138 Field->setAccess(AS_private);
2139 RD->addDecl(D: Field);
2140
2141 if (Capture.isVLATypeCapture())
2142 Field->setCapturedVLAType(Capture.getCapturedVLAType());
2143
2144 return Field;
2145}
2146
2147static SourceRange
2148ConstructFixItRangeForUnusedCapture(Sema &S, SourceRange CaptureRange,
2149 SourceLocation PrevCaptureLoc,
2150 bool CurHasPreviousCapture, bool IsLast) {
2151 if (!CaptureRange.isValid())
2152 return SourceRange();
2153
2154 auto GetTrailingEndLocation = [&](SourceLocation StartPoint) {
2155 SourceRange NextToken = S.getRangeForNextToken(
2156 Loc: StartPoint, /*IncludeMacros=*/false, /*IncludeComments=*/true);
2157 if (!NextToken.isValid())
2158 return SourceLocation();
2159 // Return the last location preceding the next token
2160 return NextToken.getBegin().getLocWithOffset(Offset: -1);
2161 };
2162
2163 if (!CurHasPreviousCapture && !IsLast) {
2164 // If there are no captures preceding this capture, remove the
2165 // trailing comma and anything up to the next token
2166 SourceRange CommaRange =
2167 S.getRangeForNextToken(Loc: CaptureRange.getEnd(), /*IncludeMacros=*/false,
2168 /*IncludeComments=*/false, ExpectedToken: tok::comma);
2169 SourceLocation FixItEnd = GetTrailingEndLocation(CommaRange.getBegin());
2170 return SourceRange(CaptureRange.getBegin(), FixItEnd);
2171 }
2172
2173 // Otherwise, remove the comma since the last used capture, and
2174 // anything up to the next token
2175 SourceLocation FixItStart = S.getLocForEndOfToken(Loc: PrevCaptureLoc);
2176 SourceLocation FixItEnd = GetTrailingEndLocation(CaptureRange.getEnd());
2177 return SourceRange(FixItStart, FixItEnd);
2178}
2179
2180ExprResult Sema::BuildLambdaExpr(SourceLocation StartLoc,
2181 SourceLocation EndLoc) {
2182 LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(Val: FunctionScopes.back());
2183 // Collect information from the lambda scope.
2184 SmallVector<LambdaCapture, 4> Captures;
2185 SmallVector<Expr *, 4> CaptureInits;
2186 SourceLocation CaptureDefaultLoc = LSI->CaptureDefaultLoc;
2187 LambdaCaptureDefault CaptureDefault =
2188 mapImplicitCaptureStyle(ICS: LSI->ImpCaptureStyle);
2189 CXXRecordDecl *Class = LSI->Lambda;
2190 CXXMethodDecl *CallOperator = LSI->CallOperator;
2191 SourceRange IntroducerRange = LSI->IntroducerRange;
2192 bool ExplicitParams = LSI->ExplicitParams;
2193 bool ExplicitResultType = !LSI->HasImplicitReturnType;
2194 CleanupInfo LambdaCleanup = LSI->Cleanup;
2195 bool ContainsUnexpandedParameterPack = LSI->ContainsUnexpandedParameterPack;
2196 bool IsGenericLambda = Class->isGenericLambda();
2197
2198 CallOperator->setLexicalDeclContext(Class);
2199 Decl *TemplateOrNonTemplateCallOperatorDecl =
2200 CallOperator->getDescribedFunctionTemplate()
2201 ? CallOperator->getDescribedFunctionTemplate()
2202 : cast<Decl>(Val: CallOperator);
2203
2204 // FIXME: Is this really the best choice? Keeping the lexical decl context
2205 // set as CurContext seems more faithful to the source.
2206 TemplateOrNonTemplateCallOperatorDecl->setLexicalDeclContext(Class);
2207
2208 {
2209 // TreeTransform of immediate functions may call getCurLambda, which
2210 // requires both the paired LSI and the lambda DeclContext.
2211 ContextRAII SavedContext(*this, CallOperator, /*NewThisContext=*/false);
2212 PopExpressionEvaluationContext();
2213 }
2214
2215 sema::AnalysisBasedWarnings::Policy WP =
2216 AnalysisWarnings.getPolicyInEffectAt(Loc: EndLoc);
2217 // We cannot release LSI until we finish computing captures, which
2218 // requires the scope to be popped.
2219 Sema::PoppedFunctionScopePtr _ = PopFunctionScopeInfo(WP: &WP, D: LSI->CallOperator);
2220
2221 // True if the current capture has a used capture or default before it.
2222 bool CurHasPreviousCapture = CaptureDefault != LCD_None;
2223 SourceLocation PrevCaptureLoc =
2224 CurHasPreviousCapture ? CaptureDefaultLoc : IntroducerRange.getBegin();
2225
2226 for (unsigned I = 0, N = LSI->Captures.size(); I != N; ++I) {
2227 const Capture &From = LSI->Captures[I];
2228
2229 if (From.isInvalid())
2230 return ExprError();
2231
2232 assert(!From.isBlockCapture() && "Cannot capture __block variables");
2233 bool IsImplicit = I >= LSI->NumExplicitCaptures;
2234 SourceLocation ImplicitCaptureLoc =
2235 IsImplicit ? CaptureDefaultLoc : SourceLocation();
2236
2237 // Use source ranges of explicit captures for fixits where available.
2238 SourceRange CaptureRange = LSI->ExplicitCaptureRanges[I];
2239
2240 // Warn about unused explicit captures.
2241 bool IsCaptureUsed = true;
2242 if (!CurContext->isDependentContext() && !IsImplicit && !From.isODRUsed()) {
2243 // Initialized captures that are non-ODR used may not be eliminated.
2244 // FIXME: Where did the IsGenericLambda here come from?
2245 bool NonODRUsedInitCapture =
2246 IsGenericLambda && From.isNonODRUsed() && From.isInitCapture();
2247 if (!NonODRUsedInitCapture) {
2248 bool IsLast = (I + 1) == LSI->NumExplicitCaptures;
2249 SourceRange FixItRange = ConstructFixItRangeForUnusedCapture(
2250 S&: *this, CaptureRange, PrevCaptureLoc, CurHasPreviousCapture, IsLast);
2251 IsCaptureUsed =
2252 !DiagnoseUnusedLambdaCapture(CaptureRange, FixItRange, From);
2253 }
2254 }
2255
2256 if (CaptureRange.isValid()) {
2257 CurHasPreviousCapture |= IsCaptureUsed;
2258 PrevCaptureLoc = CaptureRange.getEnd();
2259 }
2260
2261 // Map the capture to our AST representation.
2262 LambdaCapture Capture = [&] {
2263 if (From.isThisCapture()) {
2264 // Capturing 'this' implicitly with a default of '[=]' is deprecated,
2265 // because it results in a reference capture. Don't warn prior to
2266 // C++2a; there's nothing that can be done about it before then.
2267 if (getLangOpts().CPlusPlus20 && IsImplicit &&
2268 CaptureDefault == LCD_ByCopy) {
2269 Diag(Loc: From.getLocation(), DiagID: diag::warn_deprecated_this_capture);
2270 Diag(Loc: CaptureDefaultLoc, DiagID: diag::note_deprecated_this_capture)
2271 << FixItHint::CreateInsertion(
2272 InsertionLoc: getLocForEndOfToken(Loc: CaptureDefaultLoc), Code: ", this");
2273 }
2274 return LambdaCapture(From.getLocation(), IsImplicit,
2275 From.isCopyCapture() ? LCK_StarThis : LCK_This);
2276 } else if (From.isVLATypeCapture()) {
2277 return LambdaCapture(From.getLocation(), IsImplicit, LCK_VLAType);
2278 } else {
2279 assert(From.isVariableCapture() && "unknown kind of capture");
2280 ValueDecl *Var = From.getVariable();
2281 LambdaCaptureKind Kind = From.isCopyCapture() ? LCK_ByCopy : LCK_ByRef;
2282 return LambdaCapture(From.getLocation(), IsImplicit, Kind, Var,
2283 From.getEllipsisLoc());
2284 }
2285 }();
2286
2287 // Form the initializer for the capture field.
2288 ExprResult Init = BuildCaptureInit(Cap: From, ImplicitCaptureLoc);
2289
2290 // FIXME: Skip this capture if the capture is not used, the initializer
2291 // has no side-effects, the type of the capture is trivial, and the
2292 // lambda is not externally visible.
2293
2294 // Add a FieldDecl for the capture and form its initializer.
2295 BuildCaptureField(RD: Class, Capture: From);
2296 Captures.push_back(Elt: Capture);
2297 CaptureInits.push_back(Elt: Init.get());
2298
2299 if (LangOpts.CUDA)
2300 CUDA().CheckLambdaCapture(D: CallOperator, Capture: From);
2301 }
2302
2303 Class->setCaptures(Context, Captures);
2304
2305 // C++11 [expr.prim.lambda]p6:
2306 // The closure type for a lambda-expression with no lambda-capture
2307 // has a public non-virtual non-explicit const conversion function
2308 // to pointer to function having the same parameter and return
2309 // types as the closure type's function call operator.
2310 if (Captures.empty() && CaptureDefault == LCD_None)
2311 addFunctionPointerConversions(S&: *this, IntroducerRange, Class, CallOperator);
2312
2313 // Objective-C++:
2314 // The closure type for a lambda-expression has a public non-virtual
2315 // non-explicit const conversion function to a block pointer having the
2316 // same parameter and return types as the closure type's function call
2317 // operator.
2318 // FIXME: Fix generic lambda to block conversions.
2319 if (getLangOpts().Blocks && getLangOpts().ObjC && !IsGenericLambda)
2320 addBlockPointerConversion(S&: *this, IntroducerRange, Class, CallOperator);
2321
2322 // Finalize the lambda class.
2323 SmallVector<Decl *, 4> Fields(Class->fields());
2324 ActOnFields(S: nullptr, RecLoc: Class->getLocation(), TagDecl: Class, Fields, LBrac: SourceLocation(),
2325 RBrac: SourceLocation(), AttrList: ParsedAttributesView());
2326 CheckCompletedCXXClass(S: nullptr, Record: Class);
2327
2328 Cleanup.mergeFrom(Rhs: LambdaCleanup);
2329
2330 LambdaExpr *Lambda =
2331 LambdaExpr::Create(C: Context, Class, IntroducerRange, CaptureDefault,
2332 CaptureDefaultLoc, ExplicitParams, ExplicitResultType,
2333 CaptureInits, ClosingBrace: EndLoc, ContainsUnexpandedParameterPack);
2334
2335 // If the lambda expression's call operator is not explicitly marked constexpr
2336 // and is not dependent, analyze the call operator to infer
2337 // its constexpr-ness, suppressing diagnostics while doing so.
2338 if (getLangOpts().CPlusPlus17 && !CallOperator->isInvalidDecl() &&
2339 !CallOperator->isConstexpr() &&
2340 !isa<CoroutineBodyStmt>(Val: CallOperator->getBody()) &&
2341 !Class->isDependentContext()) {
2342 CallOperator->setConstexprKind(
2343 CheckConstexprFunctionDefinition(FD: CallOperator,
2344 Kind: CheckConstexprKind::CheckValid)
2345 ? ConstexprSpecKind::Constexpr
2346 : ConstexprSpecKind::Unspecified);
2347 }
2348
2349 // Emit delayed shadowing warnings now that the full capture list is known.
2350 DiagnoseShadowingLambdaDecls(LSI);
2351
2352 if (!CurContext->isDependentContext()) {
2353 switch (ExprEvalContexts.back().Context) {
2354 // C++11 [expr.prim.lambda]p2:
2355 // A lambda-expression shall not appear in an unevaluated operand
2356 // (Clause 5).
2357 case ExpressionEvaluationContext::Unevaluated:
2358 case ExpressionEvaluationContext::UnevaluatedList:
2359 case ExpressionEvaluationContext::UnevaluatedAbstract:
2360 // C++1y [expr.const]p2:
2361 // A conditional-expression e is a core constant expression unless the
2362 // evaluation of e, following the rules of the abstract machine, would
2363 // evaluate [...] a lambda-expression.
2364 //
2365 // This is technically incorrect, there are some constant evaluated contexts
2366 // where this should be allowed. We should probably fix this when DR1607 is
2367 // ratified, it lays out the exact set of conditions where we shouldn't
2368 // allow a lambda-expression.
2369 case ExpressionEvaluationContext::ConstantEvaluated:
2370 case ExpressionEvaluationContext::ImmediateFunctionContext:
2371 // We don't actually diagnose this case immediately, because we
2372 // could be within a context where we might find out later that
2373 // the expression is potentially evaluated (e.g., for typeid).
2374 ExprEvalContexts.back().Lambdas.push_back(Elt: Lambda);
2375 break;
2376
2377 case ExpressionEvaluationContext::DiscardedStatement:
2378 case ExpressionEvaluationContext::PotentiallyEvaluated:
2379 case ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
2380 break;
2381 }
2382 maybeAddDeclWithEffects(D: LSI->CallOperator);
2383 }
2384
2385 return MaybeBindToTemporary(E: Lambda);
2386}
2387
2388ExprResult Sema::BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
2389 SourceLocation ConvLocation,
2390 CXXConversionDecl *Conv,
2391 Expr *Src) {
2392 // Make sure that the lambda call operator is marked used.
2393 CXXRecordDecl *Lambda = Conv->getParent();
2394 CXXMethodDecl *CallOperator
2395 = cast<CXXMethodDecl>(
2396 Val: Lambda->lookup(
2397 Name: Context.DeclarationNames.getCXXOperatorName(Op: OO_Call)).front());
2398 CallOperator->setReferenced();
2399 CallOperator->markUsed(C&: Context);
2400
2401 ExprResult Init = PerformCopyInitialization(
2402 Entity: InitializedEntity::InitializeLambdaToBlock(BlockVarLoc: ConvLocation, Type: Src->getType()),
2403 EqualLoc: CurrentLocation, Init: Src);
2404 if (!Init.isInvalid())
2405 Init = ActOnFinishFullExpr(Expr: Init.get(), /*DiscardedValue*/ false);
2406
2407 if (Init.isInvalid())
2408 return ExprError();
2409
2410 // Create the new block to be returned.
2411 BlockDecl *Block = BlockDecl::Create(C&: Context, DC: CurContext, L: ConvLocation);
2412
2413 // Set the type information.
2414 Block->setSignatureAsWritten(CallOperator->getTypeSourceInfo());
2415 Block->setIsVariadic(CallOperator->isVariadic());
2416 Block->setBlockMissingReturnType(false);
2417
2418 // Add parameters.
2419 SmallVector<ParmVarDecl *, 4> BlockParams;
2420 for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) {
2421 ParmVarDecl *From = CallOperator->getParamDecl(i: I);
2422 BlockParams.push_back(Elt: ParmVarDecl::Create(
2423 C&: Context, DC: Block, StartLoc: From->getBeginLoc(), IdLoc: From->getLocation(),
2424 Id: From->getIdentifier(), T: From->getType(), TInfo: From->getTypeSourceInfo(),
2425 S: From->getStorageClass(),
2426 /*DefArg=*/nullptr));
2427 }
2428 Block->setParams(BlockParams);
2429
2430 Block->setIsConversionFromLambda(true);
2431
2432 // Add capture. The capture uses a fake variable, which doesn't correspond
2433 // to any actual memory location. However, the initializer copy-initializes
2434 // the lambda object.
2435 TypeSourceInfo *CapVarTSI =
2436 Context.getTrivialTypeSourceInfo(T: Src->getType());
2437 VarDecl *CapVar = VarDecl::Create(C&: Context, DC: Block, StartLoc: ConvLocation,
2438 IdLoc: ConvLocation, Id: nullptr,
2439 T: Src->getType(), TInfo: CapVarTSI,
2440 S: SC_None);
2441 BlockDecl::Capture Capture(/*variable=*/CapVar, /*byRef=*/false,
2442 /*nested=*/false, /*copy=*/Init.get());
2443 Block->setCaptures(Context, Captures: Capture, /*CapturesCXXThis=*/false);
2444
2445 // Add a fake function body to the block. IR generation is responsible
2446 // for filling in the actual body, which cannot be expressed as an AST.
2447 Block->setBody(new (Context) CompoundStmt(ConvLocation));
2448
2449 // Create the block literal expression.
2450 // TODO: Do we ever get here if we have unexpanded packs in the lambda???
2451 Expr *BuildBlock =
2452 new (Context) BlockExpr(Block, Conv->getConversionType(),
2453 /*ContainsUnexpandedParameterPack=*/false);
2454 ExprCleanupObjects.push_back(Elt: Block);
2455 Cleanup.setExprNeedsCleanups(true);
2456
2457 return BuildBlock;
2458}
2459
2460static FunctionDecl *getPatternFunctionDecl(FunctionDecl *FD) {
2461 if (FD->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization) {
2462 while (FD->getInstantiatedFromMemberFunction())
2463 FD = FD->getInstantiatedFromMemberFunction();
2464 return FD;
2465 }
2466
2467 if (FD->getTemplatedKind() == FunctionDecl::TK_DependentNonTemplate)
2468 return FD->getInstantiatedFromDecl();
2469
2470 FunctionTemplateDecl *FTD = FD->getPrimaryTemplate();
2471 if (!FTD)
2472 return nullptr;
2473
2474 while (FTD->getInstantiatedFromMemberTemplate())
2475 FTD = FTD->getInstantiatedFromMemberTemplate();
2476
2477 return FTD->getTemplatedDecl();
2478}
2479
2480bool Sema::addInstantiatedCapturesToScope(
2481 FunctionDecl *Function, const FunctionDecl *PatternDecl,
2482 LocalInstantiationScope &Scope,
2483 const MultiLevelTemplateArgumentList &TemplateArgs) {
2484 const auto *LambdaClass = cast<CXXMethodDecl>(Val: Function)->getParent();
2485 const auto *LambdaPattern = cast<CXXMethodDecl>(Val: PatternDecl)->getParent();
2486
2487 unsigned Instantiated = 0;
2488
2489 // FIXME: This is a workaround for not having deferred lambda body
2490 // instantiation.
2491 // When transforming a lambda's body, if we encounter another call to a
2492 // nested lambda that contains a constraint expression, we add all of the
2493 // outer lambda's instantiated captures to the current instantiation scope to
2494 // facilitate constraint evaluation. However, these captures don't appear in
2495 // the CXXRecordDecl until after the lambda expression is rebuilt, so we
2496 // pull them out from the corresponding LSI.
2497 LambdaScopeInfo *InstantiatingScope = nullptr;
2498 if (LambdaPattern->capture_size() && !LambdaClass->capture_size()) {
2499 for (FunctionScopeInfo *Scope : llvm::reverse(C&: FunctionScopes)) {
2500 auto *LSI = dyn_cast<LambdaScopeInfo>(Val: Scope);
2501 if (!LSI || getPatternFunctionDecl(FD: LSI->CallOperator) != PatternDecl)
2502 continue;
2503 InstantiatingScope = LSI;
2504 break;
2505 }
2506 assert(InstantiatingScope);
2507 }
2508
2509 auto AddSingleCapture = [&](const ValueDecl *CapturedPattern,
2510 unsigned Index) {
2511 ValueDecl *CapturedVar =
2512 InstantiatingScope ? InstantiatingScope->Captures[Index].getVariable()
2513 : LambdaClass->getCapture(I: Index)->getCapturedVar();
2514 assert(CapturedVar->isInitCapture());
2515 Scope.InstantiatedLocal(D: CapturedPattern, Inst: CapturedVar);
2516 };
2517
2518 for (const LambdaCapture &CapturePattern : LambdaPattern->captures()) {
2519 if (!CapturePattern.capturesVariable()) {
2520 Instantiated++;
2521 continue;
2522 }
2523 ValueDecl *CapturedPattern = CapturePattern.getCapturedVar();
2524
2525 if (!CapturedPattern->isInitCapture()) {
2526 Instantiated++;
2527 continue;
2528 }
2529
2530 if (!CapturedPattern->isParameterPack()) {
2531 AddSingleCapture(CapturedPattern, Instantiated++);
2532 } else {
2533 Scope.MakeInstantiatedLocalArgPack(D: CapturedPattern);
2534 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2535 SemaRef.collectUnexpandedParameterPacks(
2536 E: dyn_cast<VarDecl>(Val: CapturedPattern)->getInit(), Unexpanded);
2537 auto NumArgumentsInExpansion =
2538 getNumArgumentsInExpansionFromUnexpanded(Unexpanded, TemplateArgs);
2539 if (!NumArgumentsInExpansion)
2540 continue;
2541 for (unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg)
2542 AddSingleCapture(CapturedPattern, Instantiated++);
2543 }
2544 }
2545 return false;
2546}
2547
2548Sema::LambdaScopeForCallOperatorInstantiationRAII::
2549 LambdaScopeForCallOperatorInstantiationRAII(
2550 Sema &SemaRef, FunctionDecl *FD, MultiLevelTemplateArgumentList MLTAL,
2551 LocalInstantiationScope &Scope, bool ShouldAddDeclsFromParentScope)
2552 : FunctionScopeRAII(SemaRef) {
2553 if (!isLambdaCallOperator(DC: FD)) {
2554 FunctionScopeRAII::disable();
2555 return;
2556 }
2557
2558 SemaRef.RebuildLambdaScopeInfo(CallOperator: cast<CXXMethodDecl>(Val: FD));
2559
2560 FunctionDecl *FDPattern = getPatternFunctionDecl(FD);
2561 if (!FDPattern)
2562 return;
2563
2564 if (!ShouldAddDeclsFromParentScope)
2565 return;
2566
2567 llvm::SmallVector<std::pair<FunctionDecl *, FunctionDecl *>, 4>
2568 InstantiationAndPatterns;
2569 while (FDPattern && FD) {
2570 InstantiationAndPatterns.emplace_back(Args&: FDPattern, Args&: FD);
2571
2572 FDPattern = dyn_cast<FunctionDecl>(
2573 Val: getLambdaAwareParentOfDeclContext(DC: FDPattern)
2574 ->getEnclosingNonExpansionStatementContext());
2575 FD = dyn_cast<FunctionDecl>(
2576 Val: getLambdaAwareParentOfDeclContext(DC: FD)
2577 ->getEnclosingNonExpansionStatementContext());
2578 }
2579
2580 // Add instantiated parameters and local vars to scopes, starting from the
2581 // outermost lambda to the innermost lambda. This ordering ensures that
2582 // the outer instantiations can be found when referenced from within inner
2583 // lambdas.
2584 //
2585 // auto L = [](auto... x) {
2586 // return [](decltype(x)... y) { }; // Instantiating y needs x
2587 // };
2588 //
2589
2590 for (auto [FDPattern, FD] : llvm::reverse(C&: InstantiationAndPatterns)) {
2591 SemaRef.addInstantiatedParametersToScope(Function: FD, PatternDecl: FDPattern, Scope, TemplateArgs: MLTAL);
2592 SemaRef.addInstantiatedLocalVarsToScope(Function: FD, PatternDecl: FDPattern, Scope);
2593
2594 if (isLambdaCallOperator(DC: FD))
2595 SemaRef.addInstantiatedCapturesToScope(Function: FD, PatternDecl: FDPattern, Scope, TemplateArgs: MLTAL);
2596 }
2597}
2598