Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/ExprCXX_8h_source.html below:

clang: include/clang/AST/ExprCXX.h Source File

NonTypeTemplateParmDecl;

TemplateParameterList;

getSourceRangeImpl() const LLVM_READONLY;

NumArgs,

HasFPFeatures,

Opc == OO_Equal || Opc == OO_StarEqual || Opc == OO_SlashEqual ||

Opc == OO_PercentEqual || Opc == OO_PlusEqual ||

Opc == OO_MinusEqual || Opc == OO_LessLessEqual ||

Opc == OO_GreaterGreaterEqual || Opc == OO_AmpEqual ||

Opc == OO_CaretEqual || Opc == OO_PipeEqual;

OO_ExclaimEqual:

OO_GreaterEqual:

(Operator < OO_Plus || Operator >= OO_Arrow ||

Operator == OO_PlusPlus || Operator == OO_MinusMinus)

->getStmtClass() == CXXOperatorCallExprClass;

MinNumArgs = 0);

->getStmtClass() == CXXMemberCallExprClass;

{ CONFIG, END_PREARG };

MinNumArgs = 0);

NumArgs,

HasFPFeatures,

cast_or_null<CallExpr>(

(CONFIG));

->getStmtClass() == CUDAKernelCallExprClass;

:

(CXXRewrittenBinaryOperatorClass, SemanticForm->

(),

SemanticForm(SemanticForm) {

:

(CXXRewrittenBinaryOperatorClass,

), SemanticForm() {}

(&SemanticForm, &SemanticForm + 1);

->getStmtClass() == CXXRewrittenBinaryOperatorClass;

*op,

PathSize,

HasFPFeatures,

(l), RParenLoc(RParenLoc), AngleBrackets(AngleBrackets) {}

(

->getStmtClass()) {

CXXStaticCastExprClass:

CXXDynamicCastExprClass:

CXXReinterpretCastExprClass:

CXXConstCastExprClass:

CXXAddrspaceCastExprClass:

llvm::TrailingObjects<CXXStaticCastExpr, CXXBaseSpecifier *,

numTrailingObjects(OverloadToken<CXXBaseSpecifier *>)

{

PathSize,

hasFPFeatures);

->getStmtClass() == CXXStaticCastExprClass;

llvm::TrailingObjects<CXXDynamicCastExpr, CXXBaseSpecifier *> {

, writtenTy, l, RParenLoc,

->getStmtClass() == CXXDynamicCastExprClass;

llvm::TrailingObjects<CXXReinterpretCastExpr,

CXXBaseSpecifier *> {

pathSize,

, writtenTy, l,

RParenLoc, AngleBrackets) {}

->getStmtClass() == CXXReinterpretCastExprClass;

llvm::TrailingObjects<CXXConstCastExpr, CXXBaseSpecifier *> {

, writtenTy, l, RParenLoc,

->getStmtClass() == CXXConstCastExprClass;

llvm::TrailingObjects<CXXAddrspaceCastExpr, CXXBaseSpecifier *> {

, writtenTy, l, RParenLoc,

->getStmtClass() == CXXAddrspaceCastExprClass;

NumArgs,

HasFPOptions,

S->getStmtClass() == UserDefinedLiteralClass;

:

(CXXBoolLiteralExprClass,

) {}

->getStmtClass() == CXXBoolLiteralExprClass;

:

(CXXNullPtrLiteralExprClass,

) {}

->getStmtClass() == CXXNullPtrLiteralExprClass;

*SubExpr =

;

:

(CXXStdInitializerListExprClass,

) {}

S->getStmtClass() == CXXStdInitializerListExprClass;

llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;

Operand = (

*)

;

assert(

() &&

);

cast<TypeSourceInfo *>(Operand);

assert(!

() &&

);

*

(cast<Stmt *>(Operand));

->getStmtClass() == CXXTypeidExprClass;

**begin =

**

(&Operand);

:

(MSPropertyRefExprClass, ty, VK,

), BaseExpr(baseExpr),

TheDecl(

), MemberLoc(nameLoc), IsArrow(

),

QualifierLoc(qualifierLoc) {

(QualifierLoc)

->getStmtClass() == MSPropertyRefExprClass;

{ BASE_EXPR, IDX_EXPR, NUM_SUBEXPRS = 2 };

*SubExprs[NUM_SUBEXPRS];

setBase(

*

) { SubExprs[BASE_EXPR] =

; }

setIdx(

*Idx) { SubExprs[IDX_EXPR] = Idx; }

:

(MSPropertySubscriptExprClass, Ty, VK, OK),

RBracketLoc(RBracketLoc) {

SubExprs[BASE_EXPR] =

;

SubExprs[IDX_EXPR] = Idx;

:

(MSPropertySubscriptExprClass, Shell) {}

*

()

{

cast<Expr>(SubExprs[BASE_EXPR]); }

*

()

{

cast<Expr>(SubExprs[IDX_EXPR]); }

->getStmtClass() == MSPropertySubscriptExprClass;

(&SubExprs[0], &SubExprs[0] + NUM_SUBEXPRS);

llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;

Guid(Guid),

(R) {

Guid(Guid),

(R) {

Operand = (

*)

;

assert(

() &&

);

cast<TypeSourceInfo *>(Operand);

assert(!

() &&

);

*

(cast<Stmt *>(Operand));

->getStmtClass() == CXXUuidofExprClass;

**begin =

**

(&Operand);

.CapturedByCopyInLambdaWithExplicitObjectParameter =

;

.CapturedByCopyInLambdaWithExplicitObjectParameter;

->getStmtClass() == CXXThisExprClass;

IsThrownVariableInScope)

->getStmtClass() == CXXThrowExprClass;

(&Operand, Operand ? &Operand + 1 : &Operand);

llvm::TrailingObjects<CXXDefaultArgExpr, Expr *> {

TrailingObjects;

Param->hasUnparsedDefaultArg()

? Param->

().getNonReferenceType()

: Param->getDefaultArg()->

(),

Param(Param), UsedContext(UsedContext) {

*getTrailingObjects<Expr *>() = RewrittenExpr;

:

(CXXDefaultArgExprClass,

) {

CXXDefaultArgExpr *

(

ASTContext &

,

HasRewrittenInit);

CXXDefaultArgExpr *

(

ASTContext &

, SourceLocation

,

ParmVarDecl *Param,

*RewrittenExpr,

DeclContext *UsedContext);

->getStmtClass() == CXXDefaultArgExprClass;

llvm::TrailingObjects<CXXDefaultInitExpr, Expr *> {

TrailingObjects;

*RewrittenInitExpr);

:

(CXXDefaultInitExprClass,

) {

HasRewrittenInit);

*RewrittenInitExpr);

*getTrailingObjects<Expr *>();

*getTrailingObjects<Expr *>();

->getStmtClass() == CXXDefaultInitExprClass;

: Destructor(destructor) {}

*SubExpr =

;

:

(CXXBindTemporaryExprClass, SubExpr->getType(),

,

Temp(temp), SubExpr(SubExpr) {

:

(CXXBindTemporaryExprClass,

) {}

->getStmtClass() == CXXBindTemporaryExprClass;

**getTrailingArgs();

*

*getTrailingArgs()

{

ListInitialization,

StdInitListInitialization,

NumArgs *

(

*);

HadMultipleCandidates,

ListInitialization,

StdInitListInitialization,

ZeroInitialization,

*

*

(getTrailingArgs());

assert(Arg <

() &&

);

assert(Arg <

() &&

);

assert(Arg <

() &&

);

->getStmtClass() == CXXConstructExprClass ||

->getStmtClass() == CXXTemporaryObjectExprClass;

LLVM_PREFERRED_TYPE(

)

ConstructsVirtualBase : 1;

LLVM_PREFERRED_TYPE(

)

InheritedFromVirtualBase : 1;

InheritedFromVirtualBase)

Constructor(Ctor),

(

),

ConstructsVirtualBase(ConstructsVirtualBase),

InheritedFromVirtualBase(InheritedFromVirtualBase) {

:

(CXXInheritedCtorInitExprClass,

),

ConstructsVirtualBase(

), InheritedFromVirtualBase(

) {}

->getStmtClass() == CXXInheritedCtorInitExprClass;

llvm::TrailingObjects<CXXFunctionalCastExpr, CXXBaseSpecifier *,

FPOptionsOverride> {

LParenLoc(lParenLoc), RParenLoc(rParenLoc) {

numTrailingObjects(OverloadToken<CXXBaseSpecifier *>)

{

->getStmtClass() == CXXFunctionalCastExprClass;

HadMultipleCandidates,

ListInitialization,

StdInitListInitialization,

ZeroInitialization);

ParenOrBraceRange,

HadMultipleCandidates,

ListInitialization,

StdInitListInitialization,

ZeroInitialization);

->getStmtClass() == CXXTemporaryObjectExprClass;

Stmt **CXXConstructExpr::getTrailingArgs() {

(

*

= dyn_cast<CXXTemporaryObjectExpr>(

))

Stmt **

(

+ 1);

);

Stmt **

(

+ 1);

llvm::TrailingObjects<LambdaExpr, Stmt *> {

ClosingBrace,

ContainsUnexpandedParameterPack);

**getStoredStmts() {

getTrailingObjects<Stmt *>(); }

*

*getStoredStmts()

{

getTrailingObjects<Stmt *>(); }

initBodyIfNeeded()

;

ExplicitParams,

ExplicitResultType,

ContainsUnexpandedParameterPack);

NumCaptures);

**

(getStoredStmts());

*

*

(getStoredStmts());

*ConstThis =

;

*

(ConstThis->getCompoundStmtBody());

->getStmtClass() == LambdaExprClass;

IntroducerRange.getBegin();

:

(CXXScalarValueInitExprClass, Shell) {}

->getStmtClass() == CXXScalarValueInitExprClass;

llvm::TrailingObjects<CXXNewExpr, Stmt *, SourceRange> {

TrailingObjects;

arraySizeOffset()

{

0; }

initExprOffset()

{

arraySizeOffset() +

(); }

placementNewArgsOffset()

{

numTrailingObjects(OverloadToken<Stmt *>)

{

numTrailingObjects(OverloadToken<SourceRange>)

{

CXXNewExpr(

IsGlobalNew, FunctionDecl *OperatorNew,

FunctionDecl *OperatorDelete,

ShouldPassAlignment,

UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs,

SourceRange TypeIdParens, std::optional<Expr *> ArraySize,

QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange

,

SourceRange DirectInitRange);

CXXNewExpr(EmptyShell

,

IsArray,

NumPlacementArgs,

IsParenTypeId);

(

ASTContext &Ctx,

IsGlobalNew, FunctionDecl *OperatorNew,

FunctionDecl *OperatorDelete,

ShouldPassAlignment,

UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs,

SourceRange TypeIdParens, std::optional<Expr *> ArraySize,

QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange

,

SourceRange DirectInitRange);

CXXNewExpr *

(

ASTContext &Ctx,

IsArray,

HasInit,

NumPlacementArgs,

IsParenTypeId);

AllocatedTypeInfo;

std::nullopt;

cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]))

std::nullopt;

std::nullopt;

cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]))

std::nullopt;

**

(getTrailingObjects<Stmt *>() +

placementNewArgsOffset());

() ? getTrailingObjects<SourceRange>()[0]

? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])

? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])

getTrailingObjects<Stmt *>() + placementNewArgsOffset();

getTrailingObjects<Stmt *>() + placementNewArgsOffset();

() + numTrailingObjects(OverloadToken<Stmt *>());

getTrailingObjects<Stmt *>();

() + numTrailingObjects(OverloadToken<Stmt *>());

->getStmtClass() == CXXNewExprClass;

*Argument =

;

ArrayFormAsWritten,

UsualArrayDeleteWantsSize,

OperatorDelete(OperatorDelete), Argument(Arg) {

->getStmtClass() == CXXDeleteExprClass;

llvm::PointerUnion<TypeSourceInfo *, const IdentifierInfo *>

;

:

(II), Location(

) {}

LLVM_PREFERRED_TYPE(

)

:

(CXXPseudoDestructorExprClass, Shell), IsArrow(

) {}

->getBeginLoc();

->getStmtClass() == CXXPseudoDestructorExprClass;

llvm::TrailingObjects<TypeTraitExpr, TypeSourceInfo *> {

numTrailingObjects(OverloadToken<TypeSourceInfo *>)

{

assert(I <

() &&

);

->getStmtClass() == TypeTraitExprClass;

(value), Dimension(dimension),

(loc), RParen(rparen),

QueriedType(queried) {

assert(att <=

&&

);

assert(

(att) == ATT &&

);

:

(ArrayTypeTraitExprClass,

), ATT(0) {}

->getStmtClass() == ArrayTypeTraitExprClass;

LLVM_PREFERRED_TYPE(

)

* QueriedExpression =

;

ET(et),

(value),

(loc), RParen(rparen),

QueriedExpression(queried) {

assert(et <=

&&

);

assert(

(et) == ET &&

);

->getStmtClass() == ExpressionTraitExprClass;

KnownDependent,

KnownInstantiationDependent,

KnownContainsUnexpandedParameterPack);

HasTemplateKWAndArgsInfo);

assert(

->getType()->isSpecificBuiltinType(BuiltinType::Overload));

HasParen = isa<ParenExpr>(

);

=

->IgnoreParens();

(isa<UnaryOperator>(

)) {

assert(cast<UnaryOperator>(

)->getOpcode() == UO_AddrOf);

= cast<UnaryOperator>(

)->getSubExpr();

*Ovl = cast<OverloadExpr>(

->IgnoreParens());

.HasFormOfMemberPointer = (

== Ovl && Ovl->getQualifier());

.IsAddressOfOperand =

;

.IsAddressOfOperandWithParen = HasParen;

.Expression = Ovl;

.Expression = cast<OverloadExpr>(

);

llvm::iterator_range<decls_iterator>

()

{

->getStmtClass() == UnresolvedLookupExprClass ||

->getStmtClass() == UnresolvedMemberExprClass;

llvm::TrailingObjects<UnresolvedLookupExpr, DeclAccessPair,

ASTTemplateKWAndArgsInfo,

TemplateArgumentLoc> {

TrailingObjects;

KnownDependent,

KnownInstantiationDependent);

HasTemplateKWAndArgsInfo);

numTrailingObjects(OverloadToken<DeclAccessPair>)

{

numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)

{

UnresolvedLookupExpr *

(

ASTContext &Context, CXXRecordDecl *NamingClass,

NestedNameSpecifierLoc QualifierLoc,

DeclarationNameInfo &NameInfo,

RequiresADL,

UnresolvedSetIterator

, UnresolvedSetIterator End,

KnownDependent,

KnownInstantiationDependent);

UnresolvedLookupExpr *

(

ASTContext &Context, CXXRecordDecl *NamingClass,

NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,

DeclarationNameInfo &NameInfo,

RequiresADL,

TemplateArgumentListInfo *Args, UnresolvedSetIterator

,

UnresolvedSetIterator End,

KnownDependent,

KnownInstantiationDependent);

UnresolvedLookupExpr *

(

ASTContext &Context,

NumResults,

HasTemplateKWAndArgsInfo,

NumTemplateArgs);

l.getBeginLoc();

->getStmtClass() == UnresolvedLookupExprClass;

llvm::TrailingObjects<DependentScopeDeclRefExpr,

ASTTemplateKWAndArgsInfo,

TemplateArgumentLoc> {

TrailingObjects;

numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)

{

hasTemplateKWAndArgsInfo();

hasTemplateKWAndArgsInfo()

{

DependentScopeDeclRefExpr *

(

ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,

SourceLocation TemplateKWLoc,

DeclarationNameInfo &NameInfo,

TemplateArgumentListInfo *TemplateArgs);

DependentScopeDeclRefExpr *

(

ASTContext &Context,

HasTemplateKWAndArgsInfo,

NumTemplateArgs);

(!hasTemplateKWAndArgsInfo())

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;

(!hasTemplateKWAndArgsInfo())

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;

(!hasTemplateKWAndArgsInfo())

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(

getTrailingObjects<TemplateArgumentLoc>(), List);

getTrailingObjects<TemplateArgumentLoc>();

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;

->getStmtClass() == DependentScopeDeclRefExprClass;

llvm::TrailingObjects<

llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>> {

TrailingObjects;

numObjects);

CleanupsHaveSideEffects,

->getStmtClass() == ExprWithCleanupsClass;

llvm::TrailingObjects<CXXUnresolvedConstructExpr, Expr *> {

TrailingObjects;

llvm::PointerIntPair<TypeSourceInfo *, 1> TypeAndInitForm;

:

(CXXUnresolvedConstructExprClass,

) {

TypeAndInitForm.getPointer();

assert(I <

() &&

);

assert(I <

() &&

);

assert(I <

() &&

);

->getStmtClass() == CXXUnresolvedConstructExprClass;

**begin =

**

(

llvm::TrailingObjects<CXXDependentScopeMemberExpr,

ASTTemplateKWAndArgsInfo,

TemplateArgumentLoc, NamedDecl *> {

TrailingObjects;

hasTemplateKWAndArgsInfo()

{

hasFirstQualifierFoundInScope()

{

numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)

{

hasTemplateKWAndArgsInfo();

numTrailingObjects(OverloadToken<TemplateArgumentLoc>)

{

numTrailingObjects(OverloadToken<NamedDecl *>)

{

hasFirstQualifierFoundInScope();

CXXDependentScopeMemberExpr(

ASTContext &Ctx,

*

,

QualType BaseType,

IsArrow,

SourceLocation OperatorLoc,

NestedNameSpecifierLoc QualifierLoc,

SourceLocation TemplateKWLoc,

NamedDecl *FirstQualifierFoundInScope,

DeclarationNameInfo MemberNameInfo,

TemplateArgumentListInfo *TemplateArgs);

CXXDependentScopeMemberExpr(EmptyShell

,

HasTemplateKWAndArgsInfo,

HasFirstQualifierFoundInScope);

CXXDependentScopeMemberExpr *

(

ASTContext &Ctx,

*

, QualType BaseType,

IsArrow,

SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,

SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope,

DeclarationNameInfo MemberNameInfo,

TemplateArgumentListInfo *TemplateArgs);

CXXDependentScopeMemberExpr *

(

ASTContext &Ctx,

HasTemplateKWAndArgsInfo,

NumTemplateArgs,

HasFirstQualifierFoundInScope);

cast<Expr>(

)->isImplicitCXXThis();

cast<Expr>(

);

(!hasFirstQualifierFoundInScope())

*getTrailingObjects<NamedDecl *>();

MemberNameInfo;

(!hasTemplateKWAndArgsInfo())

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;

(!hasTemplateKWAndArgsInfo())

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;

(!hasTemplateKWAndArgsInfo())

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(

getTrailingObjects<TemplateArgumentLoc>(), List);

getTrailingObjects<TemplateArgumentLoc>();

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;

->getBeginLoc();

->getStmtClass() == CXXDependentScopeMemberExprClass;

llvm::TrailingObjects<UnresolvedMemberExpr, DeclAccessPair,

ASTTemplateKWAndArgsInfo,

TemplateArgumentLoc> {

TrailingObjects;

HasTemplateKWAndArgsInfo);

numTrailingObjects(OverloadToken<DeclAccessPair>)

{

numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)

{

UnresolvedMemberExpr *

(

ASTContext &Context,

HasUnresolvedUsing, Expr *

,

QualType BaseType,

IsArrow, SourceLocation OperatorLoc,

NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,

DeclarationNameInfo &MemberNameInfo,

TemplateArgumentListInfo *TemplateArgs,

UnresolvedSetIterator

, UnresolvedSetIterator End);

UnresolvedMemberExpr *

(

ASTContext &Context,

NumResults,

HasTemplateKWAndArgsInfo,

NumTemplateArgs);

cast<Expr>(

);

cast<Expr>(

);

->getBeginLoc();

l.getBeginLoc();

->getStmtClass() == UnresolvedMemberExprClass;

(

*ULE = dyn_cast<UnresolvedLookupExpr>(

))

cast<UnresolvedMemberExpr>(

)->getTrailingObjects<

>();

(

*ULE = dyn_cast<UnresolvedLookupExpr>(

))

cast<UnresolvedMemberExpr>(

)

(

*ULE = dyn_cast<UnresolvedLookupExpr>(

))

cast<UnresolvedMemberExpr>(

)

(

*ULE = dyn_cast<UnresolvedLookupExpr>(

))

ULE->getNamingClass();

cast<UnresolvedMemberExpr>(

)->getNamingClass();

Operand(Operand),

(Keyword, RParen) {

->getStmtClass() == CXXNoexceptExprClass;

NumExpansions;

std::optional<unsigned> NumExpansions)

EllipsisLoc(EllipsisLoc),

NumExpansions(NumExpansions ? *NumExpansions + 1 : 0),

NumExpansions - 1;

std::nullopt;

->getStmtClass() == PackExpansionExprClass;

llvm::TrailingObjects<SizeOfPackExpr, TemplateArgument> {

TrailingObjects;

std::optional<unsigned> Length,

OperatorLoc(OperatorLoc), PackLoc(PackLoc), RParenLoc(RParenLoc),

Length(Length ? *Length : PartialArgs.size()), Pack(Pack) {

assert((!Length || PartialArgs.empty()) &&

);

*Args = getTrailingObjects<TemplateArgument>();

std::uninitialized_copy(PartialArgs.begin(), PartialArgs.end(), Args);

: ExprDependence::ValueInstantiation);

:

(SizeOfPackExprClass,

), Length(NumPartialArgs) {}

SizeOfPackExpr *

(ASTContext &Context, SourceLocation OperatorLoc,

NamedDecl *Pack, SourceLocation PackLoc,

SourceLocation RParenLoc,

std::optional<unsigned> Length = std::nullopt,

ArrayRef<TemplateArgument> PartialArgs = {});

NumPartialArgs);

);

*Args = getTrailingObjects<TemplateArgument>();

->getStmtClass() == SizeOfPackExprClass;

llvm::TrailingObjects<PackIndexingExpr, Expr *> {

TrailingObjects;

TransformedExpressions : 31;

LLVM_PREFERRED_TYPE(

)

FullySubstituted : 1;

FullySubstituted =

)

EllipsisLoc(EllipsisLoc), RSquareLoc(RSquareLoc),

SubExprs{PackIdExpr, IndexExpr},

TransformedExpressions(SubstitutedExprs.size()),

FullySubstituted(FullySubstituted) {

*Exprs = getTrailingObjects<Expr *>();

std::uninitialized_copy(SubstitutedExprs.begin(), SubstitutedExprs.end(),

PackIndexingExpr(EmptyShell

) :

(PackIndexingExprClass,

) {}

numTrailingObjects(OverloadToken<Expr *>)

{

TransformedExpressions;

PackIndexingExpr *

(ASTContext &Context,

SourceLocation EllipsisLoc,

SourceLocation RSquareLoc,

*PackIdExpr,

*IndexExpr, std::optional<int64_t> Index,

ArrayRef<Expr *> SubstitutedExprs = {},

FullySubstituted =

);

NumTransformedExprs);

std::nullopt;

assert(Index.isNonNegative() &&

);

(Index.getExtValue());

assert(Index &&

);

getTrailingObjects<Expr *>()[*Index];

{getTrailingObjects<Expr *>(), TransformedExpressions};

->getStmtClass() == PackIndexingExprClass;

llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndRef;

Index : 15;

PackIndex : 16;

:

(SubstNonTypeTemplateParmExprClass,

) {}

*AssociatedDecl,

Index,

std::optional<unsigned> PackIndex,

RefParam)

:

(SubstNonTypeTemplateParmExprClass, Ty, ValueKind,

),

Replacement(Replacement),

AssociatedDeclAndRef(AssociatedDecl, RefParam), Index(Index),

PackIndex(PackIndex ? *PackIndex + 1 : 0) {

assert(AssociatedDecl !=

);

std::nullopt;

PackIndex - 1;

->getStmtClass() == SubstNonTypeTemplateParmExprClass;

*AssociatedDecl;

NumArguments : 16;

Index : 16;

:

(SubstNonTypeTemplateParmPackExprClass,

) {}

*AssociatedDecl,

Index);

->getStmtClass() == SubstNonTypeTemplateParmPackExprClass;

llvm::TrailingObjects<FunctionParmPackExpr, VarDecl *> {

TrailingObjects;

NumParameters;

NumParams);

->getStmtClass() == FunctionParmPackExprClass;

llvm::PointerUnion<Stmt *, LifetimeExtendedTemporaryDecl *> State;

BoundToLvalueReference,

:

(MaterializeTemporaryExprClass,

) {}

? cast<Stmt *>(State)

: cast<LifetimeExtendedTemporaryDecl *>(State)->getTemporaryExpr());

: cast<LifetimeExtendedTemporaryDecl *>(State)

->getStorageDuration();

assert(isa<LifetimeExtendedTemporaryDecl *>(State) &&

);

cast<LifetimeExtendedTemporaryDecl *>(State)->getOrCreateValue(

isa<Stmt *>(State) ? nullptr

: cast<LifetimeExtendedTemporaryDecl *>(State)

->getExtendingDecl();

isa<Stmt *>(State) ? 0

: cast<LifetimeExtendedTemporaryDecl *>(State)

->getManglingNumber();

->getStmtClass() == MaterializeTemporaryExprClass;

isa<Stmt *>(State)

?

(State.getAddrOfPtr1(), State.getAddrOfPtr1() + 1)

: cast<LifetimeExtendedTemporaryDecl *>(State)->childrenExpr();

isa<Stmt *>(State)

State.getAddrOfPtr1() + 1)

cast<LifetimeExtendedTemporaryDecl *>(State))

SubExpr { Callee, LHS, RHS, Count };

NumExpansions;

*SubExprs[SubExpr::Count];

std::optional<unsigned> NumExpansions);

NumExpansions - 1;

std::nullopt;

->getStmtClass() == CXXFoldExprClass;

(SubExprs, SubExprs + SubExpr::Count);

llvm::TrailingObjects<CXXParenListInitExpr, Expr *> {

NumUserSpecifiedExprs;

llvm::PointerUnion<Expr *, FieldDecl *> ArrayFillerOrUnionFieldInit;

NumExprs(Args.size()), NumUserSpecifiedExprs(NumUserSpecifiedExprs),

InitLoc(InitLoc), LParenLoc(LParenLoc), RParenLoc(RParenLoc) {

std::copy(Args.begin(), Args.end(), getTrailingObjects<Expr *>());

assert(NumExprs >= NumUserSpecifiedExprs &&

numTrailingObjects(OverloadToken<Expr *>)

{

NumExprs; }

CXXParenListInitExpr *

(ASTContext &

, ArrayRef<Expr *> Args, QualType

,

NumUserSpecifiedExprs, SourceLocation InitLoc,

SourceLocation LParenLoc, SourceLocation RParenLoc);

CXXParenListInitExpr *

(ASTContext &

,

numExprs,

:

(CXXParenListInitExprClass,

), NumExprs(NumExprs),

NumUserSpecifiedExprs(0) {}

(getTrailingObjects<Expr *>(), NumExprs);

(getTrailingObjects<Expr *>(), NumExprs);

(getTrailingObjects<Expr *>(), NumUserSpecifiedExprs);

(getTrailingObjects<Expr *>(), NumUserSpecifiedExprs);

dyn_cast_if_present<Expr *>(ArrayFillerOrUnionFieldInit);

dyn_cast_if_present<Expr *>(ArrayFillerOrUnionFieldInit);

ArrayFillerOrUnionFieldInit = FD;

dyn_cast_if_present<FieldDecl *>(ArrayFillerOrUnionFieldInit);

dyn_cast_if_present<FieldDecl *>(ArrayFillerOrUnionFieldInit);

**

=

**

(getTrailingObjects<Expr *>());

*

*

(getTrailingObjects<Expr *>());

->getStmtClass() == CXXParenListInitExprClass;

SubExpr { Operand, Common, Ready, Suspend, Resume, Count };

*SubExprs[SubExpr::Count];

KeywordLoc(KeywordLoc), OpaqueValue(OpaqueValue) {

SubExprs[SubExpr::Operand] = Operand;

SubExprs[SubExpr::Common] = Common;

SubExprs[SubExpr::Ready] = Ready;

SubExprs[SubExpr::Suspend] = Suspend;

SubExprs[SubExpr::Resume] = Resume;

);

SubExprs[SubExpr::Operand] = Operand;

SubExprs[SubExpr::Common] = Common;

SubExprs[SubExpr::Ready] =

;

SubExprs[SubExpr::Suspend] =

;

SubExprs[SubExpr::Resume] =

;

SubExprs[SubExpr::Operand] =

;

SubExprs[SubExpr::Common] =

;

SubExprs[SubExpr::Ready] =

;

SubExprs[SubExpr::Suspend] =

;

SubExprs[SubExpr::Resume] =

;

*

(SubExprs[SubExpr::Common]);

*

(SubExprs[SubExpr::Ready]);

*

(SubExprs[SubExpr::Suspend]);

*

(SubExprs[SubExpr::Resume]);

*

(SubExprs[SubExpr::Operand]);

assert(SuspendExpr);

SuspendType = SuspendExpr->getType();

(SuspendType->isVoidType())

(SuspendType->isBooleanType())

assert(SuspendType->isVoidPointerType());

(SubExprs, SubExprs + SubExpr::Count);

->getStmtClass() == CoawaitExprClass ||

->getStmtClass() == CoyieldExprClass;

Ready, Suspend, Resume, OpaqueValue) {

*Common,

IsImplicit =

)

->getStmtClass() == CoawaitExprClass;

KeywordLoc(KeywordLoc) {

);

SubExprs[1] = OpCoawait;

:

(DependentCoawaitExprClass,

) {}

cast<UnresolvedLookupExpr>(SubExprs[1]);

->getStmtClass() == DependentCoawaitExprClass;

Ready, Suspend, Resume, OpaqueValue) {}

->getStmtClass() == CoyieldExprClass;

llvm::TrailingObjects<BuiltinBitCastExpr, CXXBaseSpecifier *> {

TrailingObjects;

KWLoc(KWLoc), RParenLoc(RParenLoc) {}

->getStmtClass() == BuiltinBitCastExprClass;

llvm::TrailingObjects<ResolvedUnexpandedPackExpr, Expr *> {

TrailingObjects;

{getTrailingObjects<Expr *>(), NumExprs};

{getTrailingObjects<Expr *>(), NumExprs};

->getStmtClass() == ResolvedUnexpandedPackExprClass;

This file provides AST data structures related to concepts.

enum clang::sema::@1704::IndirectLocalPathEntry::EntryKind Kind

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

Defines the C++ template declaration subclasses.

Defines the ExceptionSpecificationType enumeration and various utility functions.

Defines enumerations for expression traits intrinsics.

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

Defines several types used to describe C++ lambda expressions that are shared between the parser and ...

Defines the clang::LangOptions interface.

Defines an enumeration for C++ overloaded operators.

Defines the clang::SourceLocation class and associated facilities.

Defines various enumerations that describe declaration and type specifiers.

static QualType getPointeeType(const MemRegion *R)

Defines enumerations for the type traits support.

C Language Family Type Representation.

__device__ __2f16 float __ockl_bool s

APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

Reads an AST files chain containing the contents of a translation unit.

An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.

ArrayTypeTraitExpr(SourceLocation loc, ArrayTypeTrait att, TypeSourceInfo *queried, uint64_t value, Expr *dimension, SourceLocation rparen, QualType ty)

uint64_t getValue() const

SourceLocation getEndLoc() const LLVM_READONLY

ArrayTypeTrait getTrait() const

QualType getQueriedType() const

Expr * getDimensionExpression() const

ArrayTypeTraitExpr(EmptyShell Empty)

const_child_range children() const

static bool classof(const Stmt *T)

TypeSourceInfo * getQueriedTypeSourceInfo() const

SourceLocation getBeginLoc() const LLVM_READONLY

StringRef getOpcodeStr() const

Represents a C++2a __builtin_bit_cast(T, v) expression.

static bool classof(const Stmt *T)

SourceLocation getEndLoc() const LLVM_READONLY

BuiltinBitCastExpr(EmptyShell Empty)

BuiltinBitCastExpr(QualType T, ExprValueKind VK, CastKind CK, Expr *SrcExpr, TypeSourceInfo *DstType, SourceLocation KWLoc, SourceLocation RParenLoc)

SourceLocation getBeginLoc() const LLVM_READONLY

Represents a call to a CUDA kernel function.

const CallExpr * getConfig() const

static CUDAKernelCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)

static bool classof(const Stmt *T)

A C++ addrspace_cast expression (currently only enabled for OpenCL).

static bool classof(const Stmt *T)

static CXXAddrspaceCastExpr * CreateEmpty(const ASTContext &Context)

Represents binding an expression to a temporary.

CXXBindTemporaryExpr(EmptyShell Empty)

static bool classof(const Stmt *T)

void setTemporary(CXXTemporary *T)

const_child_range children() const

CXXTemporary * getTemporary()

const CXXTemporary * getTemporary() const

const Expr * getSubExpr() const

SourceLocation getEndLoc() const LLVM_READONLY

SourceLocation getBeginLoc() const LLVM_READONLY

A boolean literal, per ([C++ lex.bool] Boolean literals).

const_child_range children() const

CXXBoolLiteralExpr(bool Val, QualType Ty, SourceLocation Loc)

SourceLocation getEndLoc() const

static bool classof(const Stmt *T)

static CXXBoolLiteralExpr * Create(const ASTContext &C, bool Val, QualType Ty, SourceLocation Loc)

CXXBoolLiteralExpr(EmptyShell Empty)

SourceLocation getBeginLoc() const

SourceLocation getLocation() const

void setLocation(SourceLocation L)

A C++ const_cast expression (C++ [expr.const.cast]).

static bool classof(const Stmt *T)

static CXXConstCastExpr * CreateEmpty(const ASTContext &Context)

Represents a call to a C++ constructor.

SourceRange getParenOrBraceRange() const

const_arg_iterator arg_end() const

void setStdInitListInitialization(bool V)

void setConstructionKind(CXXConstructionKind CK)

void setIsImmediateEscalating(bool Set)

llvm::iterator_range< arg_iterator > arg_range

bool isElidable() const

Whether this construction is elidable.

bool hadMultipleCandidates() const

Whether the referred constructor was resolved from an overloaded set having size greater than 1.

Expr * getArg(unsigned Arg)

Return the specified argument.

bool isStdInitListInitialization() const

Whether this constructor call was written as list-initialization, but was interpreted as forming a st...

void setListInitialization(bool V)

bool isImmediateEscalating() const

bool requiresZeroInitialization() const

Whether this construction first requires zero-initialization before the initializer is called.

void setRequiresZeroInitialization(bool ZeroInit)

SourceLocation getLocation() const

const_arg_range arguments() const

static unsigned sizeOfTrailingObjects(unsigned NumArgs)

Return the size in bytes of the trailing objects.

void setArg(unsigned Arg, Expr *ArgExpr)

Set the specified argument.

SourceLocation getEndLoc() const LLVM_READONLY

llvm::iterator_range< const_arg_iterator > const_arg_range

SourceLocation getBeginLoc() const LLVM_READONLY

void setParenOrBraceRange(SourceRange Range)

const_arg_iterator arg_begin() const

const_child_range children() const

CXXConstructorDecl * getConstructor() const

Get the constructor that this expression will (ultimately) call.

bool isListInitialization() const

Whether this constructor call was written as list-initialization.

unsigned getNumArgs() const

Return the number of arguments to the constructor call.

CXXConstructionKind getConstructionKind() const

Determine whether this constructor is actually constructing a base class (rather than a complete obje...

void setHadMultipleCandidates(bool V)

void setLocation(SourceLocation Loc)

const Expr * getArg(unsigned Arg) const

const Expr *const * getArgs() const

static bool classof(const Stmt *T)

static CXXConstructExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs)

Create an empty C++ construction expression.

Represents a C++ constructor within a class.

A default argument (C++ [dcl.fct.default]).

SourceLocation getEndLoc() const

const_child_range children() const

SourceLocation getBeginLoc() const

Default argument expressions have no representation in the source, so they have an empty source range...

SourceLocation getUsedLocation() const

Retrieve the location where this default argument was actually used.

const ParmVarDecl * getParam() const

const Expr * getExpr() const

Expr * getRewrittenExpr()

Expr * getAdjustedRewrittenExpr()

const Expr * getAdjustedRewrittenExpr() const

DeclContext * getUsedContext()

SourceLocation getExprLoc() const

const DeclContext * getUsedContext() const

const Expr * getRewrittenExpr() const

static bool classof(const Stmt *T)

static CXXDefaultArgExpr * CreateEmpty(const ASTContext &C, bool HasRewrittenInit)

bool hasRewrittenInit() const

A use of a default initializer in a constructor or in aggregate initialization.

static bool classof(const Stmt *T)

const DeclContext * getUsedContext() const

const FieldDecl * getField() const

const Expr * getRewrittenExpr() const

Retrieve the initializing expression with evaluated immediate calls, if any.

const Expr * getExpr() const

bool hasRewrittenInit() const

Expr * getExpr()

Get the initialization expression that will be used.

FieldDecl * getField()

Get the field whose initializer will be used.

static CXXDefaultInitExpr * CreateEmpty(const ASTContext &C, bool HasRewrittenInit)

Expr * getRewrittenExpr()

Retrieve the initializing expression with evaluated immediate calls, if any.

SourceLocation getBeginLoc() const

SourceLocation getEndLoc() const

const_child_range children() const

DeclContext * getUsedContext()

SourceLocation getUsedLocation() const

Retrieve the location where this default initializer expression was actually used.

Represents a delete expression for memory deallocation and destructor calls, e.g.

static bool classof(const Stmt *T)

FunctionDecl * getOperatorDelete() const

SourceLocation getEndLoc() const LLVM_READONLY

CXXDeleteExpr(EmptyShell Shell)

const_child_range children() const

SourceLocation getBeginLoc() const

const Expr * getArgument() const

bool isGlobalDelete() const

bool doesUsualArrayDeleteWantSize() const

Answers whether the usual array deallocation function for the allocated type expects the size of the ...

QualType getDestroyedType() const

Retrieve the type being destroyed.

bool isArrayFormAsWritten() const

CXXDeleteExpr(QualType Ty, bool GlobalDelete, bool ArrayForm, bool ArrayFormAsWritten, bool UsualArrayDeleteWantsSize, FunctionDecl *OperatorDelete, Expr *Arg, SourceLocation Loc)

Represents a C++ member access expression where the actual member referenced could not be resolved be...

bool isArrow() const

Determine whether this member expression used the '->' operator; otherwise, it used the '.

SourceLocation getOperatorLoc() const

Retrieve the location of the '->' or '.' operator.

SourceLocation getLAngleLoc() const

Retrieve the location of the left angle bracket starting the explicit template argument list followin...

SourceLocation getTemplateKeywordLoc() const

Retrieve the location of the template keyword preceding the member name, if any.

const DeclarationNameInfo & getMemberNameInfo() const

Retrieve the name of the member that this expression refers to.

SourceLocation getBeginLoc() const LLVM_READONLY

NestedNameSpecifier * getQualifier() const

Retrieve the nested-name-specifier that qualifies the member name.

void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const

Copies the template arguments (if present) into the given structure.

unsigned getNumTemplateArgs() const

Retrieve the number of template arguments provided as part of this template-id.

const TemplateArgumentLoc * getTemplateArgs() const

Retrieve the template arguments provided as part of this template-id.

bool hasExplicitTemplateArgs() const

Determines whether this member expression actually had a C++ template argument list explicitly specif...

static CXXDependentScopeMemberExpr * CreateEmpty(const ASTContext &Ctx, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs, bool HasFirstQualifierFoundInScope)

SourceLocation getMemberLoc() const

static bool classof(const Stmt *T)

SourceLocation getRAngleLoc() const

Retrieve the location of the right angle bracket ending the explicit template argument list following...

QualType getBaseType() const

DeclarationName getMember() const

Retrieve the name of the member that this expression refers to.

SourceLocation getEndLoc() const LLVM_READONLY

NamedDecl * getFirstQualifierFoundInScope() const

Retrieve the first part of the nested-name-specifier that was found in the scope of the member access...

Expr * getBase() const

Retrieve the base object of this member expressions, e.g., the x in x.m.

NestedNameSpecifierLoc getQualifierLoc() const

Retrieve the nested-name-specifier that qualifies the member name, with source location information.

const_child_range children() const

bool hasTemplateKeyword() const

Determines whether the member name was preceded by the template keyword.

bool isImplicitAccess() const

True if this is an implicit access, i.e.

ArrayRef< TemplateArgumentLoc > template_arguments() const

Represents a C++ destructor within a class.

A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).

static bool classof(const Stmt *T)

static CXXDynamicCastExpr * CreateEmpty(const ASTContext &Context, unsigned pathSize)

bool isAlwaysNull() const

isAlwaysNull - Return whether the result of the dynamic_cast is proven to always be null.

Represents a folding of a pack over an operator.

static bool classof(const Stmt *T)

SourceLocation getBeginLoc() const LLVM_READONLY

UnresolvedLookupExpr * getCallee() const

Expr * getInit() const

Get the operand that doesn't contain a pack, for a binary fold.

CXXFoldExpr(EmptyShell Empty)

std::optional< unsigned > getNumExpansions() const

SourceLocation getEndLoc() const LLVM_READONLY

const_child_range children() const

SourceLocation getLParenLoc() const

SourceLocation getEllipsisLoc() const

bool isLeftFold() const

Does this produce a left-associated sequence of operators?

bool isRightFold() const

Does this produce a right-associated sequence of operators?

Expr * getPattern() const

Get the pattern, that is, the operand that contains an unexpanded pack.

SourceLocation getRParenLoc() const

BinaryOperatorKind getOperator() const

Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....

void setLParenLoc(SourceLocation L)

SourceLocation getLParenLoc() const

static CXXFunctionalCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)

SourceLocation getRParenLoc() const

SourceLocation getBeginLoc() const LLVM_READONLY

void setRParenLoc(SourceLocation L)

static bool classof(const Stmt *T)

bool isListInitialization() const

Determine whether this expression models list-initialization.

SourceLocation getEndLoc() const LLVM_READONLY

Represents a call to an inherited base class constructor from an inheriting constructor.

CXXInheritedCtorInitExpr(EmptyShell Empty)

Construct an empty C++ inheriting construction expression.

const_child_range children() const

CXXConstructionKind getConstructionKind() const

SourceLocation getBeginLoc() const LLVM_READONLY

static bool classof(const Stmt *T)

bool constructsVBase() const

Determine whether this constructor is actually constructing a base class (rather than a complete obje...

CXXConstructorDecl * getConstructor() const

Get the constructor that this expression will call.

CXXInheritedCtorInitExpr(SourceLocation Loc, QualType T, CXXConstructorDecl *Ctor, bool ConstructsVirtualBase, bool InheritedFromVirtualBase)

Construct a C++ inheriting construction expression.

SourceLocation getLocation() const LLVM_READONLY

SourceLocation getEndLoc() const LLVM_READONLY

bool inheritedFromVBase() const

Determine whether the inherited constructor is inherited from a virtual base of the object we constru...

Represents a call to a member function that may be written either with member call syntax (e....

CXXMethodDecl * getMethodDecl() const

Retrieve the declaration of the called method.

Expr * getImplicitObjectArgument() const

Retrieve the implicit object argument for the member call.

static CXXMemberCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)

QualType getObjectType() const

Retrieve the type of the object argument.

SourceLocation getExprLoc() const LLVM_READONLY

static bool classof(const Stmt *T)

CXXRecordDecl * getRecordDecl() const

Retrieve the CXXRecordDecl for the underlying type of the implicit object argument.

Represents a static or instance method of a struct/union/class.

Abstract class common to all of the C++ "named"/"keyword" casts.

SourceLocation getBeginLoc() const LLVM_READONLY

SourceLocation getOperatorLoc() const

Retrieve the location of the cast operator keyword, e.g., static_cast.

const char * getCastName() const

getCastName - Get the name of the C++ cast being used, e.g., "static_cast", "dynamic_cast",...

CXXNamedCastExpr(StmtClass SC, QualType ty, ExprValueKind VK, CastKind kind, Expr *op, unsigned PathSize, bool HasFPFeatures, TypeSourceInfo *writtenTy, SourceLocation l, SourceLocation RParenLoc, SourceRange AngleBrackets)

static bool classof(const Stmt *T)

CXXNamedCastExpr(StmtClass SC, EmptyShell Shell, unsigned PathSize, bool HasFPFeatures)

SourceRange getAngleBrackets() const LLVM_READONLY

SourceLocation getEndLoc() const LLVM_READONLY

SourceLocation getRParenLoc() const

Retrieve the location of the closing parenthesis.

Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".

static CXXNewExpr * CreateEmpty(const ASTContext &Ctx, bool IsArray, bool HasInit, unsigned NumPlacementArgs, bool IsParenTypeId)

Create an empty c++ new expression.

SourceRange getDirectInitRange() const

llvm::iterator_range< arg_iterator > placement_arguments()

QualType getAllocatedType() const

arg_iterator placement_arg_end()

std::optional< const Expr * > getArraySize() const

This might return std::nullopt even if isArray() returns true, since there might not be an array size...

const_arg_iterator placement_arg_begin() const

std::optional< Expr * > getArraySize()

This might return std::nullopt even if isArray() returns true, since there might not be an array size...

SourceLocation getEndLoc() const

CXXNewInitializationStyle getInitializationStyle() const

The kind of initializer this new-expression has.

Expr * getPlacementArg(unsigned I)

bool hasInitializer() const

Whether this new-expression has any initializer at all.

const Expr * getInitializer() const

bool shouldNullCheckAllocation() const

True if the allocation result needs to be null-checked.

const Expr * getPlacementArg(unsigned I) const

static bool classof(const Stmt *T)

SourceLocation getBeginLoc() const

void setOperatorDelete(FunctionDecl *D)

bool passAlignment() const

Indicates whether the required alignment should be implicitly passed to the allocation function.

FunctionDecl * getOperatorDelete() const

unsigned getNumPlacementArgs() const

const CXXConstructExpr * getConstructExpr() const

Returns the CXXConstructExpr from this new-expression, or null.

llvm::iterator_range< const_arg_iterator > placement_arguments() const

const_arg_iterator placement_arg_end() const

TypeSourceInfo * getAllocatedTypeSourceInfo() const

SourceRange getSourceRange() const

SourceRange getTypeIdParens() const

Expr ** getPlacementArgs()

bool isParenTypeId() const

raw_arg_iterator raw_arg_end()

bool doesUsualArrayDeleteWantSize() const

Answers whether the usual array deallocation function for the allocated type expects the size of the ...

const_arg_iterator raw_arg_end() const

const_child_range children() const

arg_iterator placement_arg_begin()

raw_arg_iterator raw_arg_begin()

void setOperatorNew(FunctionDecl *D)

FunctionDecl * getOperatorNew() const

const_arg_iterator raw_arg_begin() const

Expr * getInitializer()

The initializer of this new-expression.

Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).

static bool classof(const Stmt *T)

const_child_range children() const

SourceLocation getEndLoc() const

Expr * getOperand() const

SourceLocation getBeginLoc() const

SourceRange getSourceRange() const

CXXNoexceptExpr(EmptyShell Empty)

CXXNoexceptExpr(QualType Ty, Expr *Operand, CanThrowResult Val, SourceLocation Keyword, SourceLocation RParen)

The null pointer literal (C++11 [lex.nullptr])

const_child_range children() const

CXXNullPtrLiteralExpr(EmptyShell Empty)

void setLocation(SourceLocation L)

SourceLocation getEndLoc() const

static bool classof(const Stmt *T)

CXXNullPtrLiteralExpr(QualType Ty, SourceLocation Loc)

SourceLocation getLocation() const

SourceLocation getBeginLoc() const

A call to an overloaded operator written using operator syntax.

bool isInfixBinaryOp() const

Is this written as an infix binary operator?

bool isAssignmentOp() const

static bool classof(const Stmt *T)

SourceLocation getOperatorLoc() const

Returns the location of the operator symbol in the expression.

SourceLocation getEndLoc() const

SourceLocation getExprLoc() const LLVM_READONLY

OverloadedOperatorKind getOperator() const

Returns the kind of overloaded operator that this expression refers to.

static CXXOperatorCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)

SourceLocation getBeginLoc() const

static bool isComparisonOp(OverloadedOperatorKind Opc)

static bool isAssignmentOp(OverloadedOperatorKind Opc)

bool isComparisonOp() const

SourceRange getSourceRange() const

Represents a list-initialization with parenthesis.

SourceRange getSourceRange() const LLVM_READONLY

const_child_range children() const

void setInitializedFieldInUnion(FieldDecl *FD)

SourceLocation getEndLoc() const LLVM_READONLY

const ArrayRef< Expr * > getUserSpecifiedInitExprs() const

SourceLocation getInitLoc() const LLVM_READONLY

ArrayRef< Expr * > getUserSpecifiedInitExprs()

ArrayRef< Expr * > getInitExprs()

CXXParenListInitExpr(EmptyShell Empty, unsigned NumExprs)

friend class TrailingObjects

static CXXParenListInitExpr * CreateEmpty(ASTContext &C, unsigned numExprs, EmptyShell Empty)

const FieldDecl * getInitializedFieldInUnion() const

SourceLocation getBeginLoc() const LLVM_READONLY

static bool classof(const Stmt *T)

const ArrayRef< Expr * > getInitExprs() const

FieldDecl * getInitializedFieldInUnion()

const Expr * getArrayFiller() const

void setArrayFiller(Expr *E)

Represents a C++ pseudo-destructor (C++ [expr.pseudo]).

TypeSourceInfo * getDestroyedTypeInfo() const

Retrieve the source location information for the type being destroyed.

SourceLocation getBeginLoc() const LLVM_READONLY

bool isArrow() const

Determine whether this pseudo-destructor expression was written using an '->' (otherwise,...

TypeSourceInfo * getScopeTypeInfo() const

Retrieve the scope type in a qualified pseudo-destructor expression.

static bool classof(const Stmt *T)

SourceLocation getTildeLoc() const

Retrieve the location of the '~'.

NestedNameSpecifierLoc getQualifierLoc() const

Retrieves the nested-name-specifier that qualifies the type name, with source-location information.

SourceLocation getEndLoc() const LLVM_READONLY

SourceLocation getDestroyedTypeLoc() const

Retrieve the starting location of the type being destroyed.

SourceLocation getColonColonLoc() const

Retrieve the location of the '::' in a qualified pseudo-destructor expression.

const_child_range children() const

QualType getDestroyedType() const

Retrieve the type being destroyed.

SourceLocation getOperatorLoc() const

Retrieve the location of the '.' or '->' operator.

NestedNameSpecifier * getQualifier() const

If the member name was qualified, retrieves the nested-name-specifier that precedes the member name.

void setDestroyedType(IdentifierInfo *II, SourceLocation Loc)

Set the name of destroyed type for a dependent pseudo-destructor expression.

const IdentifierInfo * getDestroyedTypeIdentifier() const

In a dependent pseudo-destructor expression for which we do not have full type information on the des...

void setDestroyedType(TypeSourceInfo *Info)

Set the destroyed type.

bool hasQualifier() const

Determines whether this member expression actually had a C++ nested-name-specifier prior to the name ...

CXXPseudoDestructorExpr(EmptyShell Shell)

Represents a C++ struct/union/class.

A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).

static bool classof(const Stmt *T)

static CXXReinterpretCastExpr * CreateEmpty(const ASTContext &Context, unsigned pathSize)

A rewritten comparison expression that was originally written using operator syntax.

Expr * getSemanticForm()

Get an equivalent semantic form for this expression.

SourceLocation getOperatorLoc() const LLVM_READONLY

BinaryOperatorKind getOperator() const

bool isComparisonOp() const

SourceLocation getEndLoc() const LLVM_READONLY

SourceRange getSourceRange() const LLVM_READONLY

bool isReversed() const

Determine whether this expression was rewritten in reverse form.

CXXRewrittenBinaryOperator(Expr *SemanticForm, bool IsReversed)

const Expr * getLHS() const

StringRef getOpcodeStr() const

CXXRewrittenBinaryOperator(EmptyShell Empty)

SourceLocation getBeginLoc() const LLVM_READONLY

Compute the begin and end locations from the decomposed form.

SourceLocation getExprLoc() const LLVM_READONLY

const Expr * getRHS() const

static bool classof(const Stmt *T)

BinaryOperatorKind getOpcode() const

bool isAssignmentOp() const

static StringRef getOpcodeStr(BinaryOperatorKind Op)

DecomposedForm getDecomposedForm() const LLVM_READONLY

Decompose this operator into its syntactic form.

const Expr * getSemanticForm() const

An expression "T()" which creates an rvalue of a non-class type T.

CXXScalarValueInitExpr(EmptyShell Shell)

const_child_range children() const

TypeSourceInfo * getTypeSourceInfo() const

SourceLocation getBeginLoc() const LLVM_READONLY

static bool classof(const Stmt *T)

SourceLocation getEndLoc() const

SourceLocation getRParenLoc() const

CXXScalarValueInitExpr(QualType Type, TypeSourceInfo *TypeInfo, SourceLocation RParenLoc)

Create an explicitly-written scalar-value initialization expression.

A C++ static_cast expression (C++ [expr.static.cast]).

static CXXStaticCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool hasFPFeatures)

static bool classof(const Stmt *T)

Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...

SourceRange getSourceRange() const LLVM_READONLY

Retrieve the source range of the expression.

const_child_range children() const

CXXStdInitializerListExpr(QualType Ty, Expr *SubExpr)

SourceLocation getEndLoc() const LLVM_READONLY

SourceLocation getBeginLoc() const LLVM_READONLY

const Expr * getSubExpr() const

static bool classof(const Stmt *S)

Represents a C++ functional cast expression that builds a temporary object.

TypeSourceInfo * getTypeSourceInfo() const

SourceLocation getEndLoc() const LLVM_READONLY

static CXXTemporaryObjectExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs)

static bool classof(const Stmt *T)

SourceLocation getBeginLoc() const LLVM_READONLY

Represents a C++ temporary.

const CXXDestructorDecl * getDestructor() const

void setDestructor(const CXXDestructorDecl *Dtor)

Represents the this expression in C++.

void setCapturedByCopyInLambdaWithExplicitObjectParameter(bool Set)

SourceLocation getBeginLoc() const

void setLocation(SourceLocation L)

SourceLocation getEndLoc() const

bool isCapturedByCopyInLambdaWithExplicitObjectParameter() const

static CXXThisExpr * CreateEmpty(const ASTContext &Ctx)

static bool classof(const Stmt *T)

const_child_range children() const

SourceLocation getLocation() const

A C++ throw-expression (C++ [except.throw]).

CXXThrowExpr(EmptyShell Empty)

const_child_range children() const

SourceLocation getEndLoc() const LLVM_READONLY

const Expr * getSubExpr() const

CXXThrowExpr(Expr *Operand, QualType Ty, SourceLocation Loc, bool IsThrownVariableInScope)

SourceLocation getThrowLoc() const

SourceLocation getBeginLoc() const

bool isThrownVariableInScope() const

Determines whether the variable thrown by this expression (if any!) is within the innermost try block...

static bool classof(const Stmt *T)

A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...

CXXTypeidExpr(QualType Ty, Expr *Operand, SourceRange R)

static bool classof(const Stmt *T)

CXXTypeidExpr(QualType Ty, TypeSourceInfo *Operand, SourceRange R)

bool isTypeOperand() const

QualType getTypeOperand(const ASTContext &Context) const

Retrieves the type operand of this typeid() expression after various required adjustments (removing r...

TypeSourceInfo * getTypeOperandSourceInfo() const

Retrieve source information for the type operand.

SourceLocation getBeginLoc() const LLVM_READONLY

Expr * getExprOperand() const

SourceRange getSourceRange() const LLVM_READONLY

bool isMostDerived(const ASTContext &Context) const

Best-effort check if the expression operand refers to a most derived object.

void setSourceRange(SourceRange R)

const_child_range children() const

SourceLocation getEndLoc() const LLVM_READONLY

bool isPotentiallyEvaluated() const

Determine whether this typeid has a type operand which is potentially evaluated, per C++11 [expr....

CXXTypeidExpr(EmptyShell Empty, bool isExpr)

bool hasNullCheck() const

Whether this is of a form like "typeid(*ptr)" that can throw a std::bad_typeid if a pointer is a null...

Describes an explicit type conversion that uses functional notion but could not be resolved because o...

const_child_range children() const

const Expr *const * const_arg_iterator

void setRParenLoc(SourceLocation L)

void setArg(unsigned I, Expr *E)

SourceLocation getLParenLoc() const

Retrieve the location of the left parentheses ('(') that precedes the argument list.

bool isListInitialization() const

Determine whether this expression models list-initialization.

TypeSourceInfo * getTypeSourceInfo() const

Retrieve the type source information for the type being constructed.

const_arg_range arguments() const

QualType getTypeAsWritten() const

Retrieve the type that is being constructed, as specified in the source code.

const_arg_iterator arg_end() const

SourceLocation getEndLoc() const LLVM_READONLY

llvm::iterator_range< const_arg_iterator > const_arg_range

void setLParenLoc(SourceLocation L)

const Expr * getArg(unsigned I) const

Expr * getArg(unsigned I)

SourceLocation getRParenLoc() const

Retrieve the location of the right parentheses (')') that follows the argument list.

SourceLocation getBeginLoc() const LLVM_READONLY

unsigned getNumArgs() const

Retrieve the number of arguments.

static bool classof(const Stmt *T)

static CXXUnresolvedConstructExpr * CreateEmpty(const ASTContext &Context, unsigned NumArgs)

llvm::iterator_range< arg_iterator > arg_range

const_arg_iterator arg_begin() const

A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...

SourceLocation getBeginLoc() const LLVM_READONLY

static bool classof(const Stmt *T)

const_child_range children() const

Expr * getExprOperand() const

CXXUuidofExpr(QualType Ty, TypeSourceInfo *Operand, MSGuidDecl *Guid, SourceRange R)

MSGuidDecl * getGuidDecl() const

QualType getTypeOperand(ASTContext &Context) const

Retrieves the type operand of this __uuidof() expression after various required adjustments (removing...

bool isTypeOperand() const

CXXUuidofExpr(QualType Ty, Expr *Operand, MSGuidDecl *Guid, SourceRange R)

TypeSourceInfo * getTypeOperandSourceInfo() const

Retrieve source information for the type operand.

void setSourceRange(SourceRange R)

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation getEndLoc() const LLVM_READONLY

CXXUuidofExpr(EmptyShell Empty, bool isExpr)

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

Expr * getArg(unsigned Arg)

getArg - Return the specified argument.

static constexpr ADLCallKind NotADL

SourceLocation getBeginLoc() const LLVM_READONLY

SourceLocation getRParenLoc() const

static constexpr ADLCallKind UsesADL

Stmt * getPreArg(unsigned I)

CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...

FPOptionsOverride * getTrailingFPFeatures()

Return a pointer to the trailing FPOptions.

unsigned path_size() const

bool hasStoredFPFeatures() const

Represents a 'co_await' expression.

void setIsImplicit(bool value=true)

static bool classof(const Stmt *T)

CoawaitExpr(EmptyShell Empty)

CoawaitExpr(SourceLocation CoawaitLoc, QualType Ty, Expr *Operand, Expr *Common, bool IsImplicit=false)

CoawaitExpr(SourceLocation CoawaitLoc, Expr *Operand, Expr *Common, Expr *Ready, Expr *Suspend, Expr *Resume, OpaqueValueExpr *OpaqueValue, bool IsImplicit=false)

CompoundStmt - This represents a group of statements like { stmt stmt }.

ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...

llvm::APSInt getResultAsAPSInt() const

Represents an expression that might suspend coroutine execution; either a co_await or co_yield expres...

SuspendReturnType getSuspendReturnType() const

CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, Expr *Operand, Expr *Common, Expr *Ready, Expr *Suspend, Expr *Resume, OpaqueValueExpr *OpaqueValue)

Expr * getReadyExpr() const

SourceLocation getKeywordLoc() const

Expr * getResumeExpr() const

SourceLocation getBeginLoc() const LLVM_READONLY

Expr * getSuspendExpr() const

CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, QualType Ty, Expr *Operand, Expr *Common)

static bool classof(const Stmt *T)

OpaqueValueExpr * getOpaqueValue() const

getOpaqueValue - Return the opaque value placeholder.

Expr * getCommonExpr() const

Expr * getOperand() const

const_child_range children() const

CoroutineSuspendExpr(StmtClass SC, EmptyShell Empty)

SourceLocation getEndLoc() const LLVM_READONLY

Represents a 'co_yield' expression.

CoyieldExpr(EmptyShell Empty)

CoyieldExpr(SourceLocation CoyieldLoc, Expr *Operand, Expr *Common, Expr *Ready, Expr *Suspend, Expr *Resume, OpaqueValueExpr *OpaqueValue)

static bool classof(const Stmt *T)

CoyieldExpr(SourceLocation CoyieldLoc, QualType Ty, Expr *Operand, Expr *Common)

A POD class for pairing a NamedDecl* with an access specifier.

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

Decl - This represents one declaration (or definition), e.g.

The name of a declaration.

Represents a 'co_await' expression while the type of the promise is dependent.

static bool classof(const Stmt *T)

DependentCoawaitExpr(EmptyShell Empty)

SourceLocation getEndLoc() const LLVM_READONLY

const_child_range children() const

Expr * getOperand() const

SourceLocation getBeginLoc() const LLVM_READONLY

DependentCoawaitExpr(SourceLocation KeywordLoc, QualType Ty, Expr *Op, UnresolvedLookupExpr *OpCoawait)

SourceLocation getKeywordLoc() const

UnresolvedLookupExpr * getOperatorCoawaitLookup() const

A qualified reference to a name whose declaration cannot yet be resolved.

SourceLocation getRAngleLoc() const

Retrieve the location of the right angle bracket ending the explicit template argument list following...

static DependentScopeDeclRefExpr * CreateEmpty(const ASTContext &Context, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)

NestedNameSpecifierLoc getQualifierLoc() const

Retrieve the nested-name-specifier that qualifies the name, with source location information.

SourceLocation getLocation() const

Retrieve the location of the name within the expression.

SourceLocation getLAngleLoc() const

Retrieve the location of the left angle bracket starting the explicit template argument list followin...

ArrayRef< TemplateArgumentLoc > template_arguments() const

const_child_range children() const

static bool classof(const Stmt *T)

bool hasExplicitTemplateArgs() const

Determines whether this lookup had explicit template arguments.

SourceLocation getEndLoc() const LLVM_READONLY

SourceLocation getBeginLoc() const LLVM_READONLY

Note: getBeginLoc() is the start of the whole DependentScopeDeclRefExpr, and differs from getLocation...

NestedNameSpecifier * getQualifier() const

Retrieve the nested-name-specifier that qualifies this declaration.

SourceLocation getTemplateKeywordLoc() const

Retrieve the location of the template keyword preceding this name, if any.

bool hasTemplateKeyword() const

Determines whether the name was preceded by the template keyword.

unsigned getNumTemplateArgs() const

DeclarationName getDeclName() const

Retrieve the name that this expression refers to.

TemplateArgumentLoc const * getTemplateArgs() const

void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const

Copies the template arguments (if present) into the given structure.

const DeclarationNameInfo & getNameInfo() const

Retrieve the name that this expression refers to.

ExplicitCastExpr - An explicit cast written in the source code.

Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...

bool cleanupsHaveSideEffects() const

static bool classof(const Stmt *T)

CleanupObject getObject(unsigned i) const

ArrayRef< CleanupObject > getObjects() const

unsigned getNumObjects() const

SourceLocation getEndLoc() const LLVM_READONLY

const_child_range children() const

llvm::PointerUnion< BlockDecl *, CompoundLiteralExpr * > CleanupObject

The type of objects that are kept in the cleanup.

SourceLocation getBeginLoc() const LLVM_READONLY

This represents one expression.

bool isImplicitCXXThis() const

Whether this expression is an implicit reference to 'this' in C++.

bool isValueDependent() const

Determines whether the value of this expression depends on.

ExprValueKind getValueKind() const

getValueKind - The value kind that this expression produces.

bool isTypeDependent() const

Determines whether the type of this expression depends on.

bool containsUnexpandedParameterPack() const

Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates).

bool isLValue() const

isLValue - True if this expression is an "l-value" according to the rules of the current language.

ExprObjectKind getObjectKind() const

getObjectKind - The object kind that this expression produces.

bool isInstantiationDependent() const

Whether this expression is instantiation-dependent, meaning that it depends in some way on.

void setValueKind(ExprValueKind Cat)

setValueKind - Set the value kind produced by this expression.

SourceLocation getExprLoc() const LLVM_READONLY

getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...

static ExprValueKind getValueKindForType(QualType T)

getValueKindForType - Given a formal return or parameter type, give its value kind.

void setDependence(ExprDependence Deps)

Each concrete expr subclass is expected to compute its dependence and call this in the constructor.

An expression trait intrinsic.

ExpressionTraitExpr(SourceLocation loc, ExpressionTrait et, Expr *queried, bool value, SourceLocation rparen, QualType resultType)

static bool classof(const Stmt *T)

ExpressionTraitExpr(EmptyShell Empty)

SourceLocation getBeginLoc() const LLVM_READONLY

Expr * getQueriedExpression() const

ExpressionTrait getTrait() const

SourceLocation getEndLoc() const LLVM_READONLY

const_child_range children() const

Represents difference between two FPOptions values.

bool requiresTrailingStorage() const

Represents a member of a struct/union/class.

FullExpr - Represents a "full-expression" node.

Represents a function declaration or definition.

Represents a reference to a function parameter pack or init-capture pack that has been substituted bu...

VarDecl * getParameterPack() const

Get the parameter pack which this expression refers to.

const_child_range children() const

SourceLocation getEndLoc() const LLVM_READONLY

SourceLocation getBeginLoc() const LLVM_READONLY

VarDecl * getExpansion(unsigned I) const

Get an expansion of the parameter pack by index.

VarDecl *const * iterator

Iterators over the parameters which the parameter pack expanded into.

unsigned getNumExpansions() const

Get the number of parameters in this parameter pack.

static bool classof(const Stmt *T)

SourceLocation getParameterPackLocation() const

Get the location of the parameter pack.

static FunctionParmPackExpr * CreateEmpty(const ASTContext &Context, unsigned NumParams)

Declaration of a template function.

One of these records is kept for each identifier that is lexed.

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...

llvm::iterator_range< const_capture_init_iterator > capture_inits() const

Retrieve the initialization expressions for this lambda's captures.

capture_iterator capture_begin() const

Retrieve an iterator pointing to the first lambda capture.

static LambdaExpr * CreateDeserialized(const ASTContext &C, unsigned NumCaptures)

Construct a new lambda expression that will be deserialized from an external source.

SourceLocation getEndLoc() const LLVM_READONLY

Stmt * getBody() const

Retrieve the body of the lambda.

bool hasExplicitParameters() const

Determine whether this lambda has an explicit parameter list vs.

const_capture_init_iterator capture_init_begin() const

Retrieve the first initialization argument for this lambda expression (which initializes the first ca...

bool isGenericLambda() const

Whether this is a generic lambda.

SourceRange getIntroducerRange() const

Retrieve the source range covering the lambda introducer, which contains the explicit capture list su...

bool isMutable() const

Determine whether the lambda is mutable, meaning that any captures values can be modified.

capture_iterator implicit_capture_end() const

Retrieve an iterator pointing past the end of the sequence of implicit lambda captures.

CompoundStmt * getCompoundStmtBody()

unsigned capture_size() const

Determine the number of captures in this lambda.

capture_range explicit_captures() const

Retrieve this lambda's explicit captures.

bool isInitCapture(const LambdaCapture *Capture) const

Determine whether one of this lambda's captures is an init-capture.

const_capture_init_iterator capture_init_end() const

Retrieve the iterator pointing one past the last initialization argument for this lambda expression.

CXXMethodDecl * getCallOperator() const

Retrieve the function call operator associated with this lambda expression.

const CompoundStmt * getCompoundStmtBody() const

Retrieve the CompoundStmt representing the body of the lambda.

bool hasExplicitResultType() const

Whether this lambda had its result type explicitly specified.

capture_range implicit_captures() const

Retrieve this lambda's implicit captures.

TemplateParameterList * getTemplateParameterList() const

If this is a generic lambda expression, retrieve the template parameter list associated with it,...

ArrayRef< NamedDecl * > getExplicitTemplateParameters() const

Get the template parameters were explicitly specified (as opposed to being invented by use of an auto...

capture_iterator implicit_capture_begin() const

Retrieve an iterator pointing to the first implicit lambda capture.

capture_iterator explicit_capture_end() const

Retrieve an iterator pointing past the end of the sequence of explicit lambda captures.

capture_iterator capture_end() const

Retrieve an iterator pointing past the end of the sequence of lambda captures.

llvm::iterator_range< capture_iterator > capture_range

An iterator over a range of lambda captures.

SourceLocation getCaptureDefaultLoc() const

Retrieve the location of this lambda's capture-default, if any.

capture_init_iterator capture_init_end()

Retrieve the iterator pointing one past the last initialization argument for this lambda expression.

const LambdaCapture * capture_iterator

An iterator that walks over the captures of the lambda, both implicit and explicit.

Expr *const * const_capture_init_iterator

Const iterator that walks over the capture initialization arguments.

Expr * getTrailingRequiresClause() const

Get the trailing requires clause, if any.

capture_iterator explicit_capture_begin() const

Retrieve an iterator pointing to the first explicit lambda capture.

llvm::iterator_range< capture_init_iterator > capture_inits()

Retrieve the initialization expressions for this lambda's captures.

child_range children()

Includes the captures and the body of the lambda.

FunctionTemplateDecl * getDependentCallOperator() const

Retrieve the function template call operator associated with this lambda expression.

SourceLocation getBeginLoc() const LLVM_READONLY

static bool classof(const Stmt *T)

capture_range captures() const

Retrieve this lambda's captures.

capture_init_iterator capture_init_begin()

Retrieve the first initialization argument for this lambda expression (which initializes the first ca...

LambdaCaptureDefault getCaptureDefault() const

Determine the default capture kind for this lambda.

CXXRecordDecl * getLambdaClass() const

Retrieve the class that corresponds to the lambda.

Implicit declaration of a temporary that was materialized by a MaterializeTemporaryExpr and lifetime-...

An instance of this class represents the declaration of a property member.

A member reference to an MSPropertyDecl.

const_child_range children() const

NestedNameSpecifierLoc getQualifierLoc() const

MSPropertyRefExpr(EmptyShell Empty)

bool isImplicitAccess() const

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation getEndLoc() const

MSPropertyDecl * getPropertyDecl() const

Expr * getBaseExpr() const

MSPropertyRefExpr(Expr *baseExpr, MSPropertyDecl *decl, bool isArrow, QualType ty, ExprValueKind VK, NestedNameSpecifierLoc qualifierLoc, SourceLocation nameLoc)

static bool classof(const Stmt *T)

SourceLocation getBeginLoc() const

SourceLocation getMemberLoc() const

MS property subscript expression.

static bool classof(const Stmt *T)

const Expr * getIdx() const

void setRBracketLoc(SourceLocation L)

SourceLocation getEndLoc() const LLVM_READONLY

MSPropertySubscriptExpr(Expr *Base, Expr *Idx, QualType Ty, ExprValueKind VK, ExprObjectKind OK, SourceLocation RBracketLoc)

SourceLocation getExprLoc() const LLVM_READONLY

const_child_range children() const

MSPropertySubscriptExpr(EmptyShell Shell)

Create an empty array subscript expression.

const Expr * getBase() const

SourceLocation getBeginLoc() const LLVM_READONLY

SourceLocation getRBracketLoc() const

Represents a prvalue temporary that is written into memory so that a reference can bind to it.

const LifetimeExtendedTemporaryDecl * getLifetimeExtendedTemporaryDecl() const

StorageDuration getStorageDuration() const

Retrieve the storage duration for the materialized temporary.

Expr * getSubExpr() const

Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.

APValue * getOrCreateValue(bool MayCreate) const

Get the storage for the constant value of a materialized temporary of static storage duration.

bool isBoundToLvalueReference() const

Determine whether this materialized temporary is bound to an lvalue reference; otherwise,...

ValueDecl * getExtendingDecl()

Get the declaration which triggered the lifetime-extension of this temporary, if any.

bool isUsableInConstantExpressions(const ASTContext &Context) const

Determine whether this temporary object is usable in constant expressions, as specified in C++20 [exp...

MaterializeTemporaryExpr(EmptyShell Empty)

LifetimeExtendedTemporaryDecl * getLifetimeExtendedTemporaryDecl()

void setExtendingDecl(ValueDecl *ExtendedBy, unsigned ManglingNumber)

SourceLocation getEndLoc() const LLVM_READONLY

const ValueDecl * getExtendingDecl() const

static bool classof(const Stmt *T)

SourceLocation getBeginLoc() const LLVM_READONLY

unsigned getManglingNumber() const

const_child_range children() const

This represents a decl that may have a name.

A C++ nested-name-specifier augmented with source location information.

SourceLocation getBeginLoc() const

Retrieve the location of the beginning of this nested-name-specifier.

bool hasQualifier() const

Evaluates true when this nested-name-specifier location is non-empty.

NestedNameSpecifier * getNestedNameSpecifier() const

Retrieve the nested-name-specifier to which this instance refers.

Represents a C++ nested name specifier, such as "\::std::vector<int>::".

NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.

OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.

A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.

static bool classof(const Stmt *T)

NestedNameSpecifier * getQualifier() const

Fetches the nested-name qualifier, if one was given.

ASTTemplateKWAndArgsInfo * getTrailingASTTemplateKWAndArgsInfo()

Return the optional template keyword and arguments info.

bool hasExplicitTemplateArgs() const

Determines whether this expression had explicit template arguments.

static FindResult find(Expr *E)

Finds the overloaded expression in the given expression E of OverloadTy.

SourceLocation getLAngleLoc() const

Retrieve the location of the left angle bracket starting the explicit template argument list followin...

const DeclarationNameInfo & getNameInfo() const

Gets the full name info.

const CXXRecordDecl * getNamingClass() const

SourceLocation getNameLoc() const

Gets the location of the name.

decls_iterator decls_begin() const

CXXRecordDecl * getNamingClass()

Gets the naming class of this lookup, if any.

unsigned getNumDecls() const

Gets the number of declarations in the unresolved set.

SourceLocation getTemplateKeywordLoc() const

Retrieve the location of the template keyword preceding this name, if any.

NestedNameSpecifierLoc getQualifierLoc() const

Fetches the nested-name qualifier with source-location information, if one was given.

const ASTTemplateKWAndArgsInfo * getTrailingASTTemplateKWAndArgsInfo() const

TemplateArgumentLoc const * getTemplateArgs() const

llvm::iterator_range< decls_iterator > decls() const

void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const

Copies the template arguments into the given structure.

TemplateArgumentLoc * getTrailingTemplateArgumentLoc()

Return the optional template arguments.

DeclAccessPair * getTrailingResults()

Return the results. Defined after UnresolvedMemberExpr.

const DeclAccessPair * getTrailingResults() const

bool hasTemplateKWAndArgsInfo() const

decls_iterator decls_end() const

unsigned getNumTemplateArgs() const

const TemplateArgumentLoc * getTrailingTemplateArgumentLoc() const

DeclarationName getName() const

Gets the name looked up.

SourceLocation getRAngleLoc() const

Retrieve the location of the right angle bracket ending the explicit template argument list following...

bool hasTemplateKeyword() const

Determines whether the name was preceded by the template keyword.

ArrayRef< TemplateArgumentLoc > template_arguments() const

Represents a C++11 pack expansion that produces a sequence of expressions.

Expr * getPattern()

Retrieve the pattern of the pack expansion.

const Expr * getPattern() const

Retrieve the pattern of the pack expansion.

PackExpansionExpr(QualType T, Expr *Pattern, SourceLocation EllipsisLoc, std::optional< unsigned > NumExpansions)

SourceLocation getBeginLoc() const LLVM_READONLY

std::optional< unsigned > getNumExpansions() const

Determine the number of expansions that will be produced when this pack expansion is instantiated,...

SourceLocation getEndLoc() const LLVM_READONLY

const_child_range children() const

SourceLocation getEllipsisLoc() const

Retrieve the location of the ellipsis that describes this pack expansion.

PackExpansionExpr(EmptyShell Empty)

static bool classof(const Stmt *T)

NamedDecl * getPackDecl() const

static PackIndexingExpr * CreateDeserialized(ASTContext &Context, unsigned NumTransformedExprs)

SourceLocation getEllipsisLoc() const

Determine the location of the 'sizeof' keyword.

Expr * getIndexExpr() const

ArrayRef< Expr * > getExpressions() const

Return the trailing expressions, regardless of the expansion.

SourceLocation getEndLoc() const LLVM_READONLY

SourceLocation getPackLoc() const

Determine the location of the parameter pack.

SourceLocation getRSquareLoc() const

Determine the location of the right parenthesis.

std::optional< unsigned > getSelectedIndex() const

bool expandsToEmptyPack() const

Determine if the expression was expanded to empty.

Expr * getPackIdExpression() const

Expr * getSelectedExpr() const

static bool classof(const Stmt *T)

bool isFullySubstituted() const

const_child_range children() const

SourceLocation getBeginLoc() const LLVM_READONLY

Represents a parameter to a function.

PointerType - C99 6.7.5.1 - Pointer Declarators.

Stores the type being destroyed by a pseudo-destructor expression.

PseudoDestructorTypeStorage(const IdentifierInfo *II, SourceLocation Loc)

const IdentifierInfo * getIdentifier() const

PseudoDestructorTypeStorage()=default

SourceLocation getLocation() const

TypeSourceInfo * getTypeSourceInfo() const

A (possibly-)qualified type.

llvm::MutableArrayRef< Expr * > getExprs()

static ResolvedUnexpandedPackExpr * CreateDeserialized(ASTContext &C, unsigned NumExprs)

llvm::ArrayRef< Expr * > getExprs() const

static ResolvedUnexpandedPackExpr * getFromDecl(Decl *)

SourceLocation getBeginLoc() const LLVM_READONLY

SourceLocation getEndLoc() const LLVM_READONLY

Expr * getExpansion(unsigned Idx)

unsigned getNumExprs() const

Expr * getExpansion(unsigned Idx) const

static bool classof(const Stmt *T)

Represents an expression that computes the length of a parameter pack.

SourceLocation getPackLoc() const

Determine the location of the parameter pack.

static bool classof(const Stmt *T)

SourceLocation getEndLoc() const LLVM_READONLY

static SizeOfPackExpr * CreateDeserialized(ASTContext &Context, unsigned NumPartialArgs)

bool isPartiallySubstituted() const

Determine whether this represents a partially-substituted sizeof... expression, such as is produced f...

const_child_range children() const

SourceLocation getBeginLoc() const LLVM_READONLY

ArrayRef< TemplateArgument > getPartialArguments() const

Get.

SourceLocation getOperatorLoc() const

Determine the location of the 'sizeof' keyword.

SourceLocation getRParenLoc() const

Determine the location of the right parenthesis.

NamedDecl * getPack() const

Retrieve the parameter pack.

unsigned getPackLength() const

Retrieve the length of the parameter pack.

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.

Stmt - This represents one statement.

SourceLocation getEndLoc() const LLVM_READONLY

CXXUnresolvedConstructExprBitfields CXXUnresolvedConstructExprBits

LambdaExprBitfields LambdaExprBits

UnresolvedLookupExprBitfields UnresolvedLookupExprBits

SubstNonTypeTemplateParmExprBitfields SubstNonTypeTemplateParmExprBits

CXXNoexceptExprBitfields CXXNoexceptExprBits

StmtIterator child_iterator

Child Iterators: All subclasses must implement 'children' to permit easy iteration over the substatem...

CXXRewrittenBinaryOperatorBitfields CXXRewrittenBinaryOperatorBits

ExprWithCleanupsBitfields ExprWithCleanupsBits

StmtClass getStmtClass() const

CXXScalarValueInitExprBitfields CXXScalarValueInitExprBits

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...

OverloadExprBitfields OverloadExprBits

CXXConstructExprBitfields CXXConstructExprBits

CXXDependentScopeMemberExprBitfields CXXDependentScopeMemberExprBits

ConstCastIterator< Expr > ConstExprIterator

TypeTraitExprBitfields TypeTraitExprBits

CXXNewExprBitfields CXXNewExprBits

CXXNullPtrLiteralExprBitfields CXXNullPtrLiteralExprBits

CoawaitExprBitfields CoawaitBits

llvm::iterator_range< child_iterator > child_range

CXXThrowExprBitfields CXXThrowExprBits

ConstStmtIterator const_child_iterator

CXXBoolLiteralExprBitfields CXXBoolLiteralExprBits

CXXOperatorCallExprBitfields CXXOperatorCallExprBits

CXXDefaultInitExprBitfields CXXDefaultInitExprBits

DependentScopeDeclRefExprBitfields DependentScopeDeclRefExprBits

SourceLocation getBeginLoc() const LLVM_READONLY

UnresolvedMemberExprBitfields UnresolvedMemberExprBits

llvm::iterator_range< const_child_iterator > const_child_range

CXXDeleteExprBitfields CXXDeleteExprBits

CXXDefaultArgExprBitfields CXXDefaultArgExprBits

CXXThisExprBitfields CXXThisExprBits

CastIterator< Expr > ExprIterator

Represents a reference to a non-type template parameter that has been substituted with a template arg...

std::optional< unsigned > getPackIndex() const

Decl * getAssociatedDecl() const

A template-like entity which owns the whole pattern being substituted.

SourceLocation getEndLoc() const

QualType getParameterType(const ASTContext &Ctx) const

Determine the substituted type of the template parameter.

const_child_range children() const

bool isReferenceParameter() const

unsigned getIndex() const

Returns the index of the replaced parameter in the associated declaration.

SourceLocation getNameLoc() const

NonTypeTemplateParmDecl * getParameter() const

SourceLocation getBeginLoc() const

SubstNonTypeTemplateParmExpr(QualType Ty, ExprValueKind ValueKind, SourceLocation Loc, Expr *Replacement, Decl *AssociatedDecl, unsigned Index, std::optional< unsigned > PackIndex, bool RefParam)

Expr * getReplacement() const

static bool classof(const Stmt *s)

Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...

SourceLocation getBeginLoc() const LLVM_READONLY

TemplateArgument getArgumentPack() const

Retrieve the template argument pack containing the substituted template arguments.

SourceLocation getParameterPackLocation() const

Retrieve the location of the parameter pack name.

const_child_range children() const

NonTypeTemplateParmDecl * getParameterPack() const

Retrieve the non-type template parameter pack being substituted.

Decl * getAssociatedDecl() const

A template-like entity which owns the whole pattern being substituted.

static bool classof(const Stmt *T)

unsigned getIndex() const

Returns the index of the replaced parameter in the associated declaration.

SourceLocation getEndLoc() const LLVM_READONLY

A convenient class for passing around template argument information.

Location wrapper for a TemplateArgument.

Represents a template argument.

Stores a list of template parameters for a TemplateDecl and its derived classes.

A container of type source information.

QualType getType() const

Return the type wrapped by this type source info.

A type trait used in the implementation of various C++11 and Library TR1 trait templates.

ArrayRef< TypeSourceInfo * > getArgs() const

Retrieve the argument types.

static TypeTraitExpr * CreateDeserialized(const ASTContext &C, unsigned NumArgs)

SourceLocation getEndLoc() const LLVM_READONLY

TypeSourceInfo * getArg(unsigned I) const

Retrieve the Ith argument.

const_child_range children() const

unsigned getNumArgs() const

Determine the number of arguments to this type trait.

TypeTrait getTrait() const

Determine which type trait this expression uses.

SourceLocation getBeginLoc() const LLVM_READONLY

static bool classof(const Stmt *T)

The base class of the type hierarchy.

const T * castAs() const

Member-template castAs<specific type>.

bool isDependentType() const

Whether this type is a dependent type, meaning that its definition somehow depends on a template para...

A reference to a name which we were able to look up during parsing but could not resolve to a specifi...

SourceLocation getBeginLoc() const LLVM_READONLY

const CXXRecordDecl * getNamingClass() const

CXXRecordDecl * getNamingClass()

Gets the 'naming class' (in the sense of C++0x [class.access.base]p5) of the lookup.

SourceLocation getEndLoc() const LLVM_READONLY

static UnresolvedLookupExpr * CreateEmpty(const ASTContext &Context, unsigned NumResults, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)

static bool classof(const Stmt *T)

bool requiresADL() const

True if this declaration should be extended by argument-dependent lookup.

const_child_range children() const

Represents a C++ member access expression for which lookup produced a set of overloaded functions.

SourceLocation getEndLoc() const LLVM_READONLY

DeclarationName getMemberName() const

Retrieve the name of the member that this expression refers to.

QualType getBaseType() const

bool isArrow() const

Determine whether this member expression used the '->' operator; otherwise, it used the '.

SourceLocation getOperatorLoc() const

Retrieve the location of the '->' or '.' operator.

bool hasUnresolvedUsing() const

Determine whether the lookup results contain an unresolved using declaration.

const Expr * getBase() const

const CXXRecordDecl * getNamingClass() const

SourceLocation getExprLoc() const LLVM_READONLY

Return the preferred location (the member name) for the arrow when diagnosing a problem with this exp...

Expr * getBase()

Retrieve the base object of this member expressions, e.g., the x in x.m.

static bool classof(const Stmt *T)

CXXRecordDecl * getNamingClass()

Retrieve the naming class of this lookup.

bool isImplicitAccess() const

True if this is an implicit access, i.e., one in which the member being accessed was not written in t...

const DeclarationNameInfo & getMemberNameInfo() const

Retrieve the full name info for the member that this expression refers to.

SourceLocation getBeginLoc() const LLVM_READONLY

static UnresolvedMemberExpr * CreateEmpty(const ASTContext &Context, unsigned NumResults, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)

const_child_range children() const

SourceLocation getMemberLoc() const

Retrieve the location of the name of the member that this expression refers to.

UnresolvedSetIterator iterator

The iterator over UnresolvedSets.

A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit....

LiteralOperatorKind getLiteralOperatorKind() const

Returns the kind of literal operator invocation which this expression represents.

const Expr * getCookedLiteral() const

const IdentifierInfo * getUDSuffix() const

Returns the ud-suffix specified for this literal.

static UserDefinedLiteral * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPOptions, EmptyShell Empty)

SourceLocation getEndLoc() const

Expr * getCookedLiteral()

If this is not a raw user-defined literal, get the underlying cooked literal (representing the litera...

SourceLocation getBeginLoc() const

SourceLocation getUDSuffixLoc() const

Returns the location of a ud-suffix in the expression.

LiteralOperatorKind

The kind of literal operator which is invoked.

@ LOK_String

operator "" X (const CharT *, size_t)

@ LOK_Raw

Raw form: operator "" X (const char *)

@ LOK_Floating

operator "" X (long double)

@ LOK_Integer

operator "" X (unsigned long long)

@ LOK_Template

Raw form: operator "" X<cs...> ()

@ LOK_Character

operator "" X (CharT)

static bool classof(const Stmt *S)

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

Represents a variable declaration or definition.

const internal::VariadicAllOfMatcher< Decl > decl

Matches declarations.

const internal::VariadicDynCastAllOfMatcher< Stmt, CastExpr > castExpr

Matches any cast nodes of Clang's AST.

The JSON file list parser is used to communicate input to InstallAPI.

OverloadedOperatorKind

Enumeration specifying the different kinds of C++ overloaded operators.

ArrayTypeTrait

Names for the array type traits.

CanThrowResult

Possible results from evaluation of a noexcept expression.

ExprObjectKind

A further classification of the kind of object referenced by an l-value or x-value.

@ OK_Ordinary

An ordinary object is located at an address in memory.

ExprDependence computeDependence(FullExpr *E)

@ Create

'create' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...

StorageDuration

The storage duration for an object (per C++ [basic.stc]).

@ SD_FullExpression

Full-expression storage duration (for temporaries).

@ Result

The result type of a method or function.

CastKind

CastKind - The kind of operation required for a conversion.

LambdaCaptureDefault

The default, if any, capture method for a lambda expression.

ExprValueKind

The categorization of expression values, currently following the C++11 scheme.

@ VK_PRValue

A pr-value expression (in the C++11 taxonomy) produces a temporary value.

@ VK_LValue

An l-value expression is a reference to an object with independent storage.

const FunctionProtoType * T

@ None

The alignment was not explicit in code.

@ Class

The "class" keyword introduces the elaborated-type-specifier.

TypeTrait

Names for traits that operate specifically on types.

CXXNewInitializationStyle

@ Parens

New-expression has a C++98 paren-delimited initializer.

@ Braces

New-expression has a C++11 list-initializer.

Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".

SourceLocation LAngleLoc

The source location of the left angle bracket ('<').

void copyInto(const TemplateArgumentLoc *ArgArray, TemplateArgumentListInfo &List) const

unsigned NumTemplateArgs

The number of template arguments in TemplateArgs.

SourceLocation RAngleLoc

The source location of the right angle bracket ('>').

SourceLocation TemplateKWLoc

The source location of the template keyword; this is used as part of the representation of qualified ...

const Expr * RHS

The original right-hand side.

const Expr * InnerBinOp

The inner == or <=> operator expression.

BinaryOperatorKind Opcode

The original opcode, prior to rewriting.

const Expr * LHS

The original left-hand side.

DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...

SourceLocation getLoc() const

getLoc - Returns the main location of the declaration name.

DeclarationName getName() const

getName - Returns the embedded declaration name.

SourceLocation getBeginLoc() const

getBeginLoc - Retrieve the location of the first token.

SourceLocation getEndLoc() const LLVM_READONLY

bool IsAddressOfOperandWithParen

bool HasFormOfMemberPointer

Iterator for iterating over Stmt * arrays that contain only T *.

A placeholder type used to construct an empty shell of a type, that will be filled in later (e....

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4