23#include "llvm/ADT/STLExtras.h"
63static inline std::optional<unsigned>
68 const std::optional<unsigned> NoLambdaIsCaptureReady;
71 unsigned CurScopeIndex = FunctionScopes.size() - 1;
72 while (CurScopeIndex > 0 && isa<clang::sema::CapturedRegionScopeInfo>(
73 FunctionScopes[CurScopeIndex]))
76 isa<clang::sema::LambdaScopeInfo>(FunctionScopes[CurScopeIndex]) &&
77 "The function on the top of sema's function-info stack must be a lambda");
80 const bool IsCapturingThis = !VarToCapture;
81 const bool IsCapturingVariable = !IsCapturingThis;
85 cast<sema::LambdaScopeInfo>(FunctionScopes[CurScopeIndex])->CallOperator;
89 cast<sema::LambdaScopeInfo>(FunctionScopes[CurScopeIndex]);
97 if (IsCapturingVariable &&
99 return NoLambdaIsCaptureReady;
118 if (IsCapturingVariable && !LSI->
isCaptured(VarToCapture))
119 return NoLambdaIsCaptureReady;
121 return NoLambdaIsCaptureReady;
125 assert(CurScopeIndex);
131 assert(CurScopeIndex < (FunctionScopes.size() - 1));
135 return CurScopeIndex + 1;
136 return NoLambdaIsCaptureReady;
174std::optional<unsigned>
179 const std::optional<unsigned> NoLambdaIsCaptureCapable;
181 const std::optional<unsigned> OptionalStackIndex =
184 if (!OptionalStackIndex)
185 return NoLambdaIsCaptureCapable;
187 const unsigned IndexOfCaptureReadyLambda = *OptionalStackIndex;
188 assert(((IndexOfCaptureReadyLambda != (FunctionScopes.size() - 1)) ||
190 "The capture ready lambda for a potential capture can only be the "
191 "current lambda if it is a generic lambda");
194 cast<sema::LambdaScopeInfo>(FunctionScopes[IndexOfCaptureReadyLambda]);
197 const bool IsCapturingThis = !VarToCapture;
198 const bool IsCapturingVariable = !IsCapturingThis;
200 if (IsCapturingVariable) {
205 const bool CanCaptureVariable =
211 DeclRefType, &IndexOfCaptureReadyLambda);
212 if (!CanCaptureVariable)
213 return NoLambdaIsCaptureCapable;
218 const bool CanCaptureThis =
222 &IndexOfCaptureReadyLambda);
224 return NoLambdaIsCaptureCapable;
226 return IndexOfCaptureReadyLambda;
245 unsigned LambdaDependencyKind,
251 bool IsGenericLambda =
256 IsGenericLambda, CaptureDefault);
266 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(DC))
276std::tuple<MangleNumberingContext *, Decl *>
295 if (ManglingContextDecl) {
296 if (
ParmVarDecl *Param = dyn_cast<ParmVarDecl>(ManglingContextDecl)) {
299 if (LexicalDC->isRecord())
301 }
else if (
VarDecl *Var = dyn_cast<VarDecl>(ManglingContextDecl)) {
302 if (Var->getDeclContext()->isRecord())
303 Kind = StaticDataMember;
304 else if (Var->getMostRecentDecl()->isInline())
305 Kind = InlineVariable;
306 else if (Var->getDescribedVarTemplate())
307 Kind = VariableTemplate;
308 else if (
auto *VTS = dyn_cast<VarTemplateSpecializationDecl>(Var)) {
309 if (!VTS->isExplicitSpecialization())
310 Kind = VariableTemplate;
312 }
else if (isa<FieldDecl>(ManglingContextDecl)) {
314 }
else if (isa<ImplicitConceptSpecializationDecl>(ManglingContextDecl)) {
322 bool IsInNonspecializedTemplate =
328 if ((IsInNonspecializedTemplate &&
329 !(ManglingContextDecl && isa<ParmVarDecl>(ManglingContextDecl))) ||
331 while (
auto *CD = dyn_cast<CapturedDecl>(DC))
336 return std::make_tuple(
nullptr,
nullptr);
344 case StaticDataMember:
346 if (!IsInNonspecializedTemplate)
347 return std::make_tuple(
nullptr, ManglingContextDecl);
357 case VariableTemplate:
359 return std::make_tuple(
361 ManglingContextDecl),
362 ManglingContextDecl);
365 llvm_unreachable(
"unexpected context");
372 assert(MethodTypeInfo &&
"expected a non null type");
378 if (Class->isDependentContext() || TemplateParams) {
381 if (
Result->isUndeducedType()) {
392 std::optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling) {
394 ContextRAII ManglingContext(*
this, Class->getDeclContext());
397 bool HasKnownInternalLinkage;
398 unsigned ManglingNumber, DeviceManglingNumber;
399 Decl *ManglingContextDecl;
400 std::tie(HasKnownInternalLinkage, ManglingNumber, DeviceManglingNumber,
401 ManglingContextDecl) = *Mangling;
402 Class->setLambdaMangling(ManglingNumber, ManglingContextDecl,
403 HasKnownInternalLinkage);
404 Class->setDeviceLambdaManglingNumber(DeviceManglingNumber);
408 auto getMangleNumberingContext =
412 if (ManglingContextDecl)
416 auto DC = Class->getDeclContext();
417 while (
auto *CD = dyn_cast<CapturedDecl>(DC))
418 DC = CD->getParent();
423 Decl *ManglingContextDecl;
424 std::tie(MCtx, ManglingContextDecl) =
426 bool HasKnownInternalLinkage =
false;
436 MCtx = getMangleNumberingContext(Class, ManglingContextDecl);
437 assert(MCtx &&
"Retrieving mangle numbering context failed!");
438 HasKnownInternalLinkage =
true;
442 Class->setLambdaMangling(ManglingNumber, ManglingContextDecl,
443 HasKnownInternalLinkage);
450 bool ExplicitResultType) {
451 if (ExplicitResultType) {
456 diag::err_lambda_incomplete_result);
466 bool ExplicitParams,
bool Mutable) {
469 LSI->
Lambda = LambdaClass;
489 assert(LSI &&
"Expected a lambda scope");
491 "Already acted on explicit template parameters");
493 "Explicit template parameters should come "
494 "before invented (auto) ones");
495 assert(!TParams.empty() &&
496 "No template parameters to act on");
518 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
519 return cast<EnumDecl>(D->getDeclContext());
527 if (BO->getOpcode() == BO_Comma)
534 if (
StmtExpr *SE = dyn_cast<StmtExpr>(E)) {
535 if (
Expr *last = dyn_cast_or_null<Expr>(SE->getSubStmt()->body_back()))
556 if (ICE->getCastKind() == CK_IntegralCast)
564 return ET->getDecl();
587 if (!ED)
return nullptr;
590 for (++i; i != e; ++i) {
606 i = returns.begin(), e = returns.end(); i != e; ++i) {
635 "lambda expressions use auto deduction in C++14 onwards");
672 assert(!CSI.
ReturnType.
isNull() &&
"We should have a tentative return type.");
678 assert(isa<BlockScopeInfo>(CSI));
707 if (BlockNullability &&
708 (!RetTyNullability ||
717 diag::err_typecheck_missing_return_type_incompatible)
718 << ReturnType << CSI.
ReturnType << isa<LambdaScopeInfo>(CSI);
726 bool IsDirectInit,
Expr *&Init) {
735 assert(!DeductType.
isNull() &&
"can't build reference to auto");
739 if (Init->containsUnexpandedParameterPack()) {
741 ? diag::warn_cxx17_compat_init_capture_pack
742 : diag::ext_init_capture_pack);
761 ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init);
770 Loc, Init->getBeginLoc(), Init->getEndLoc())
796 PETL.setEllipsisLoc(EllipsisLoc);
803 InitCaptureType, TSI,
SC_Auto);
816 bool isReferenceType) {
817 assert(Var->
isInitCapture() &&
"init capture flag should be set");
860 bool &ExplicitResultType) {
862 ExplicitResultType =
false;
868 "Unexpected storage specifier");
869 bool IsLambdaStatic =
890 diag::err_return_value_with_address_space);
895 assert(MethodTyInfo &&
"no type from lambda-declarator");
935 bool HasExplicitResultType) {
939 if (TrailingRequiresClause)
947 if (TemplateParams) {
950 TemplateParams, Method);
966 TemplateParams, MethodTyInfo));
969 if (!Params.empty()) {
975 P->setOwningFunction(Method);
983 Scope *CurrentScope) {
986 assert(LSI &&
"LambdaScopeInfo should be on stack!");
1004 assert(TemplateParamScope &&
1005 "Lambda with explicit template param list should establish a "
1006 "template param scope");
1007 assert(TemplateParamScope->
getParent());
1015 Intro.
Range,
nullptr, LambdaDependencyKind, Intro.
Default);
1024 bool ContainsUnexpandedParameterPack =
false;
1027 llvm::DenseMap<IdentifierInfo *, ValueDecl *> CaptureNames;
1033 PrevCaptureLoc =
C->Loc, ++
C) {
1037 ? diag::ext_star_this_lambda_capture_cxx17
1038 : diag::warn_cxx14_compat_star_this_lambda_capture);
1044 Diag(
C->Loc, diag::err_capture_more_than_once)
1058 ? diag::ext_equals_this_lambda_capture_cxx20
1059 : diag::warn_cxx17_compat_equals_this_lambda_capture);
1065 if (ThisCaptureType.
isNull()) {
1066 Diag(
C->Loc, diag::err_this_capture) <<
true;
1078 assert(
C->Id &&
"missing identifier for capture");
1080 if (
C->Init.isInvalid())
1084 if (
C->Init.isUsable()) {
1086 ? diag::warn_cxx11_compat_init_capture
1087 : diag::ext_init_capture);
1094 if (
C->InitCaptureType.get().isNull())
1097 if (
C->Init.get()->containsUnexpandedParameterPack() &&
1102 switch (
C->InitKind) {
1104 llvm_unreachable(
"not an init-capture?");
1116 C->EllipsisLoc,
C->Id, InitStyle,
1117 C->Init.get(), Method);
1118 assert(Var &&
"createLambdaInitCaptureVarDecl returned a null VarDecl?");
1119 if (
auto *
V = dyn_cast<VarDecl>(Var))
1124 "init capture has valid but null init?");
1132 Diag(
C->Loc, diag::err_reference_capture_with_reference_default)
1137 Diag(
C->Loc, diag::err_copy_capture_with_copy_default)
1172 Diag(
C->Loc, diag::err_capture_does_not_name_variable) <<
C->Id;
1179 if (
auto [It, Inserted] = CaptureNames.insert(std::pair{C->Id, Var});
1183 Diag(
C->Loc, diag::err_capture_more_than_once)
1184 <<
C->Id << It->second->getBeginLoc()
1190 Diag(
C->Loc, diag::err_capture_more_than_once) <<
C->Id;
1201 Diag(
C->Loc, diag::err_capture_non_automatic_variable) <<
C->Id;
1209 if (
C->EllipsisLoc.isValid()) {
1211 EllipsisLoc =
C->EllipsisLoc;
1213 Diag(
C->EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
1214 << (
C->Init.isUsable() ?
C->Init.get()->getSourceRange()
1220 ContainsUnexpandedParameterPack =
true;
1223 if (
C->Init.isUsable()) {
1271 auto *Param = cast<ParmVarDecl>(
P.Param);
1273 if (Param->getIdentifier())
1288 bool ExplicitResultType;
1313 Params.reserve(Params.size());
1314 for (
unsigned I = 0; I < FTI.NumParams; ++I) {
1315 auto *Param = cast<ParmVarDecl>(FTI.Params[I].Param);
1316 Param->setScopeInfo(0, Params.size());
1317 Params.push_back(Param);
1321 bool IsLambdaStatic =
1355 if (!
C.isVariableCapture())
1363 auto CheckRedefinition = [&](
ParmVarDecl *Param) {
1365 if (
Capture.Id == Param->getIdentifier()) {
1366 Diag(Param->getLocation(), diag::err_parameter_shadow_capture);
1367 Diag(
Capture.Loc, diag::note_var_explicitly_captured_here)
1376 if (!
P->getIdentifier())
1378 if (CheckRedefinition(
P))
1392 bool IsInstantiation) {
1400 if (!IsInstantiation)
1405 Class->setInvalidDecl();
1414template <
typename Func>
1438 DefaultFree, DefaultMember, CallOpCC};
1440 llvm::iterator_range<CallingConv *> Range(
1441 std::begin(Convs), std::unique(std::begin(Convs), std::end(Convs)));
1451 if (CallOpCC == DefaultMember && DefaultMember != DefaultFree) {
1473 if (CallOpCC == DefaultMember && DefaultMember != DefaultFree)
1486 "Lambda's call operator should not have a reference qualifier");
1499 auto HasPassObjectSizeAttr = [](
const ParmVarDecl *
P) {
1500 return P->hasAttr<PassObjectSizeAttr>();
1502 if (llvm::any_of(CallOperator->
parameters(), HasPassObjectSizeAttr))
1572 for (
unsigned I = 0, N = CallOperator->
getNumParams(); I != N; ++I) {
1582 CallOpConvTL.setParam(I, From);
1583 CallOpConvNameTL.setParam(I, From);
1597 if (Class->isGenericLambda()) {
1604 Loc, ConversionName,
1610 Class->addDecl(ConversionTemplate);
1612 Class->addDecl(Conversion);
1638 for (
unsigned I = 0, N = CallOperator->
getNumParams(); I != N; ++I)
1639 InvokerParams[I]->setOwningFunction(Invoke);
1643 if (Class->isGenericLambda()) {
1648 S.
Context, Class, Loc, InvokerName,
1653 Class->addDecl(StaticInvokerTemplate);
1655 Class->addDecl(Invoke);
1711 Class->addDecl(Conversion);
1716 bool IsOpenMPMapping) {
1723 return cast<VarDecl>(Cap.
getVariable())->getInit();
1763 if (IsOpenMPMapping)
1766 if (Init.isInvalid())
1769 Expr *InitExpr = Init.get();
1775 return InitSeq.
Perform(*
this, Entity, InitKind, InitExpr);
1796 llvm_unreachable(
"block capture in lambda");
1798 llvm_unreachable(
"Unknown implicit capture style");
1804 if (Init && Init->HasSideEffects(
Context))
1820 return !RD->isCompleteDefinition() || !RD->hasTrivialCopyConstructor() ||
1821 !RD->hasTrivialDestructor();
1834 auto diag =
Diag(From.
getLocation(), diag::warn_unused_lambda_capture);
1854 if (Var && Var->isInitCapture())
1855 TSI = Var->getTypeSourceInfo();
1866 nullptr, FieldType, TSI,
nullptr,
1872 diag::err_field_incomplete_or_sizeless)) {
1874 Field->setInvalidDecl();
1880 Field->setInvalidDecl();
1884 Field->setImplicit(
true);
1905 bool ExplicitParams;
1906 bool ExplicitResultType;
1908 bool ContainsUnexpandedParameterPack;
1909 bool IsGenericLambda;
1918 IsGenericLambda = Class->isGenericLambda();
1921 Decl *TemplateOrNonTemplateCallOperatorDecl =
1924 : cast<Decl>(CallOperator);
1933 bool CurHasPreviousCapture = CaptureDefault !=
LCD_None;
1935 CaptureDefaultLoc : IntroducerRange.
getBegin();
1937 for (
unsigned I = 0, N = LSI->
Captures.size(); I != N; ++I) {
1943 assert(!From.
isBlockCapture() &&
"Cannot capture __block variables");
1952 bool IsCaptureUsed =
true;
1957 bool NonODRUsedInitCapture =
1959 if (!NonODRUsedInitCapture) {
1963 if (!CurHasPreviousCapture && !IsLast) {
1980 CurHasPreviousCapture |= IsCaptureUsed;
1981 PrevCaptureLoc = CaptureRange.
getEnd();
1993 Diag(CaptureDefaultLoc, diag::note_deprecated_this_capture)
2021 CaptureInits.push_back(Init.get());
2027 Class->setCaptures(
Context, Captures);
2034 if (Captures.empty() && CaptureDefault ==
LCD_None)
2057 CaptureDefault, CaptureDefaultLoc,
2058 ExplicitParams, ExplicitResultType,
2059 CaptureInits, EndLoc,
2060 ContainsUnexpandedParameterPack);
2066 !isa<CoroutineBodyStmt>(CallOperator->
getBody()) &&
2067 !Class->getDeclContext()->isDependentContext()) {
2120 = cast<CXXMethodDecl>(
2128 CurrentLocation, Src);
2129 if (!Init.isInvalid())
2132 if (Init.isInvalid())
2141 Block->setBlockMissingReturnType(
false);
2145 for (
unsigned I = 0, N = CallOperator->
getNumParams(); I != N; ++I) {
2153 Block->setParams(BlockParams);
2155 Block->setIsConversionFromLambda(
true);
2163 ConvLocation,
nullptr,
This file provides some common utility functions for processing Lambda related AST Constructs.
Defines the clang::Expr interface and subclasses for C++ expressions.
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,...
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...
static TypeSourceInfo * getLambdaType(Sema &S, LambdaIntroducer &Intro, Declarator &ParamInfo, Scope *CurScope, SourceLocation Loc, bool &ExplicitResultType)
static std::optional< unsigned > getStackIndexOfNearestEnclosingCaptureReadyLambda(ArrayRef< const clang::sema::FunctionScopeInfo * > FunctionScopes, ValueDecl *VarToCapture)
Examines the FunctionScopeInfo stack to determine the nearest enclosing lambda (to the current lambda...
static LambdaScopeInfo * getCurrentLambdaScopeUnsafe(Sema &S)
static void adjustBlockReturnsToEnum(Sema &S, ArrayRef< ReturnStmt * > returns, QualType returnType)
Adjust the given return statements so that they formally return the given type.
static TemplateParameterList * getGenericLambdaTemplateParameterList(LambdaScopeInfo *LSI, Sema &SemaRef)
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)
static TypeSourceInfo * getDummyLambdaType(Sema &S, SourceLocation Loc=SourceLocation())
static QualType buildTypeForLambdaCallOperator(Sema &S, clang::CXXRecordDecl *Class, TemplateParameterList *TemplateParams, TypeSourceInfo *MethodTypeInfo)
static bool isInInlineFunction(const DeclContext *DC)
Determine whether the given context is or is enclosed in an inline function.
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.
tok::TokenKind ContextKind
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
TranslationUnitDecl * getTranslationUnitDecl() const
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
QualType getPackExpansionType(QualType Pattern, std::optional< unsigned > NumExpansions, bool ExpectPackInType=true)
Form a pack expansion type with the given pattern.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
MangleNumberingContext & getManglingNumberContext(const DeclContext *DC)
Retrieve the context for computing mangling numbers in the given DeclContext.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
const TargetInfo & getTargetInfo() const
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
Attr - This represents one attribute.
A builtin binary operation expression such as "x + y" or "x <= y".
A binding in a decomposition declaration.
A class which contains all the information about a particular captured value.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
static BlockDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Represents a C++ conversion function within a class.
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, Expr *TrailingRequiresClause=nullptr)
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Represents a static or instance method of a struct/union/class.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
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, Expr *TrailingRequiresClause=nullptr)
Represents a C++ struct/union/class.
void setLambdaTypeInfo(TypeSourceInfo *TS)
void setLambdaIsGeneric(bool IsGeneric)
static CXXRecordDecl * CreateLambda(const ASTContext &C, DeclContext *DC, TypeSourceInfo *Info, SourceLocation Loc, unsigned DependencyKind, bool IsGeneric, LambdaCaptureDefault CaptureDefault)
Represents a C++ nested-name-specifier or a global scope specifier.
void mergeFrom(CleanupInfo Rhs)
void setExprNeedsCleanups(bool SideEffects)
CompoundStmt - This represents a group of statements like { stmt stmt }.
ConditionalOperator - The ?: ternary operator.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
bool isFileContext() const
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
bool isTranslationUnit() const
void addDecl(Decl *D)
Add the declaration D into this context.
bool isFunctionOrMethod() const
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.
Captures information about "declaration specifiers".
SCS getStorageClassSpec() const
bool SetTypeQual(TQ T, SourceLocation Loc)
ConstexprSpecKind getConstexprSpecifier() const
Decl - This represents one declaration (or definition), e.g.
bool isParameterPack() const
Whether this declaration is a parameter pack.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
bool isInvalidDecl() const
void setAccess(AccessSpecifier AS)
SourceLocation getLocation() const
void setImplicit(bool I=true)
void setReferenced(bool R=true)
void setLocation(SourceLocation L)
DeclContext * getDeclContext()
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
void setLexicalDeclContext(DeclContext *DC)
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.
The name of a declaration.
void setInnerLocStart(SourceLocation L)
SourceLocation getBeginLoc() const LLVM_READONLY
void setTypeSourceInfo(TypeSourceInfo *TI)
void setTrailingRequiresClause(Expr *TrailingRequiresClause)
TypeSourceInfo * getTypeSourceInfo() const
Information about one declarator, including the parsed type information and the identifier.
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Expr * getTrailingRequiresClause()
Sets a trailing requires clause for this declarator.
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
An instance of this object exists for each enum constant that is defined.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
Store information needed for an explicit specifier.
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
This represents one expression.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
Represents difference between two FPOptions values.
bool isFPConstrained() const
Represents a member of a struct/union/class.
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
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.
void setSubExpr(Expr *E)
As with any mutator of the AST, be very careful when modifying an existing AST to preserve its invari...
const Expr * getSubExpr() const
Represents a function declaration or definition.
const ParmVarDecl * getParamDecl(unsigned i) const
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
ConstexprSpecKind getConstexprKind() const
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
bool isVariadic() const
Whether this function is variadic.
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
void setConstexprKind(ConstexprSpecKind CSK)
void setStorageClass(StorageClass SClass)
Sets the storage class as written in the source.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)
Represents a prototype with parameter type info, e.g.
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
Declaration of a template function.
static FunctionTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
TypeLoc getReturnLoc() const
ExtInfo withCallingConv(CallingConv cc) const
CallingConv getCallConv() const
QualType getReturnType() const
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 ...
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
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.
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.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
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.
Represents the results of name lookup.
DeclClass * getAsSingle() const
bool empty() const
Return true if no decls were found.
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...
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Represents a pack expansion of types.
unsigned getNumExprs() const
Return the number of expressions in this paren list.
Represents a parameter to a function.
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Wrapper for source info for pointers.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
LangAS getAddressSpace() const
Return the address space of this type.
The collection of all-type qualifiers we support.
void addAddressSpace(LangAS space)
Represents a struct/union/class.
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
void setRetValue(Expr *E)
SourceLocation getBeginLoc() const
Scope - A scope is a transient data structure that is used while parsing the program.
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Scope * getTemplateParamParent()
Sema - This implements semantic analysis and AST building for C.
Attr * getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD, bool IsDefinition)
Returns an implicit CodeSegAttr if a __declspec(code_seg) is found on a containing class.
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.
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr, bool IsAfterAmp=false)
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name, QualType Type, TypeSourceInfo *TSI, SourceRange Range, bool DirectInit, Expr *Init)
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...
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
ExprResult BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc, sema::LambdaScopeInfo *LSI)
Complete a lambda-expression having processed and attached the lambda body.
CXXRecordDecl * createLambdaClosureType(SourceRange IntroducerRange, TypeSourceInfo *Info, unsigned LambdaDependencyKind, LambdaCaptureDefault CaptureDefault)
Create a new lambda closure type.
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
void CUDACheckLambdaCapture(CXXMethodDecl *D, const sema::Capture &Capture)
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
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.
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,...
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...
FieldDecl * BuildCaptureField(RecordDecl *RD, const sema::Capture &Capture)
Build a FieldDecl suitable to hold the given capture.
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
ASTContext & getASTContext() const
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.
void PopExpressionEvaluationContext()
sema::LambdaScopeInfo * getCurGenericLambda()
Retrieve the current generic lambda info, if any.
void handleLambdaNumbering(CXXRecordDecl *Class, CXXMethodDecl *Method, std::optional< std::tuple< bool, unsigned, unsigned, Decl * > > Mangling=std::nullopt)
Number lambda for linkage purposes if necessary.
LangAS getDefaultCXXMethodAddrSpace() const
Returns default addr space for method qualifiers.
ExprResult BuildCaptureInit(const sema::Capture &Capture, SourceLocation ImplicitCaptureLoc, bool IsOpenMPMapping=false)
Initialize the given capture with a suitable expression.
FPOptions & getCurFPFeatures()
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
@ UPPC_Initializer
An initializer.
@ UPPC_DeclarationType
The type of an arbitrary declaration.
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.
const LangOptions & getLangOpts() const
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 CheckConstexprFunctionDefinition(const FunctionDecl *FD, CheckConstexprKind Kind)
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
const LangOptions & LangOpts
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
bool DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, CorrectionCandidateCallback &CCC, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr, ArrayRef< Expr * > Args=std::nullopt, TypoExpr **Out=nullptr)
Diagnose an empty lookup.
bool DiagnoseUnusedLambdaCapture(SourceRange CaptureRange, const sema::Capture &From)
Diagnose if an explicit lambda capture is unused.
QualType buildLambdaInitCaptureInitialization(SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc, std::optional< unsigned > NumExpansions, IdentifierInfo *Id, bool DirectInit, Expr *&Init)
void CheckCXXDefaultArguments(FunctionDecl *FD)
CheckCXXDefaultArguments - Verify that the default arguments for a function declaration are well-form...
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
void DiagnoseShadowingLambdaDecls(const sema::LambdaScopeInfo *LSI)
Diagnose shadowing for variables shadowed in the lambda record LambdaRD when these variables are capt...
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.
void addInitCapture(sema::LambdaScopeInfo *LSI, VarDecl *Var, bool isReferenceType)
Add an init-capture to a lambda scope.
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
void ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Decl *D)
Act on D, a function definition inside of an omp [begin/end] assumes.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
@ TryCapture_ExplicitByVal
@ TryCapture_ExplicitByRef
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...
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
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.
bool CheckParmsForFunctionDef(ArrayRef< ParmVarDecl * > Parameters, bool CheckParameterNames)
Helpers for dealing with blocks and functions.
void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R)
Diagnose variable or built-in function shadowing.
@ Normal
A normal translation unit fragment.
void CUDASetLambdaAttrs(CXXMethodDecl *Method)
Set device or host device attributes on the given lambda operator() method.
SmallVector< ExprWithCleanups::CleanupObject, 8 > ExprCleanupObjects
ExprCleanupObjects - This is the stack of objects requiring cleanup that are created by the current f...
@ 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...
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
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()
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
CXXMethodDecl * CreateLambdaCallOperator(SourceRange IntroducerRange, CXXRecordDecl *Class)
void deduceClosureReturnType(sema::CapturingScopeInfo &CSI)
Deduce a block or lambda's return type based on the return statements present in the body.
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
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)
bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID, const Ts &... Args)
std::tuple< MangleNumberingContext *, Decl * > getCurrentMangleNumberContext(const DeclContext *DC)
Compute the mangling number context for a lambda expression or block literal.
void CompleteLambdaCallOperator(CXXMethodDecl *Method, SourceLocation LambdaLoc, SourceLocation CallOperatorLoc, Expr *TrailingRequiresClause, TypeSourceInfo *MethodTyInfo, ConstexprSpecKind ConstexprKind, StorageClass SC, ArrayRef< ParmVarDecl * > Params, bool HasExplicitResultType)
TypeSourceInfo * GetTypeForDeclarator(Declarator &D, Scope *S)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
void finishLambdaExplicitCaptures(sema::LambdaScopeInfo *LSI)
Note that we have finished the explicit captures for the given lambda.
@ CheckValid
Identify whether this function satisfies the formal rules for constexpr functions in the current lanu...
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
ExprResult ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body, Scope *CurScope)
ActOnLambdaExpr - This is called when the body of a lambda expression was successfully completed.
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type?
Exposes information about the current target.
virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const
Determines whether a given calling convention is valid for the target.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Stores a list of template parameters for a TemplateDecl and its derived classes.
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.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
void setNameLoc(SourceLocation Loc)
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
const T * castAs() const
Member-template castAs<specific type>.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
const T * getAs() const
Member-template getAs<specific type>'.
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
VarDecl * getPotentiallyDecomposedVarDecl()
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Represents a variable declaration or definition.
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
void setInitStyle(InitializationStyle Style)
void setInitCapture(bool IC)
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
InitializationStyle
Initialization styles.
@ ListInit
Direct list-initialization (C++11)
@ CInit
C-style initialization with assignment.
@ CallInit
Call-style initialization (C++98)
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack.
ValueDecl * getVariable() const
bool isVariableCapture() const
bool isBlockCapture() const
SourceLocation getLocation() const
Retrieve the location at which this variable was captured.
bool isNonODRUsed() const
bool isInitCapture() const
Determine whether this capture is an init-capture.
bool isVLATypeCapture() const
SourceLocation getEllipsisLoc() const
Retrieve the source location of the ellipsis, whose presence indicates that the capture is a pack exp...
bool isThisCapture() const
QualType getCaptureType() const
Retrieve the capture type for this capture, which is effectively the type of the non-static data memb...
bool isCopyCapture() const
const VariableArrayType * getCapturedVLAType() const
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
bool isCaptured(ValueDecl *Var) const
Determine whether the given variable has been captured.
SmallVector< Capture, 4 > Captures
Captures - The captures.
ImplicitCaptureStyle ImpCaptureStyle
bool HasImplicitReturnType
Capture & getCXXThisCapture()
Retrieve the capture of C++ 'this', if it has been captured.
bool isCXXThisCaptured() const
Determine whether the C++ 'this' is captured.
void addCapture(ValueDecl *Var, bool isBlock, bool isByref, bool isNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, bool Invalid)
SmallVector< ReturnStmt *, 4 > Returns
The list of return statements that occur within the function or block, if there is any chance of appl...
SourceLocation PotentialThisCaptureLocation
void finishedExplicitCaptures()
Note when all explicit captures have been added.
bool ContainsUnexpandedParameterPack
Whether the lambda contains an unexpanded parameter pack.
SmallVector< NamedDecl *, 4 > LocalPacks
Packs introduced by this lambda, if any.
CleanupInfo Cleanup
Whether any of the capture expressions requires cleanups.
SourceRange IntroducerRange
Source range covering the lambda introducer [...].
bool ExplicitParams
Whether the (empty) parameter list is explicit.
TemplateParameterList * GLTemplateParameterList
If this is a generic lambda, and the template parameter list has been created (from the TemplateParam...
ExprResult RequiresClause
The requires-clause immediately following the explicit template parameter list, if any.
SourceRange ExplicitTemplateParamsRange
Source range covering the explicit template parameter list (if it exists).
CXXRecordDecl * Lambda
The class that describes the lambda.
unsigned NumExplicitCaptures
The number of captures in the Captures list that are explicit captures.
SourceLocation CaptureDefaultLoc
Source location of the '&' or '=' specifying the default capture type, if any.
llvm::DenseMap< unsigned, SourceRange > ExplicitCaptureRanges
A map of explicit capture indices to their introducer source ranges.
bool AfterParameterList
Indicate that we parsed the parameter list at which point the mutability of the lambda is known.
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
bool Mutable
Whether this is a mutable lambda.
Defines the clang::TargetInfo interface.
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
std::optional< unsigned > getStackIndexOfNearestEnclosingCaptureCapableLambda(ArrayRef< const sema::FunctionScopeInfo * > FunctionScopes, ValueDecl *VarToCapture, Sema &S)
Examines the FunctionScopeInfo stack to determine the nearest enclosing lambda (to the current lambda...
ConstexprSpecKind
Define the kind of constexpr specifier.
@ ICIS_NoInit
No in-class initializer.
@ RQ_None
No ref-qualifier was provided.
LambdaCaptureKind
The different capture forms in a lambda introducer.
@ LCK_ByCopy
Capturing by copy (a.k.a., by value)
@ LCK_ByRef
Capturing by reference.
@ LCK_VLAType
Capturing variable-length array type.
@ LCK_StarThis
Capturing the *this object by copy.
@ LCK_This
Capturing the *this object by reference.
StorageClass
Storage classes.
bool FTIHasSingleVoidParameter(const DeclaratorChunk::FunctionTypeInfo &FTI)
@ CopyInit
[a = b], [a = {b}]
@ C
Languages that the frontend can parse and compile.
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ 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.
ActionResult< Expr * > ExprResult
LangAS
Defines the address space values used by the address space qualifier of QualType.
LambdaCaptureDefault
The default, if any, capture method for a lambda expression.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
StringRef getLambdaStaticInvokerName()
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ EST_BasicNoexcept
noexcept
MutableArrayRef< Expr * > MultiExprArg
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
SourceLocation getTrailingReturnTypeLoc() const
Get the trailing-return-type location for this function declarator.
bool hasTrailingReturnType() const
Determine whether this function declarator had a trailing-return-type.
ParsedType getTrailingReturnType() const
Get the trailing-return-type for this function declarator.
bool hasMutableQualifier() const
Determine whether this lambda-declarator contains a 'mutable' qualifier.
DeclSpec & getOrCreateMethodQualifiers()
ParamInfo - An array of paraminfo objects is allocated whenever a function declarator is parsed.
ExceptionSpecificationType Type
The kind of exception specification this is.
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
RefQualifierKind RefQualifier
FunctionType::ExtInfo ExtInfo
unsigned NumExplicitTemplateParams
The number of parameters in the template parameter list that were explicitly specified by the user,...
SmallVector< NamedDecl *, 4 > TemplateParams
Store the list of the template parameters for a generic lambda or an abbreviated function template.
Represents a complete lambda introducer.
SmallVector< LambdaCapture, 4 > Captures
SourceLocation DefaultLoc
LambdaCaptureDefault Default