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

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

clang: lib/AST/ExprCXX.cpp Source File

;

OO_Call:

OO_Subscript:

SkippedNot =

;

(

*NotEq = dyn_cast<UnaryOperator>(

)) {

assert(NotEq->getOpcode() == UO_LNot);

(

*BO = dyn_cast<BinaryOperator>(

)) {

assert(!SkippedNot || BO->getOpcode() == BO_EQ);

.Opcode = SkippedNot ? BO_NE : BO->getOpcode();

.LHS = BO->getLHS();

.RHS = BO->getRHS();

}

(

*BO = dyn_cast<CXXOperatorCallExpr>(

)) {

assert(!SkippedNot || BO->getOperator() == OO_EqualEqual);

assert(BO->isInfixBinaryOp());

(BO->getOperator()) {

OO_Less:

.Opcode = BO_LT;

;

OO_LessEqual:

.Opcode = BO_LE;

;

OO_Greater:

.Opcode = BO_GT;

;

OO_GreaterEqual:

.Opcode = BO_GE;

;

OO_Spaceship:

.Opcode = BO_Cmp;

;

OO_EqualEqual:

.Opcode = SkippedNot ? BO_NE : BO_EQ;

;

: llvm_unreachable(

);

.LHS = BO->getArg(0);

.RHS = BO->getArg(1);

llvm_unreachable(

);

(

.Opcode == BO_EQ ||

.Opcode == BO_NE)

=

.LHS->IgnoreUnlessSpelledInSource();

(

*BO = dyn_cast<BinaryOperator>(

)) {

assert(BO->getOpcode() == BO_Cmp);

.LHS = BO->getLHS();

.RHS = BO->getRHS();

}

(

*BO = dyn_cast<CXXOperatorCallExpr>(

)) {

assert(BO->getOperator() == OO_Spaceship);

.LHS = BO->getArg(0);

.RHS = BO->getArg(1);

llvm_unreachable(

);

assert(!

() &&

);

(

*DRE = dyn_cast<DeclRefExpr>(

)) {

Ty = DRE->getDecl()->getType();

assert(

() &&

);

cast<TypeSourceInfo *>(Operand)->

().getNonReferenceType(), Quals);

(

*CE = dyn_cast<CastExpr>(

)) {

(!CE->getSubExpr()->isGLValue())

(

*OVE = dyn_cast<OpaqueValueExpr>(

))

(

*BO = dyn_cast<BinaryOperator>(

))

(BO->getOpcode() == BO_Comma)

(

*ACO = dyn_cast<AbstractConditionalOperator>(

))

(isa<ArraySubscriptExpr>(

))

(

*UO = dyn_cast<UnaryOperator>(

))

(UO->getOpcode() == UO_Deref)

assert(

() &&

);

cast<TypeSourceInfo *>(Operand)->

().getNonReferenceType(), Quals);

CXXNewExpr::CXXNewExpr(

IsGlobalNew,

*OperatorNew,

UsualArrayDeleteWantsSize,

std::optional<Expr *> ArraySize,

OperatorNew(OperatorNew), OperatorDelete(OperatorDelete),

AllocatedTypeInfo(AllocatedTypeInfo),

(

),

DirectInitRange(DirectInitRange) {

);

.UsualArrayDeleteWantsSize = UsualArrayDeleteWantsSize;

llvm::to_underlying(InitializationStyle);

IsParenTypeId = TypeIdParens.

();

getTrailingObjects<Stmt *>()[arraySizeOffset()] = *ArraySize;

getTrailingObjects<Stmt *>()[initExprOffset()] =

;

(

I = 0; I != PlacementArgs.size(); ++I)

getTrailingObjects<Stmt *>()[placementNewArgsOffset() + I] =

getTrailingObjects<SourceRange>()[0] = TypeIdParens;

(getInitializationStyle()) {

CXXNewExpr::CXXNewExpr(EmptyShell

,

IsArray,

NumPlacementArgs,

IsParenTypeId)

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

IsArray = ArraySize.has_value();

NumPlacementArgs = PlacementArgs.size();

IsParenTypeId = TypeIdParens.

();

Ctx.

(totalSizeToAlloc<Stmt *, SourceRange>(

IsArray + HasInit + NumPlacementArgs, IsParenTypeId),

(IsGlobalNew, OperatorNew, OperatorDelete, ShouldPassAlignment,

UsualArrayDeleteWantsSize, PlacementArgs, TypeIdParens,

AllocatedTypeInfo,

, DirectInitRange);

HasInit,

NumPlacementArgs,

IsParenTypeId) {

Ctx.

(totalSizeToAlloc<Stmt *, SourceRange>(

IsArray + HasInit + NumPlacementArgs, IsParenTypeId),

(

*ICE = dyn_cast<ImplicitCastExpr>(Arg)) {

(ICE->getCastKind() == CK_DerivedToBase ||

ICE->getCastKind() == CK_UncheckedDerivedToBase ||

ICE->getCastKind() == CK_NoOp) {

assert((ICE->getCastKind() == CK_NoOp ||

);

Arg = ICE->getSubExpr();

:

(CXXPseudoDestructorExprClass, Context.BoundMemberTy,

,

OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),

ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc),

DestroyedType(DestroyedType) {

TInfo->getType();

End = TInfo->getTypeLoc().getSourceRange().getEnd();

UnresolvedLookupExpr::UnresolvedLookupExpr(

KnownInstantiationDependent)

:

(UnresolvedLookupExprClass, Context, QualifierLoc,

TemplateKWLoc, NameInfo, TemplateArgs,

, End,

KnownDependent, KnownInstantiationDependent,

),

NamingClass(NamingClass) {

UnresolvedLookupExpr::UnresolvedLookupExpr(EmptyShell

,

HasTemplateKWAndArgsInfo)

HasTemplateKWAndArgsInfo) {}

KnownDependent,

KnownInstantiationDependent) {

NumResults = End -

;

Context, NamingClass, QualifierLoc,

,

, End, KnownDependent,

KnownInstantiationDependent);

KnownInstantiationDependent) {

NumResults = End -

;

HasTemplateKWAndArgsInfo = Args || TemplateKWLoc.

();

NumTemplateArgs = Args ? Args->

() : 0;

NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);

Context, NamingClass, QualifierLoc, TemplateKWLoc, NameInfo, RequiresADL,

Args,

, End, KnownDependent, KnownInstantiationDependent);

&Context,

NumResults,

HasTemplateKWAndArgsInfo,

NumTemplateArgs) {

assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);

NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);

KnownInstantiationDependent,

KnownContainsUnexpandedParameterPack)

QualifierLoc(QualifierLoc) {

NumResults = End -

;

(TemplateArgs != nullptr ) || TemplateKWLoc.

();

Deps = TemplateArgumentDependence::None;

}

(TemplateKWLoc.

()) {

KnownInstantiationDependent,

KnownContainsUnexpandedParameterPack));

HasTemplateKWAndArgsInfo)

DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(

QualifierLoc(QualifierLoc), NameInfo(NameInfo) {

(Args !=

) || TemplateKWLoc.

();

Deps = TemplateArgumentDependence::None;

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(

TemplateKWLoc, *Args, getTrailingObjects<TemplateArgumentLoc>(), Deps);

}

(TemplateKWLoc.

()) {

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(

assert(QualifierLoc &&

);

HasTemplateKWAndArgsInfo = Args || TemplateKWLoc.

();

totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(

HasTemplateKWAndArgsInfo, Args ? Args->

() : 0);

*Mem = Context.

(Size);

TemplateKWLoc, NameInfo, Args);

HasTemplateKWAndArgsInfo,

NumTemplateArgs) {

assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);

totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(

HasTemplateKWAndArgsInfo, NumTemplateArgs);

*Mem = Context.

(Size);

HasTemplateKWAndArgsInfo;

(

*TOE = dyn_cast<CXXTemporaryObjectExpr>(

))

TOE->getBeginLoc();

(

*TOE = dyn_cast<CXXTemporaryObjectExpr>(

))

TOE->getEndLoc();

(ParenOrBraceRange.

())

ParenOrBraceRange.

();

(

I =

(); I > 0; --I) {

:

(CXXOperatorCallExprClass, Fn,

{}, Args, Ty, VK,

OperatorLoc, FPFeatures,

0, UsesADL) {

CXXOperatorCallExprBits.OperatorKind = OpKind;

(CXXOperatorCallExprBits.OperatorKind ==

(OpKind)) &&

);

= getSourceRangeImpl();

CXXOperatorCallExpr::CXXOperatorCallExpr(

NumArgs,

HasFPFeatures,

:

(CXXOperatorCallExprClass,

0, NumArgs,

HasFPFeatures,

) {}

NumArgs = Args.size();

SizeOfTrailingObjects =

CXXOperatorCallExpr::getSourceRangeImpl()

{

(Kind == OO_PlusPlus || Kind == OO_MinusMinus) {

}

(Kind == OO_Arrow) {

}

(Kind == OO_Call) {

}

(Kind == OO_Subscript) {

:

(CXXMemberCallExprClass,

,

{}, Args, Ty, VK, RP,

CXXMemberCallExpr::CXXMemberCallExpr(

NumArgs,

HasFPFeatures,

:

(CXXMemberCallExprClass,

0, NumArgs, HasFPFeatures,

MinNumArgs) {

NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);

SizeOfTrailingObjects =

(

*MemExpr = dyn_cast<MemberExpr>(Callee))

MemExpr->getBase();

(

*BO = dyn_cast<BinaryOperator>(Callee))

(BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI)

cast<CXXMethodDecl>(MemExpr->getMemberDecl());

CXXStaticCastExprClass:

;

CXXDynamicCastExprClass:

;

CXXReinterpretCastExprClass:

;

CXXConstCastExprClass:

;

CXXAddrspaceCastExprClass:

;

:

;

PathSize = (BasePath ? BasePath->size() : 0);

.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(

FPO, L, RParenLoc, AngleBrackets);

std::uninitialized_copy_n(BasePath->data(), BasePath->size(),

HasFPFeatures) {

.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(

PathSize, HasFPFeatures));

PathSize = (BasePath ? BasePath->size() : 0);

*Buffer =

.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));

RParenLoc, AngleBrackets);

std::uninitialized_copy_n(BasePath->data(), BasePath->size(),

*Buffer =

.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));

assert(SrcRD && DestRD);

(SrcRD->isEffectivelyFinal()) {

assert(!SrcRD->isDerivedFrom(DestRD) &&

);

(DestRD->isEffectivelyFinal() && !DestRD->isDerivedFrom(SrcRD))

PathSize = (BasePath ? BasePath->size() : 0);

*Buffer =

.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));

RParenLoc, AngleBrackets);

std::uninitialized_copy_n(BasePath->data(), BasePath->size(),

*Buffer =

.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));

(

)

(

, VK, Op, WrittenTy, L, RParenLoc, AngleBrackets);

PathSize = (BasePath ? BasePath->size() : 0);

.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(

*

=

(Buffer)

std::uninitialized_copy_n(BasePath->data(), BasePath->size(),

HasFPFeatures) {

.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(

PathSize, HasFPFeatures));

:

(UserDefinedLiteralClass, Fn,

{}, Args, Ty, VK,

LitEndLoc, FPFeatures,

0, NotADL),

UDSuffixLoc(SuffixLoc) {}

UserDefinedLiteral::UserDefinedLiteral(

NumArgs,

HasFPFeatures,

:

(UserDefinedLiteralClass,

0, NumArgs,

HasFPFeatures,

) {}

NumArgs = Args.size();

SizeOfTrailingObjects =

assert(

() == 1 &&

);

cast<FunctionDecl>(

())->getParamDecl(0)->getType();

llvm_unreachable(

);

cast<FunctionDecl>(

())->getLiteralIdentifier();

HasRewrittenInit) {

Size = totalSizeToAlloc<Expr *>(HasRewrittenInit);

*RewrittenExpr,

Size = totalSizeToAlloc<Expr *>(RewrittenExpr !=

);

RewrittenExpr, UsedContext);

);

(

*

= dyn_cast_if_present<FullExpr>(

))

(!isa<ConstantExpr>(

))

->getSubExpr();

CXXDefaultInitExpr::CXXDefaultInitExpr(

&Ctx,

*RewrittenInitExpr)

:

(CXXDefaultInitExprClass, Ty.getNonLValueExprType(Ctx),

: Ty->isRValueReferenceType() ?

Field(Field), UsedContext(UsedContext) {

*getTrailingObjects<Expr *>() = RewrittenInitExpr;

assert(Field->hasInClassInitializer());

HasRewrittenInit) {

Size = totalSizeToAlloc<Expr *>(HasRewrittenInit);

*RewrittenInitExpr) {

Size = totalSizeToAlloc<Expr *>(RewrittenInitExpr !=

);

UsedContext, RewrittenInitExpr);

assert(Field->getInClassInitializer() &&

);

Field->getInClassInitializer();

);

CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(

HadMultipleCandidates,

ListInitialization,

StdInitListInitialization,

ZeroInitialization)

CXXTemporaryObjectExprClass, Ty, TSI->getTypeLoc().getBeginLoc(),

Cons,

, Args, HadMultipleCandidates,

ListInitialization, StdInitListInitialization, ZeroInitialization,

CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(EmptyShell

,

HadMultipleCandidates,

ListInitialization,

StdInitListInitialization,

ZeroInitialization) {

Cons, Ty, TSI, Args, ParenOrBraceRange, HadMultipleCandidates,

ListInitialization, StdInitListInitialization, ZeroInitialization);

HadMultipleCandidates,

ListInitialization,

StdInitListInitialization,

ZeroInitialization,

CXXConstructExprClass, Ty,

, Ctor, Elidable, Args,

HadMultipleCandidates, ListInitialization, StdInitListInitialization,

ZeroInitialization, ConstructKind, ParenOrBraceRange);

ListInitialization,

StdInitListInitialization,

ParenOrBraceRange(ParenOrBraceRange), NumArgs(Args.size()) {

**TrailingArgs = getTrailingArgs();

(

I = 0, N = Args.size(); I != N; ++I) {

assert(Args[I] &&

);

TrailingArgs[I] = Args[I];

(SC == CXXConstructExprClass)

:

(SC,

), NumArgs(NumArgs) {}

: DeclAndBits(Var, 0),

(

), EllipsisLoc(EllipsisLoc) {

Bits |= Capture_Implicit;

Bits |= Capture_ByCopy;

assert(!Var &&

);

Bits |= Capture_This;

Bits |= Capture_ByCopy;

assert(Var &&

);

assert(!Var &&

);

DeclAndBits.setInt(Bits);

CapByCopy = DeclAndBits.getInt() & Capture_ByCopy;

ContainsUnexpandedParameterPack)

IntroducerRange(IntroducerRange), CaptureDefaultLoc(CaptureDefaultLoc),

ClosingBrace(ClosingBrace) {

LambdaExprBits.NumCaptures = CaptureInits.size();

LambdaExprBits.CaptureDefault = CaptureDefault;

LambdaExprBits.ExplicitParams = ExplicitParams;

LambdaExprBits.ExplicitResultType = ExplicitResultType;

assert(capture_size() ==

->capture_size() &&

);

assert(getCaptureDefault() ==

->getLambdaCaptureDefault());

**Stored = getStoredStmts();

(

I = 0, N = CaptureInits.size(); I != N; ++I)

*Stored++ = CaptureInits[I];

*Stored++ = getCallOperator()->getBody();

LambdaExpr::LambdaExpr(EmptyShell

,

NumCaptures)

LambdaExprBits.NumCaptures = NumCaptures;

getStoredStmts()[NumCaptures] =

;

ExplicitParams,

ExplicitResultType,

ContainsUnexpandedParameterPack) {

Size = totalSizeToAlloc<Stmt *>(CaptureInits.size() + 1);

*Mem = Context.

(Size);

(

, IntroducerRange, CaptureDefault, CaptureDefaultLoc,

ExplicitParams, ExplicitResultType, CaptureInits, ClosingBrace,

ContainsUnexpandedParameterPack);

NumCaptures) {

Size = totalSizeToAlloc<Stmt *>(NumCaptures + 1);

*Mem =

.Allocate(Size);

LambdaExpr::initBodyIfNeeded()

{

*This =

*

(

);

(

*CoroBody = dyn_cast<CoroutineBodyStmt>(Body))

cast<CompoundStmt>(CoroBody->getBody());

cast<CompoundStmt>(Body);

->capturesVariable() &&

->getCapturedVar()->isInitCapture() &&

->getLambdaCallOperator();

->getDependentLambdaCallOperator();

->getGenericLambdaTemplateParameterList();

->getLambdaExplicitTemplateParameters();

ExprWithCleanups::ExprWithCleanups(

*subexpr,

CleanupsHaveSideEffects,

:

(ExprWithCleanupsClass, subexpr) {

(

i = 0, e = objects.size(); i != e; ++i)

getTrailingObjects<CleanupObject>()[i] = objects[i];

CleanupsHaveSideEffects,

*buffer =

.Allocate(totalSizeToAlloc<CleanupObject>(objects.size()),

ExprWithCleanups::ExprWithCleanups(EmptyShell empty,

numObjects)

:

(ExprWithCleanupsClass, empty) {

numObjects) {

*buffer =

.Allocate(totalSizeToAlloc<CleanupObject>(numObjects),

CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(

:

(CXXUnresolvedConstructExprClass,

,

(TSI->getType()->isLValueReferenceType() ?

: TSI->getType()->isRValueReferenceType() ?

TypeAndInitForm(TSI, IsListInit), LParenLoc(LParenLoc),

RParenLoc(RParenLoc) {

**StoredArgs = getTrailingObjects<Expr *>();

(

I = 0; I != Args.size(); ++I)

StoredArgs[I] = Args[I];

*Mem = Context.

(totalSizeToAlloc<Expr *>(Args.size()));

RParenLoc, IsListInit);

*Mem = Context.

(totalSizeToAlloc<Expr *>(NumArgs));

TypeAndInitForm.getPointer()->getTypeLoc().getBeginLoc();

CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(

:

(CXXDependentScopeMemberExprClass, Ctx.DependentTy,

,

(

), BaseType(BaseType), QualifierLoc(QualifierLoc),

MemberNameInfo(MemberNameInfo) {

(TemplateArgs !=

) || TemplateKWLoc.

();

FirstQualifierFoundInScope !=

;

Deps = TemplateArgumentDependence::None;

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(

TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(),

}

(TemplateKWLoc.

()) {

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(

(hasFirstQualifierFoundInScope())

*getTrailingObjects<NamedDecl *>() = FirstQualifierFoundInScope;

CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(

EmptyShell

,

HasTemplateKWAndArgsInfo,

HasFirstQualifierFoundInScope)

:

(CXXDependentScopeMemberExprClass,

) {

HasTemplateKWAndArgsInfo;

HasFirstQualifierFoundInScope;

HasTemplateKWAndArgsInfo =

(TemplateArgs !=

) || TemplateKWLoc.

();

NumTemplateArgs = TemplateArgs ? TemplateArgs->

() : 0;

HasFirstQualifierFoundInScope = FirstQualifierFoundInScope !=

;

HasTemplateKWAndArgsInfo, NumTemplateArgs, HasFirstQualifierFoundInScope);

Ctx,

, BaseType, IsArrow, OperatorLoc, QualifierLoc, TemplateKWLoc,

FirstQualifierFoundInScope, MemberNameInfo, TemplateArgs);

&Ctx,

HasTemplateKWAndArgsInfo,

NumTemplateArgs,

HasFirstQualifierFoundInScope) {

assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);

HasTemplateKWAndArgsInfo, NumTemplateArgs, HasFirstQualifierFoundInScope);

(), HasTemplateKWAndArgsInfo, HasFirstQualifierFoundInScope);

(isa<UnresolvedUsingValueDecl>(

))

(cast<CXXMethodDecl>(

->getUnderlyingDecl()->getAsFunction())

}

(++begin != end);

UnresolvedMemberExpr::UnresolvedMemberExpr(

UnresolvedMemberExprClass, Context, QualifierLoc, TemplateKWLoc,

MemberNameInfo, TemplateArgs,

, End,

((

&&

->isTypeDependent()) || BaseType->isDependentType()),

((

&&

->isInstantiationDependent()) ||

BaseType->isInstantiationDependentType()),

((

&&

->containsUnexpandedParameterPack()) ||

BaseType->containsUnexpandedParameterPack())),

(

), BaseType(BaseType), OperatorLoc(OperatorLoc) {

UnresolvedMemberExprBits.IsArrow = IsArrow;

UnresolvedMemberExprBits.HasUnresolvedUsing = HasUnresolvedUsing;

UnresolvedMemberExpr::UnresolvedMemberExpr(EmptyShell

,

NumResults,

HasTemplateKWAndArgsInfo)

HasTemplateKWAndArgsInfo) {}

cast<Expr>(

)->isImplicitCXXThis();

NumResults = End -

;

HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.

();

NumTemplateArgs = TemplateArgs ? TemplateArgs->

() : 0;

NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);

Context, HasUnresolvedUsing,

, BaseType, IsArrow, OperatorLoc,

QualifierLoc, TemplateKWLoc, MemberNameInfo, TemplateArgs,

, End);

&Context,

NumResults,

HasTemplateKWAndArgsInfo,

NumTemplateArgs) {

assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);

NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);

assert(

&&

);

assert(

&&

);

assert(

&&

);

std::optional<unsigned> Length,

Context.

(totalSizeToAlloc<TemplateArgument>(PartialArgs.size()));

PackLoc, RParenLoc, Length, PartialArgs);

NumPartialArgs) {

Context.

(totalSizeToAlloc<TemplateArgument>(NumPartialArgs));

cast<NonTypeTemplateParmDecl>(

*PackIdExpr,

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

(Index && FullySubstituted && !SubstitutedExprs.empty())

= SubstitutedExprs[*Index]->getType();

Context.

(totalSizeToAlloc<Expr *>(SubstitutedExprs.size()));

(Storage)

SubstitutedExprs, FullySubstituted);

*ND = dyn_cast<NamedDecl>(

->getDecl());

assert(ND &&

);

assert(

&&

);

NumTransformedExprs) {

Context.

(totalSizeToAlloc<Expr *>(NumTransformedExprs));

SubstNonTypeTemplateParmPackExpr::SubstNonTypeTemplateParmPackExpr(

:

(SubstNonTypeTemplateParmPackExprClass,

, ValueKind,

),

AssociatedDecl(AssociatedDecl), Arguments(ArgPack.pack_begin()),

NumArguments(ArgPack.pack_size()), Index(Index), NameLoc(NameLoc) {

assert(AssociatedDecl !=

);

ExprDependence::UnexpandedPack);

cast<NonTypeTemplateParmDecl>(

FunctionParmPackExpr::FunctionParmPackExpr(

,

*ParamPack,

ParamPack(ParamPack), NameLoc(NameLoc), NumParameters(NumParams) {

std::uninitialized_copy(Params, Params + NumParams,

getTrailingObjects<VarDecl *>());

ExprDependence::UnexpandedPack);

(Context.

(totalSizeToAlloc<VarDecl *>(Params.size())))

NumParams) {

(Context.

(totalSizeToAlloc<VarDecl *>(NumParams)))

:

(MaterializeTemporaryExprClass,

,

MTD->ExprWithTemporary = Temporary;

ManglingNumber) {

(!isa<LifetimeExtendedTemporaryDecl *>(State))

cast<Expr>(cast<Stmt *>(State)), ExtendedBy, ManglingNumber);

ES = cast<LifetimeExtendedTemporaryDecl *>(State);

ES->ExtendingDecl = ExtendedBy;

ES->ManglingNumber = ManglingNumber;

VD->isUsableInConstantExpressions(Context);

RParenLoc(RParenLoc) {

assert(Kind <=

&&

);

);

);

**ToArgs = getTrailingObjects<TypeSourceInfo *>();

(

I = 0, N = Args.size(); I != N; ++I)

ToArgs[I] = Args[I];

*Mem =

.Allocate(totalSizeToAlloc<TypeSourceInfo *>(Args.size()));

*Mem =

.Allocate(totalSizeToAlloc<TypeSourceInfo *>(NumArgs));

CUDAKernelCallExpr::CUDAKernelCallExpr(

*Fn,

*Config,

MinNumArgs)

:

(CUDAKernelCallExprClass, Fn,

Config, Args, Ty, VK,

RP, FPFeatures, MinNumArgs, NotADL) {}

CUDAKernelCallExpr::CUDAKernelCallExpr(

NumArgs,

HasFPFeatures,

:

(CUDAKernelCallExprClass,

END_PREARG, NumArgs,

HasFPFeatures,

) {}

MinNumArgs) {

NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);

END_PREARG, NumArgs, HasFPFeatures);

NumUserSpecifiedExprs,

*Mem =

.Allocate(totalSizeToAlloc<Expr *>(Args.size()));

LParenLoc, RParenLoc);

*Mem =

.Allocate(totalSizeToAlloc<Expr *>(NumExprs),

std::optional<unsigned> NumExpansions)

EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc),

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

);

SubExprs[SubExpr::Callee] = Callee;

SubExprs[SubExpr::LHS] = LHS;

SubExprs[SubExpr::RHS] = RHS;

ResolvedUnexpandedPackExpr::ResolvedUnexpandedPackExpr(

BL,

BeginLoc(BL), NumExprs(NumExprs) {

ExprDependence::UnexpandedPack);

NumExprs) {

*Mem = Ctx.

(totalSizeToAlloc<Expr *>(NumExprs),

*Mem = Ctx.

(totalSizeToAlloc<Expr *>(NumExprs),

std::uninitialized_fill(Exprs.begin(), Exprs.end(),

);

*New =

(Ctx, BL,

, Exprs.size());

std::uninitialized_copy(Exprs.begin(), Exprs.end(), New->getExprs().begin());

(

*BD = dyn_cast<BindingDecl>(

))

dyn_cast_if_present<ResolvedUnexpandedPackExpr>(BD->getBinding());

Defines the clang::ASTContext interface.

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

Defines the C++ template declaration subclasses.

static bool hasOnlyNonStaticMemberFunctions(UnresolvedSetIterator begin, UnresolvedSetIterator end)

static bool isGLValueFromPointerDeref(const Expr *E)

Defines the clang::Expr interface and subclasses for C++ expressions.

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

Defines the LambdaCapture class.

llvm::MachO::Record Record

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 the clang::TypeLoc interface and its subclasses.

C Language Family Type Representation.

__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)

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

QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const

Return the uniqued reference to the type for an lvalue reference 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.

const LangOptions & getLangOpts() const

CanQualType getSizeType() const

Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.

CanQualType BoundMemberTy

void * Allocate(size_t Size, unsigned Align=8) const

QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const

Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.

Represents a call to a CUDA kernel function.

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

static CUDAKernelCallExpr * Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RP, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0)

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

static CXXAddrspaceCastExpr * CreateEmpty(const ASTContext &Context)

static CXXAddrspaceCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)

Represents a base class of a C++ class.

Represents binding an expression to a temporary.

static CXXBindTemporaryExpr * Create(const ASTContext &C, CXXTemporary *Temp, Expr *SubExpr)

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

static CXXConstCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, Expr *Op, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)

static CXXConstCastExpr * CreateEmpty(const ASTContext &Context)

Represents a call to a C++ constructor.

SourceRange getParenOrBraceRange() const

static CXXConstructExpr * Create(const ASTContext &Ctx, QualType Ty, SourceLocation Loc, CXXConstructorDecl *Ctor, bool Elidable, ArrayRef< Expr * > Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, CXXConstructionKind ConstructKind, SourceRange ParenOrBraceRange)

Create a C++ construction expression.

Expr * getArg(unsigned Arg)

Return the specified argument.

CXXConstructExpr(StmtClass SC, QualType Ty, SourceLocation Loc, CXXConstructorDecl *Ctor, bool Elidable, ArrayRef< Expr * > Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, CXXConstructionKind ConstructKind, SourceRange ParenOrBraceRange)

Build a C++ construction expression.

SourceLocation getLocation() const

static unsigned sizeOfTrailingObjects(unsigned NumArgs)

Return the size in bytes of the trailing objects.

SourceLocation getEndLoc() const LLVM_READONLY

SourceLocation getBeginLoc() const LLVM_READONLY

unsigned getNumArgs() const

Return the number of arguments to the constructor call.

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

const ParmVarDecl * getParam() const

Expr * getRewrittenExpr()

Expr * getAdjustedRewrittenExpr()

static CXXDefaultArgExpr * Create(const ASTContext &C, SourceLocation Loc, ParmVarDecl *Param, Expr *RewrittenExpr, DeclContext *UsedContext)

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 CXXDefaultInitExpr * Create(const ASTContext &Ctx, SourceLocation Loc, FieldDecl *Field, DeclContext *UsedContext, Expr *RewrittenInitExpr)

Field is the non-static data member whose default initializer is used by this expression.

const Expr * getRewrittenExpr() const

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

bool hasRewrittenInit() const

Expr * getExpr()

Get the initialization expression that will be used.

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

FunctionDecl * getOperatorDelete() const

QualType getDestroyedType() const

Retrieve the type being destroyed.

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

static CXXDependentScopeMemberExpr * Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)

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

Represents a C++ destructor within a class.

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

static CXXDynamicCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)

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.

CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee, SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Opcode, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, std::optional< unsigned > NumExpansions)

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

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

SourceLocation getBeginLoc() const LLVM_READONLY

SourceLocation getEndLoc() const LLVM_READONLY

static CXXFunctionalCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, TypeSourceInfo *Written, CastKind Kind, Expr *Op, const CXXCastPath *Path, FPOptionsOverride FPO, SourceLocation LPLoc, SourceLocation RPLoc)

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)

static CXXMemberCallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RP, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0)

QualType getObjectType() const

Retrieve the type of the object argument.

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.

const char * getCastName() const

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

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.

bool shouldNullCheckAllocation() const

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

FunctionDecl * getOperatorNew() const

static CXXNewExpr * Create(const ASTContext &Ctx, bool IsGlobalNew, FunctionDecl *OperatorNew, FunctionDecl *OperatorDelete, bool ShouldPassAlignment, bool UsualArrayDeleteWantsSize, ArrayRef< Expr * > PlacementArgs, SourceRange TypeIdParens, std::optional< Expr * > ArraySize, CXXNewInitializationStyle InitializationStyle, Expr *Initializer, QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range, SourceRange DirectInitRange)

Create a c++ new expression.

A call to an overloaded operator written using operator syntax.

bool isInfixBinaryOp() const

Is this written as an infix binary operator?

SourceLocation getOperatorLoc() const

Returns the location of the operator symbol in the expression.

SourceLocation getEndLoc() const

OverloadedOperatorKind getOperator() const

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

static CXXOperatorCallExpr * Create(const ASTContext &Ctx, OverloadedOperatorKind OpKind, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation OperatorLoc, FPOptionsOverride FPFeatures, ADLCallKind UsesADL=NotADL)

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

SourceLocation getBeginLoc() const

Represents a list-initialization with parenthesis.

static CXXParenListInitExpr * Create(ASTContext &C, ArrayRef< Expr * > Args, QualType T, unsigned NumUserSpecifiedExprs, SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)

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

CXXPseudoDestructorExpr(const ASTContext &Context, Expr *Base, bool isArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, TypeSourceInfo *ScopeType, SourceLocation ColonColonLoc, SourceLocation TildeLoc, PseudoDestructorTypeStorage DestroyedType)

SourceLocation getEndLoc() const LLVM_READONLY

QualType getDestroyedType() const

Retrieve the type being destroyed.

Represents a C++ struct/union/class.

capture_const_iterator captures_end() const

capture_const_iterator captures_begin() const

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

static CXXReinterpretCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)

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

Expr * getSemanticForm()

Get an equivalent semantic form for this expression.

bool isReversed() const

Determine whether this expression was rewritten in reverse form.

DecomposedForm getDecomposedForm() const LLVM_READONLY

Decompose this operator into its syntactic form.

SourceLocation getBeginLoc() const LLVM_READONLY

SourceLocation getRParenLoc() const

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

static CXXStaticCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written, FPOptionsOverride FPO, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)

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

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

static CXXTemporaryObjectExpr * Create(const ASTContext &Ctx, CXXConstructorDecl *Cons, QualType Ty, TypeSourceInfo *TSI, ArrayRef< Expr * > Args, SourceRange ParenOrBraceRange, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization)

TypeSourceInfo * getTypeSourceInfo() const

SourceLocation getEndLoc() const LLVM_READONLY

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

SourceLocation getBeginLoc() const LLVM_READONLY

Represents a C++ temporary.

static CXXTemporary * Create(const ASTContext &C, const CXXDestructorDecl *Destructor)

Represents the this expression in C++.

static CXXThisExpr * CreateEmpty(const ASTContext &Ctx)

static CXXThisExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType Ty, bool IsImplicit)

bool isTypeOperand() const

QualType getTypeOperand(const ASTContext &Context) const

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

Expr * getExprOperand() const

bool isMostDerived(const ASTContext &Context) const

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

bool isPotentiallyEvaluated() const

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

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

static CXXUnresolvedConstructExpr * Create(const ASTContext &Context, QualType T, TypeSourceInfo *TSI, SourceLocation LParenLoc, ArrayRef< Expr * > Args, SourceLocation RParenLoc, bool IsListInit)

SourceLocation getBeginLoc() const LLVM_READONLY

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

QualType getTypeOperand(ASTContext &Context) const

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

bool isTypeOperand() const

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

Expr * getArg(unsigned Arg)

getArg - Return the specified argument.

static unsigned sizeOfTrailingObjects(unsigned NumPreArgs, unsigned NumArgs, bool HasFPFeatures)

Return the size in bytes needed for the trailing objects.

unsigned getNumArgs() const

getNumArgs - Return the number of actual arguments to this call.

SourceLocation getRParenLoc() const

static constexpr ADLCallKind UsesADL

CastKind getCastKind() const

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

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.

Expr * getTrailingRequiresClause()

Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...

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

static DependentScopeDeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)

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

TypeSourceInfo * getTypeInfoAsWritten() const

getTypeInfoAsWritten - Returns the type source info for the type that this expression is casting to.

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

static ExprWithCleanups * Create(const ASTContext &C, EmptyShell empty, unsigned numObjects)

This represents one expression.

Expr * IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY

Skip past any parentheses and casts which do not change the value (including ptr->int casts of the sa...

bool isValueDependent() const

Determines whether the value of this expression depends on.

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

Expr * IgnoreImplicit() LLVM_READONLY

Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.

Expr * IgnoreParens() LLVM_READONLY

Skip past any parentheses which might surround this expression until reaching a fixed point.

bool isDefaultArgument() const

Determine whether this expression is a default function argument.

void setDependence(ExprDependence Deps)

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

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.

Stmt * getBody(const FunctionDecl *&Definition) const

Retrieve the body (definition) of the function.

bool isReservedGlobalPlacementOperator() const

Determines whether this operator new or delete is one of the reserved global placement operators: voi...

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

static FunctionParmPackExpr * Create(const ASTContext &Context, QualType T, VarDecl *ParamPack, SourceLocation NameLoc, ArrayRef< VarDecl * > Params)

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

Represents a prototype with parameter type info, e.g.

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.

bool capturesVLAType() const

Determine whether this captures a variable length array bound expression.

LambdaCapture(SourceLocation Loc, bool Implicit, LambdaCaptureKind Kind, ValueDecl *Var=nullptr, SourceLocation EllipsisLoc=SourceLocation())

Create a new capture of a variable or of this.

LambdaCaptureKind getCaptureKind() const

Determine the kind of capture.

bool capturesThis() const

Determine whether this capture handles the C++ this pointer.

A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...

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.

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.

Stmt * getBody() const

Retrieve the body of the lambda.

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.

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.

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.

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.

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.

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.

capture_range captures() const

Retrieve this lambda's captures.

CXXRecordDecl * getLambdaClass() const

Retrieve the class that corresponds to the lambda.

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

static LifetimeExtendedTemporaryDecl * Create(Expr *Temp, ValueDecl *EDec, unsigned Mangling)

MaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference, LifetimeExtendedTemporaryDecl *MTD=nullptr)

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

void setExtendingDecl(ValueDecl *ExtendedBy, unsigned ManglingNumber)

This represents a decl that may have a name.

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

@ Super

Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.

const Type * getAsType() const

Retrieve the type stored in this nested name specifier.

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

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

NestedNameSpecifier * getQualifier() const

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

ASTTemplateKWAndArgsInfo * getTrailingASTTemplateKWAndArgsInfo()

Return the optional template keyword and arguments info.

TemplateArgumentLoc * getTrailingTemplateArgumentLoc()

Return the optional template arguments.

DeclAccessPair * getTrailingResults()

Return the results. Defined after UnresolvedMemberExpr.

OverloadExpr(StmtClass SC, const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent, bool KnownInstantiationDependent, bool KnownContainsUnexpandedParameterPack)

NamedDecl * getPackDecl() const

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

Expr * getPackIdExpression() const

static PackIndexingExpr * Create(ASTContext &Context, SourceLocation EllipsisLoc, SourceLocation RSquareLoc, Expr *PackIdExpr, Expr *IndexExpr, std::optional< int64_t > Index, ArrayRef< Expr * > SubstitutedExprs={}, bool FullySubstituted=false)

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()=default

SourceLocation getLocation() const

TypeSourceInfo * getTypeSourceInfo() const

A (possibly-)qualified type.

bool isVolatileQualified() const

Determine whether this type is volatile-qualified.

bool isConstant(const ASTContext &Ctx) const

QualType getNonReferenceType() const

If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...

QualType getUnqualifiedType() const

Retrieve the unqualified variant of the given type, removing as little sugar as possible.

The collection of all-type qualifiers we support.

llvm::MutableArrayRef< Expr * > getExprs()

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

static ResolvedUnexpandedPackExpr * getFromDecl(Decl *)

static ResolvedUnexpandedPackExpr * Create(ASTContext &C, SourceLocation BeginLoc, QualType T, unsigned NumExprs)

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

static SizeOfPackExpr * Create(ASTContext &Context, SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, std::optional< unsigned > Length=std::nullopt, ArrayRef< TemplateArgument > PartialArgs={})

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

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

void setEnd(SourceLocation e)

Stmt - This represents one statement.

SourceLocation getEndLoc() const LLVM_READONLY

CXXUnresolvedConstructExprBitfields CXXUnresolvedConstructExprBits

UnresolvedLookupExprBitfields UnresolvedLookupExprBits

ExprWithCleanupsBitfields ExprWithCleanupsBits

StmtClass getStmtClass() const

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

TypeTraitExprBitfields TypeTraitExprBits

CXXNewExprBitfields CXXNewExprBits

llvm::iterator_range< child_iterator > child_range

CXXDefaultInitExprBitfields CXXDefaultInitExprBits

DependentScopeDeclRefExprBitfields DependentScopeDeclRefExprBits

llvm::iterator_range< const_child_iterator > const_child_range

CXXDefaultArgExprBitfields CXXDefaultArgExprBits

Decl * getAssociatedDecl() const

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

QualType getParameterType(const ASTContext &Ctx) const

Determine the substituted type of the template parameter.

bool isReferenceParameter() const

NonTypeTemplateParmDecl * getParameter() const

TemplateArgument getArgumentPack() const

Retrieve the template argument pack containing the substituted template arguments.

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.

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.

SourceLocation getBeginLoc() const

Get the begin source location.

A container of type source information.

TypeLoc getTypeLoc() const

Return the TypeLoc wrapper for the type source info.

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

static TypeTraitExpr * Create(const ASTContext &C, QualType T, SourceLocation Loc, TypeTrait Kind, ArrayRef< TypeSourceInfo * > Args, SourceLocation RParenLoc, bool Value)

Create a new type trait expression.

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

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 isLiteralType(const ASTContext &Ctx) const

Return true if this is a literal type (C++11 [basic.types]p10)

bool isVoidPointerType() const

bool isPointerType() const

bool isIntegerType() const

isIntegerType() does not include complex integers (a GCC extension).

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 isAnyCharacterType() const

Determine whether this type is any of the built-in character types.

bool isDependentType() const

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

bool isPointerOrReferenceType() const

bool isFloatingType() const

bool isAnyPointerType() const

bool isRecordType() const

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

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

static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent, bool KnownInstantiationDependent)

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

QualType getBaseType() const

bool isArrow() const

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

static UnresolvedMemberExpr * Create(const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin, UnresolvedSetIterator End)

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

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

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 IdentifierInfo * getUDSuffix() const

Returns the ud-suffix specified for this literal.

static UserDefinedLiteral * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation LitEndLoc, SourceLocation SuffixLoc, FPOptionsOverride FPFeatures)

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

Expr * getCookedLiteral()

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

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)

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.

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

OverloadedOperatorKind

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

@ OK_Ordinary

An ordinary object is located at an address in memory.

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.

ExprDependence computeDependence(FullExpr *E)

@ Create

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

@ Result

The result type of a method or function.

TemplateParameterList * getReplacedTemplateParameterList(Decl *D)

Internal helper used by Subst* nodes to retrieve the parameter list for their AssociatedDecl.

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_XValue

An x-value expression is a reference to an object with independent storage but which can be "moved",...

@ VK_LValue

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

const FunctionProtoType * T

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

@ None

New-expression has no initializer as written.

@ Braces

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

@ Implicit

An implicit conversion.

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

void initializeFrom(SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &List, TemplateArgumentLoc *OutArgArray)

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

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