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