14#ifndef LLVM_CLANG_AST_EXPRCXX_H
15#define LLVM_CLANG_AST_EXPRCXX_H
42#include "llvm/ADT/ArrayRef.h"
43#include "llvm/ADT/PointerUnion.h"
44#include "llvm/ADT/StringRef.h"
45#include "llvm/ADT/iterator_range.h"
46#include "llvm/Support/Casting.h"
47#include "llvm/Support/Compiler.h"
48#include "llvm/Support/TrailingObjects.h"
61class NonTypeTemplateParmDecl;
62class TemplateParameterList;
90 SourceRange getSourceRangeImpl() const LLVM_READONLY;
107 unsigned NumArgs,
bool HasFPFeatures,
117 return Opc == OO_Equal || Opc == OO_StarEqual || Opc == OO_SlashEqual ||
118 Opc == OO_PercentEqual || Opc == OO_PlusEqual ||
119 Opc == OO_MinusEqual || Opc == OO_LessLessEqual ||
120 Opc == OO_GreaterGreaterEqual || Opc == OO_AmpEqual ||
121 Opc == OO_CaretEqual || Opc == OO_PipeEqual;
128 case OO_ExclaimEqual:
130 case OO_GreaterEqual:
153 return (Operator < OO_Plus || Operator >= OO_Arrow ||
154 Operator == OO_PlusPlus || Operator == OO_MinusMinus)
164 return T->getStmtClass() == CXXOperatorCallExprClass;
191 unsigned MinNumArgs = 0);
226 return T->getStmtClass() == CXXMemberCallExprClass;
234 enum { CONFIG, END_PREARG };
251 unsigned MinNumArgs = 0);
254 unsigned NumArgs,
bool HasFPFeatures,
258 return cast_or_null<CallExpr>(
getPreArg(CONFIG));
263 return T->getStmtClass() == CUDAKernelCallExprClass;
291 :
Expr(CXXRewrittenBinaryOperatorClass, SemanticForm->
getType(),
293 SemanticForm(SemanticForm) {
298 :
Expr(CXXRewrittenBinaryOperatorClass, Empty), SemanticForm() {}
357 return child_range(&SemanticForm, &SemanticForm + 1);
361 return T->getStmtClass() == CXXRewrittenBinaryOperatorClass;
387 Expr *op,
unsigned PathSize,
bool HasFPFeatures,
392 Loc(l), RParenLoc(RParenLoc), AngleBrackets(AngleBrackets) {}
413 switch (
T->getStmtClass()) {
414 case CXXStaticCastExprClass:
415 case CXXDynamicCastExprClass:
416 case CXXReinterpretCastExprClass:
417 case CXXConstCastExprClass:
418 case CXXAddrspaceCastExprClass:
432 private llvm::TrailingObjects<CXXStaticCastExpr, CXXBaseSpecifier *,
450 unsigned numTrailingObjects(OverloadToken<CXXBaseSpecifier *>)
const {
464 unsigned PathSize,
bool hasFPFeatures);
467 return T->getStmtClass() == CXXStaticCastExprClass;
478 private llvm::TrailingObjects<CXXDynamicCastExpr, CXXBaseSpecifier *> {
484 false, writtenTy, l, RParenLoc,
508 return T->getStmtClass() == CXXDynamicCastExprClass;
522 private llvm::TrailingObjects<CXXReinterpretCastExpr,
523 CXXBaseSpecifier *> {
529 pathSize,
false, writtenTy, l,
530 RParenLoc, AngleBrackets) {}
550 return T->getStmtClass() == CXXReinterpretCastExprClass;
563 private llvm::TrailingObjects<CXXConstCastExpr, CXXBaseSpecifier *> {
568 false, writtenTy, l, RParenLoc,
587 return T->getStmtClass() == CXXConstCastExprClass;
601 private llvm::TrailingObjects<CXXAddrspaceCastExpr, CXXBaseSpecifier *> {
606 false, writtenTy, l, RParenLoc,
624 return T->getStmtClass() == CXXAddrspaceCastExprClass;
661 unsigned NumArgs,
bool HasFPOptions,
715 return S->getStmtClass() == UserDefinedLiteralClass;
730 :
Expr(CXXBoolLiteralExprClass, Empty) {}
747 return T->getStmtClass() == CXXBoolLiteralExprClass;
774 :
Expr(CXXNullPtrLiteralExprClass, Empty) {}
783 return T->getStmtClass() == CXXNullPtrLiteralExprClass;
798 Stmt *SubExpr =
nullptr;
801 :
Expr(CXXStdInitializerListExprClass, Empty) {}
830 return S->getStmtClass() == CXXStdInitializerListExprClass;
849 llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;
866 :
Expr(CXXTypeidExprClass, Empty) {
868 Operand = (
Expr*)
nullptr;
889 assert(
isTypeOperand() &&
"Cannot call getTypeOperand for typeid(expr)");
893 assert(!
isTypeOperand() &&
"Cannot call getExprOperand for typeid(type)");
894 return static_cast<Expr*
>(Operand.get<
Stmt *>());
903 return T->getStmtClass() == CXXTypeidExprClass;
910 auto **begin =
reinterpret_cast<Stmt **
>(&Operand);
942 :
Expr(MSPropertyRefExprClass, ty, VK,
OK_Ordinary), BaseExpr(baseExpr),
943 TheDecl(
decl), MemberLoc(nameLoc), IsArrow(
isArrow),
944 QualifierLoc(qualifierLoc) {
961 else if (QualifierLoc)
979 return T->getStmtClass() == MSPropertyRefExprClass;
1003 enum { BASE_EXPR, IDX_EXPR, NUM_SUBEXPRS = 2 };
1005 Stmt *SubExprs[NUM_SUBEXPRS];
1008 void setBase(
Expr *
Base) { SubExprs[BASE_EXPR] =
Base; }
1009 void setIdx(
Expr *Idx) { SubExprs[IDX_EXPR] = Idx; }
1014 :
Expr(MSPropertySubscriptExprClass, Ty, VK, OK),
1015 RBracketLoc(RBracketLoc) {
1016 SubExprs[BASE_EXPR] =
Base;
1017 SubExprs[IDX_EXPR] = Idx;
1023 :
Expr(MSPropertySubscriptExprClass, Shell) {}
1026 const Expr *
getBase()
const {
return cast<Expr>(SubExprs[BASE_EXPR]); }
1029 const Expr *
getIdx()
const {
return cast<Expr>(SubExprs[IDX_EXPR]); }
1045 return T->getStmtClass() == MSPropertySubscriptExprClass;
1050 return child_range(&SubExprs[0], &SubExprs[0] + NUM_SUBEXPRS);
1066 llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;
1074 Guid(Guid), Range(R) {
1080 Guid(Guid), Range(R) {
1085 :
Expr(CXXUuidofExprClass, Empty) {
1087 Operand = (
Expr*)
nullptr;
1100 assert(
isTypeOperand() &&
"Cannot call getTypeOperand for __uuidof(expr)");
1104 assert(!
isTypeOperand() &&
"Cannot call getExprOperand for __uuidof(type)");
1105 return static_cast<Expr*
>(Operand.get<
Stmt *>());
1116 return T->getStmtClass() == CXXUuidofExprClass;
1123 auto **begin =
reinterpret_cast<Stmt **
>(&Operand);
1152 CXXThisExprBits.CapturedByCopyInLambdaWithExplicitObjectParameter =
false;
1175 return CXXThisExprBits.CapturedByCopyInLambdaWithExplicitObjectParameter;
1184 return T->getStmtClass() == CXXThisExprClass;
1214 bool IsThrownVariableInScope)
1244 return T->getStmtClass() == CXXThrowExprClass;
1249 return child_range(&Operand, Operand ? &Operand + 1 : &Operand);
1264 private llvm::TrailingObjects<CXXDefaultArgExpr, Expr *> {
1267 friend TrailingObjects;
1278 Param->hasUnparsedDefaultArg()
1279 ? Param->
getType().getNonReferenceType()
1280 : Param->getDefaultArg()->
getType(),
1283 Param(Param), UsedContext(UsedContext) {
1287 *getTrailingObjects<Expr *>() = RewrittenExpr;
1292 :
Expr(CXXDefaultArgExprClass, Empty) {
1297 static CXXDefaultArgExpr *
CreateEmpty(
const ASTContext &
C,
1298 bool HasRewrittenInit);
1302 static CXXDefaultArgExpr *
Create(
const ASTContext &
C, SourceLocation Loc,
1303 ParmVarDecl *Param,
Expr *RewrittenExpr,
1304 DeclContext *UsedContext);
1348 return T->getStmtClass() == CXXDefaultArgExprClass;
1371 private llvm::TrailingObjects<CXXDefaultInitExpr, Expr *> {
1375 friend TrailingObjects;
1384 Expr *RewrittenInitExpr);
1387 :
Expr(CXXDefaultInitExprClass, Empty) {
1393 bool HasRewrittenInit);
1398 Expr *RewrittenInitExpr);
1418 return *getTrailingObjects<Expr *>();
1425 return *getTrailingObjects<Expr *>();
1439 return T->getStmtClass() == CXXDefaultInitExprClass;
1458 : Destructor(destructor) {}
1487 Stmt *SubExpr =
nullptr;
1490 :
Expr(CXXBindTemporaryExprClass, SubExpr->getType(),
VK_PRValue,
1492 Temp(temp), SubExpr(SubExpr) {
1498 :
Expr(CXXBindTemporaryExprClass, Empty) {}
1521 return T->getStmtClass() == CXXBindTemporaryExprClass;
1567 inline Stmt **getTrailingArgs();
1568 const Stmt *
const *getTrailingArgs()
const {
1577 bool ListInitialization,
bool StdInitListInitialization,
1587 return NumArgs *
sizeof(
Stmt *);
1595 bool HadMultipleCandidates,
bool ListInitialization,
1596 bool StdInitListInitialization,
bool ZeroInitialization,
1676 return reinterpret_cast<const Expr *
const *
>(getTrailingArgs());
1684 assert(Arg <
getNumArgs() &&
"Arg access out of range!");
1688 assert(Arg <
getNumArgs() &&
"Arg access out of range!");
1694 assert(Arg <
getNumArgs() &&
"Arg access out of range!");
1712 return T->getStmtClass() == CXXConstructExprClass ||
1713 T->getStmtClass() == CXXTemporaryObjectExprClass;
1739 LLVM_PREFERRED_TYPE(
bool)
1740 unsigned ConstructsVirtualBase : 1;
1744 LLVM_PREFERRED_TYPE(
bool)
1745 unsigned InheritedFromVirtualBase : 1;
1753 bool InheritedFromVirtualBase)
1755 Constructor(Ctor), Loc(Loc),
1756 ConstructsVirtualBase(ConstructsVirtualBase),
1757 InheritedFromVirtualBase(InheritedFromVirtualBase) {
1764 :
Expr(CXXInheritedCtorInitExprClass, Empty),
1765 ConstructsVirtualBase(
false), InheritedFromVirtualBase(
false) {}
1789 return T->getStmtClass() == CXXInheritedCtorInitExprClass;
1810 private llvm::TrailingObjects<CXXFunctionalCastExpr, CXXBaseSpecifier *,
1811 FPOptionsOverride> {
1822 LParenLoc(lParenLoc), RParenLoc(rParenLoc) {
1832 unsigned numTrailingObjects(OverloadToken<CXXBaseSpecifier *>)
const {
1860 return T->getStmtClass() == CXXFunctionalCastExprClass;
1891 bool HadMultipleCandidates,
bool ListInitialization,
1892 bool StdInitListInitialization,
1893 bool ZeroInitialization);
1901 SourceRange ParenOrBraceRange,
bool HadMultipleCandidates,
1902 bool ListInitialization,
bool StdInitListInitialization,
1903 bool ZeroInitialization);
1914 return T->getStmtClass() == CXXTemporaryObjectExprClass;
1918Stmt **CXXConstructExpr::getTrailingArgs() {
1919 if (
auto *E = dyn_cast<CXXTemporaryObjectExpr>(
this))
1920 return reinterpret_cast<Stmt **
>(E + 1);
1922 "Unexpected class deriving from CXXConstructExpr!");
1923 return reinterpret_cast<Stmt **
>(
this + 1);
1948 private llvm::TrailingObjects<LambdaExpr, Stmt *> {
1972 SourceLocation ClosingBrace,
bool ContainsUnexpandedParameterPack);
1977 Stmt **getStoredStmts() {
return getTrailingObjects<Stmt *>(); }
1978 Stmt *
const *getStoredStmts()
const {
return getTrailingObjects<Stmt *>(); }
1980 void initBodyIfNeeded()
const;
1991 bool ExplicitParams,
bool ExplicitResultType,
1993 bool ContainsUnexpandedParameterPack);
1998 unsigned NumCaptures);
2075 return reinterpret_cast<Expr **
>(getStoredStmts());
2081 return reinterpret_cast<Expr *
const *
>(getStoredStmts());
2141 const auto *ConstThis =
this;
2142 return const_cast<CompoundStmt *
>(ConstThis->getCompoundStmtBody());
2159 return T->getStmtClass() == LambdaExprClass;
2163 return IntroducerRange.getBegin();
2192 :
Expr(CXXScalarValueInitExprClass, Shell) {}
2206 return T->getStmtClass() == CXXScalarValueInitExprClass;
2234 private llvm::TrailingObjects<CXXNewExpr, Stmt *, SourceRange> {
2237 friend TrailingObjects;
2269 unsigned arraySizeOffset()
const {
return 0; }
2270 unsigned initExprOffset()
const {
return arraySizeOffset() +
isArray(); }
2271 unsigned placementNewArgsOffset()
const {
2275 unsigned numTrailingObjects(OverloadToken<Stmt *>)
const {
2279 unsigned numTrailingObjects(OverloadToken<SourceRange>)
const {
2284 CXXNewExpr(
bool IsGlobalNew, FunctionDecl *OperatorNew,
2285 FunctionDecl *OperatorDelete,
bool ShouldPassAlignment,
2286 bool UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs,
2287 SourceRange TypeIdParens, std::optional<Expr *> ArraySize,
2289 QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,
2290 SourceRange DirectInitRange);
2293 CXXNewExpr(EmptyShell Empty,
bool IsArray,
unsigned NumPlacementArgs,
2294 bool IsParenTypeId);
2299 Create(
const ASTContext &Ctx,
bool IsGlobalNew, FunctionDecl *OperatorNew,
2300 FunctionDecl *OperatorDelete,
bool ShouldPassAlignment,
2301 bool UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs,
2302 SourceRange TypeIdParens, std::optional<Expr *> ArraySize,
2304 QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,
2305 SourceRange DirectInitRange);
2308 static CXXNewExpr *
CreateEmpty(
const ASTContext &Ctx,
bool IsArray,
2309 bool HasInit,
unsigned NumPlacementArgs,
2310 bool IsParenTypeId);
2317 return AllocatedTypeInfo;
2349 return std::nullopt;
2352 cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]))
2355 return std::nullopt;
2363 return std::nullopt;
2366 cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]))
2369 return std::nullopt;
2377 return reinterpret_cast<Expr **
>(getTrailingObjects<Stmt *>() +
2378 placementNewArgsOffset());
2391 return isParenTypeId() ? getTrailingObjects<SourceRange>()[0]
2409 ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])
2414 ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])
2446 return getTrailingObjects<Stmt *>() + placementNewArgsOffset();
2452 return getTrailingObjects<Stmt *>() + placementNewArgsOffset();
2462 return raw_arg_begin() + numTrailingObjects(OverloadToken<Stmt *>());
2465 return getTrailingObjects<Stmt *>();
2468 return raw_arg_begin() + numTrailingObjects(OverloadToken<Stmt *>());
2478 return T->getStmtClass() == CXXNewExprClass;
2498 Stmt *Argument =
nullptr;
2502 bool ArrayFormAsWritten,
bool UsualArrayDeleteWantsSize,
2505 OperatorDelete(OperatorDelete), Argument(Arg) {
2547 return T->getStmtClass() == CXXDeleteExprClass;
2562 llvm::PointerUnion<TypeSourceInfo *, const IdentifierInfo *>
Type;
2571 :
Type(II), Location(Loc) {}
2618 LLVM_PREFERRED_TYPE(
bool)
2652 :
Expr(CXXPseudoDestructorExprClass, Shell), IsArrow(
false) {}
2735 return Base->getBeginLoc();
2740 return T->getStmtClass() == CXXPseudoDestructorExprClass;
2761 private llvm::TrailingObjects<TypeTraitExpr, TypeSourceInfo *> {
2778 size_t numTrailingObjects(OverloadToken<TypeSourceInfo *>)
const {
2812 assert(I <
getNumArgs() &&
"Argument out-of-range");
2825 return T->getStmtClass() == TypeTraitExprClass;
2873 Value(value), Dimension(dimension), Loc(loc), RParen(rparen),
2874 QueriedType(queried) {
2875 assert(att <=
ATT_Last &&
"invalid enum value!");
2876 assert(
static_cast<unsigned>(att) == ATT &&
"ATT overflow!");
2881 :
Expr(ArrayTypeTraitExprClass, Empty), ATT(0) {}
2897 return T->getStmtClass() == ArrayTypeTraitExprClass;
2923 LLVM_PREFERRED_TYPE(
bool)
2933 Expr* QueriedExpression =
nullptr;
2941 ET(et),
Value(value), Loc(loc), RParen(rparen),
2942 QueriedExpression(queried) {
2943 assert(et <=
ET_Last &&
"invalid enum value!");
2944 assert(
static_cast<unsigned>(et) == ET &&
"ET overflow!");
2961 return T->getStmtClass() == ExpressionTraitExprClass;
2993 bool KnownDependent,
bool KnownInstantiationDependent,
2994 bool KnownContainsUnexpandedParameterPack);
2997 bool HasTemplateKWAndArgsInfo);
3042 if (isa<UnaryOperator>(E)) {
3043 assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
3044 E = cast<UnaryOperator>(E)->getSubExpr();
3047 Result.HasFormOfMemberPointer = (E == Ovl && Ovl->getQualifier());
3048 Result.IsAddressOfOperand =
true;
3051 Result.HasFormOfMemberPointer =
false;
3052 Result.IsAddressOfOperand =
false;
3053 Result.Expression = cast<OverloadExpr>(E);
3074 llvm::iterator_range<decls_iterator>
decls()
const {
3153 return T->getStmtClass() == UnresolvedLookupExprClass ||
3154 T->getStmtClass() == UnresolvedMemberExprClass;
3171 private llvm::TrailingObjects<UnresolvedLookupExpr, DeclAccessPair,
3172 ASTTemplateKWAndArgsInfo,
3173 TemplateArgumentLoc> {
3176 friend TrailingObjects;
3203 bool KnownDependent);
3206 bool HasTemplateKWAndArgsInfo);
3208 unsigned numTrailingObjects(OverloadToken<DeclAccessPair>)
const {
3212 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)
const {
3217 static UnresolvedLookupExpr *
3218 Create(
const ASTContext &Context, CXXRecordDecl *NamingClass,
3219 NestedNameSpecifierLoc QualifierLoc,
3220 const DeclarationNameInfo &NameInfo,
bool RequiresADL,
3221 UnresolvedSetIterator
Begin, UnresolvedSetIterator End,
3222 bool KnownDependent);
3227 static UnresolvedLookupExpr *
3228 Create(
const ASTContext &Context, CXXRecordDecl *NamingClass,
3229 NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
3230 const DeclarationNameInfo &NameInfo,
bool RequiresADL,
3231 const TemplateArgumentListInfo *Args, UnresolvedSetIterator
Begin,
3232 UnresolvedSetIterator End,
bool KnownDependent);
3234 static UnresolvedLookupExpr *
CreateEmpty(
const ASTContext &Context,
3235 unsigned NumResults,
3236 bool HasTemplateKWAndArgsInfo,
3237 unsigned NumTemplateArgs);
3251 return l.getBeginLoc();
3270 return T->getStmtClass() == UnresolvedLookupExprClass;
3290 private llvm::TrailingObjects<DependentScopeDeclRefExpr,
3291 ASTTemplateKWAndArgsInfo,
3292 TemplateArgumentLoc> {
3295 friend TrailingObjects;
3309 size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)
const {
3310 return hasTemplateKWAndArgsInfo();
3313 bool hasTemplateKWAndArgsInfo()
const {
3318 static DependentScopeDeclRefExpr *
3319 Create(
const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
3320 SourceLocation TemplateKWLoc,
const DeclarationNameInfo &NameInfo,
3321 const TemplateArgumentListInfo *TemplateArgs);
3323 static DependentScopeDeclRefExpr *
CreateEmpty(
const ASTContext &Context,
3324 bool HasTemplateKWAndArgsInfo,
3325 unsigned NumTemplateArgs);
3351 if (!hasTemplateKWAndArgsInfo())
3353 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
3359 if (!hasTemplateKWAndArgsInfo())
3361 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
3367 if (!hasTemplateKWAndArgsInfo())
3369 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
3382 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
3383 getTrailingObjects<TemplateArgumentLoc>(), List);
3390 return getTrailingObjects<TemplateArgumentLoc>();
3397 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
3417 return T->getStmtClass() == DependentScopeDeclRefExprClass;
3441 private llvm::TrailingObjects<
3443 llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>> {
3453 friend TrailingObjects;
3461 unsigned numObjects);
3464 bool CleanupsHaveSideEffects,
3492 return T->getStmtClass() == ExprWithCleanupsClass;
3526 private llvm::TrailingObjects<CXXUnresolvedConstructExpr, Expr *> {
3528 friend TrailingObjects;
3532 llvm::PointerIntPair<TypeSourceInfo *, 1> TypeAndInitForm;
3545 :
Expr(CXXUnresolvedConstructExprClass, Empty) {
3565 return TypeAndInitForm.getPointer();
3603 assert(I <
getNumArgs() &&
"Argument index out-of-range");
3608 assert(I <
getNumArgs() &&
"Argument index out-of-range");
3613 assert(I <
getNumArgs() &&
"Argument index out-of-range");
3625 return T->getStmtClass() == CXXUnresolvedConstructExprClass;
3635 auto **begin =
reinterpret_cast<Stmt **
>(
3650 private llvm::TrailingObjects<CXXDependentScopeMemberExpr,
3651 ASTTemplateKWAndArgsInfo,
3652 TemplateArgumentLoc, NamedDecl *> {
3655 friend TrailingObjects;
3691 bool hasTemplateKWAndArgsInfo()
const {
3695 bool hasFirstQualifierFoundInScope()
const {
3699 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)
const {
3700 return hasTemplateKWAndArgsInfo();
3703 unsigned numTrailingObjects(OverloadToken<TemplateArgumentLoc>)
const {
3707 unsigned numTrailingObjects(OverloadToken<NamedDecl *>)
const {
3708 return hasFirstQualifierFoundInScope();
3711 CXXDependentScopeMemberExpr(
const ASTContext &Ctx,
Expr *
Base,
3712 QualType BaseType,
bool IsArrow,
3713 SourceLocation OperatorLoc,
3714 NestedNameSpecifierLoc QualifierLoc,
3715 SourceLocation TemplateKWLoc,
3716 NamedDecl *FirstQualifierFoundInScope,
3717 DeclarationNameInfo MemberNameInfo,
3718 const TemplateArgumentListInfo *TemplateArgs);
3720 CXXDependentScopeMemberExpr(EmptyShell Empty,
bool HasTemplateKWAndArgsInfo,
3721 bool HasFirstQualifierFoundInScope);
3724 static CXXDependentScopeMemberExpr *
3725 Create(
const ASTContext &Ctx,
Expr *
Base, QualType BaseType,
bool IsArrow,
3726 SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
3727 SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope,
3728 DeclarationNameInfo MemberNameInfo,
3729 const TemplateArgumentListInfo *TemplateArgs);
3731 static CXXDependentScopeMemberExpr *
3732 CreateEmpty(
const ASTContext &Ctx,
bool HasTemplateKWAndArgsInfo,
3733 unsigned NumTemplateArgs,
bool HasFirstQualifierFoundInScope);
3741 return cast<Expr>(
Base)->isImplicitCXXThis();
3748 return cast<Expr>(
Base);
3783 if (!hasFirstQualifierFoundInScope())
3785 return *getTrailingObjects<NamedDecl *>();
3790 return MemberNameInfo;
3803 if (!hasTemplateKWAndArgsInfo())
3805 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
3811 if (!hasTemplateKWAndArgsInfo())
3813 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
3819 if (!hasTemplateKWAndArgsInfo())
3821 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
3835 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
3836 getTrailingObjects<TemplateArgumentLoc>(), List);
3845 return getTrailingObjects<TemplateArgumentLoc>();
3854 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
3863 return Base->getBeginLoc();
3876 return T->getStmtClass() == CXXDependentScopeMemberExprClass;
3910 private llvm::TrailingObjects<UnresolvedMemberExpr, DeclAccessPair,
3911 ASTTemplateKWAndArgsInfo,
3912 TemplateArgumentLoc> {
3915 friend TrailingObjects;
3953 bool HasTemplateKWAndArgsInfo);
3955 unsigned numTrailingObjects(OverloadToken<DeclAccessPair>)
const {
3959 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)
const {
3964 static UnresolvedMemberExpr *
3965 Create(
const ASTContext &Context,
bool HasUnresolvedUsing, Expr *
Base,
3966 QualType BaseType,
bool IsArrow, SourceLocation OperatorLoc,
3967 NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
3968 const DeclarationNameInfo &MemberNameInfo,
3969 const TemplateArgumentListInfo *TemplateArgs,
3970 UnresolvedSetIterator
Begin, UnresolvedSetIterator End);
3972 static UnresolvedMemberExpr *
CreateEmpty(
const ASTContext &Context,
3973 unsigned NumResults,
3974 bool HasTemplateKWAndArgsInfo,
3975 unsigned NumTemplateArgs);
3987 return cast<Expr>(
Base);
3991 return cast<Expr>(
Base);
4032 return Base->getBeginLoc();
4034 return l.getBeginLoc();
4045 return T->getStmtClass() == UnresolvedMemberExprClass;
4063 if (
auto *ULE = dyn_cast<UnresolvedLookupExpr>(
this))
4065 return cast<UnresolvedMemberExpr>(
this)->getTrailingObjects<
DeclAccessPair>();
4072 if (
auto *ULE = dyn_cast<UnresolvedLookupExpr>(
this))
4074 return cast<UnresolvedMemberExpr>(
this)
4079 if (
auto *ULE = dyn_cast<UnresolvedLookupExpr>(
this))
4081 return cast<UnresolvedMemberExpr>(
this)
4086 if (
auto *ULE = dyn_cast<UnresolvedLookupExpr>(
this))
4087 return ULE->getNamingClass();
4088 return cast<UnresolvedMemberExpr>(
this)->getNamingClass();
4105 Operand(Operand), Range(Keyword, RParen) {
4121 return T->getStmtClass() == CXXNoexceptExprClass;
4160 unsigned NumExpansions;
4166 std::optional<unsigned> NumExpansions)
4169 EllipsisLoc(EllipsisLoc),
4170 NumExpansions(NumExpansions ? *NumExpansions + 1 : 0),
4191 return NumExpansions - 1;
4193 return std::nullopt;
4203 return T->getStmtClass() == PackExpansionExprClass;
4227 private llvm::TrailingObjects<SizeOfPackExpr, TemplateArgument> {
4230 friend TrailingObjects;
4260 std::optional<unsigned> Length,
4263 OperatorLoc(OperatorLoc), PackLoc(PackLoc), RParenLoc(RParenLoc),
4264 Length(Length ? *Length : PartialArgs.size()), Pack(Pack) {
4265 assert((!Length || PartialArgs.empty()) &&
4266 "have partial args for non-dependent sizeof... expression");
4267 auto *Args = getTrailingObjects<TemplateArgument>();
4268 std::uninitialized_copy(PartialArgs.begin(), PartialArgs.end(), Args);
4270 : ExprDependence::ValueInstantiation);
4275 :
Expr(SizeOfPackExprClass, Empty), Length(NumPartialArgs) {}
4278 static SizeOfPackExpr *
4279 Create(ASTContext &Context, SourceLocation OperatorLoc, NamedDecl *Pack,
4280 SourceLocation PackLoc, SourceLocation RParenLoc,
4281 std::optional<unsigned> Length = std::nullopt,
4282 ArrayRef<TemplateArgument> PartialArgs = std::nullopt);
4284 unsigned NumPartialArgs);
4304 "Cannot get the length of a value-dependent pack size expression");
4320 const auto *Args = getTrailingObjects<TemplateArgument>();
4328 return T->getStmtClass() == SizeOfPackExprClass;
4343 private llvm::TrailingObjects<PackIndexingExpr, Expr *> {
4346 friend TrailingObjects;
4356 size_t TransformedExpressions;
4362 EllipsisLoc(EllipsisLoc), RSquareLoc(RSquareLoc),
4363 SubExprs{PackIdExpr, IndexExpr},
4364 TransformedExpressions(SubstitutedExprs.size()) {
4366 auto *Exprs = getTrailingObjects<Expr *>();
4367 std::uninitialized_copy(SubstitutedExprs.begin(), SubstitutedExprs.end(),
4376 PackIndexingExpr(EmptyShell Empty) :
Expr(PackIndexingExprClass, Empty) {}
4378 unsigned numTrailingObjects(OverloadToken<Expr *>)
const {
4379 return TransformedExpressions;
4383 static PackIndexingExpr *
Create(ASTContext &Context,
4384 SourceLocation EllipsisLoc,
4385 SourceLocation RSquareLoc,
Expr *PackIdExpr,
4386 Expr *IndexExpr, std::optional<int64_t> Index,
4387 ArrayRef<Expr *> SubstitutedExprs = {});
4389 unsigned NumTransformedExprs);
4411 return std::nullopt;
4414 assert(Index.isNonNegative() &&
"Invalid index");
4415 return static_cast<unsigned>(Index.getExtValue());
4420 assert(Index &&
"extracting the indexed expression of a dependant pack");
4421 return getTrailingObjects<Expr *>()[*Index];
4425 return {getTrailingObjects<Expr *>(), TransformedExpressions};
4429 return T->getStmtClass() == PackIndexingExprClass;
4452 llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndRef;
4454 unsigned Index : 15;
4455 unsigned PackIndex : 16;
4458 :
Expr(SubstNonTypeTemplateParmExprClass, Empty) {}
4463 Decl *AssociatedDecl,
unsigned Index,
4464 std::optional<unsigned> PackIndex,
bool RefParam)
4465 :
Expr(SubstNonTypeTemplateParmExprClass, Ty, ValueKind,
OK_Ordinary),
4466 Replacement(Replacement),
4467 AssociatedDeclAndRef(AssociatedDecl, RefParam), Index(Index),
4468 PackIndex(PackIndex ? *PackIndex + 1 : 0) {
4469 assert(AssociatedDecl !=
nullptr);
4492 return std::nullopt;
4493 return PackIndex - 1;
4504 return s->getStmtClass() == SubstNonTypeTemplateParmExprClass;
4532 Decl *AssociatedDecl;
4539 unsigned NumArguments : 16;
4541 unsigned Index : 16;
4547 :
Expr(SubstNonTypeTemplateParmPackExprClass, Empty) {}
4553 Decl *AssociatedDecl,
unsigned Index);
4577 return T->getStmtClass() == SubstNonTypeTemplateParmPackExprClass;
4606 private llvm::TrailingObjects<FunctionParmPackExpr, VarDecl *> {
4609 friend TrailingObjects;
4618 unsigned NumParameters;
4630 unsigned NumParams);
4654 return T->getStmtClass() == FunctionParmPackExprClass;
4691 llvm::PointerUnion<Stmt *, LifetimeExtendedTemporaryDecl *> State;
4695 bool BoundToLvalueReference,
4699 :
Expr(MaterializeTemporaryExprClass, Empty) {}
4706 ? State.get<
Stmt *>()
4721 "the temporary has not been lifetime extended");
4737 return State.is<
Stmt *>() ?
nullptr
4748 return State.is<
Stmt *>() ? 0
4770 return T->getStmtClass() == MaterializeTemporaryExprClass;
4775 return State.is<
Stmt *>()
4776 ?
child_range(State.getAddrOfPtr1(), State.getAddrOfPtr1() + 1)
4781 return State.is<
Stmt *>()
4783 State.getAddrOfPtr1() + 1)
4802 enum SubExpr { Callee, LHS, RHS, Count };
4809 unsigned NumExpansions;
4810 Stmt *SubExprs[SubExpr::Count];
4817 std::optional<unsigned> NumExpansions)
4819 LParenLoc(LParenLoc), EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc),
4820 NumExpansions(NumExpansions ? *NumExpansions + 1 : 0), Opcode(Opcode) {
4821 SubExprs[SubExpr::Callee] = Callee;
4822 SubExprs[SubExpr::LHS] = LHS;
4823 SubExprs[SubExpr::RHS] = RHS;
4856 return NumExpansions - 1;
4857 return std::nullopt;
4877 return T->getStmtClass() == CXXFoldExprClass;
4882 return child_range(SubExprs, SubExprs + SubExpr::Count);
4920 private llvm::TrailingObjects<CXXParenListInitExpr, Expr *> {
4926 unsigned NumUserSpecifiedExprs;
4928 llvm::PointerUnion<Expr *, FieldDecl *> ArrayFillerOrUnionFieldInit;
4934 NumExprs(Args.size()), NumUserSpecifiedExprs(NumUserSpecifiedExprs),
4935 InitLoc(InitLoc), LParenLoc(LParenLoc), RParenLoc(RParenLoc) {
4936 std::copy(Args.begin(), Args.end(), getTrailingObjects<Expr *>());
4937 assert(NumExprs >= NumUserSpecifiedExprs &&
4938 "number of user specified inits is greater than the number of "
4943 size_t numTrailingObjects(OverloadToken<Expr *>)
const {
return NumExprs; }
4946 static CXXParenListInitExpr *
4947 Create(ASTContext &
C, ArrayRef<Expr *> Args, QualType
T,
4948 unsigned NumUserSpecifiedExprs, SourceLocation InitLoc,
4949 SourceLocation LParenLoc, SourceLocation RParenLoc);
4951 static CXXParenListInitExpr *
CreateEmpty(ASTContext &
C,
unsigned numExprs,
4955 :
Expr(CXXParenListInitExprClass, Empty), NumExprs(NumExprs),
4956 NumUserSpecifiedExprs(0) {}
4961 return ArrayRef(getTrailingObjects<Expr *>(), NumExprs);
4965 return ArrayRef(getTrailingObjects<Expr *>(), NumExprs);
4969 return ArrayRef(getTrailingObjects<Expr *>(), NumUserSpecifiedExprs);
4973 return ArrayRef(getTrailingObjects<Expr *>(), NumUserSpecifiedExprs);
4989 return ArrayFillerOrUnionFieldInit.dyn_cast<
Expr *>();
4993 return ArrayFillerOrUnionFieldInit.dyn_cast<
Expr *>();
4997 ArrayFillerOrUnionFieldInit = FD;
5001 return ArrayFillerOrUnionFieldInit.dyn_cast<
FieldDecl *>();
5005 return ArrayFillerOrUnionFieldInit.dyn_cast<
FieldDecl *>();
5009 Stmt **
Begin =
reinterpret_cast<Stmt **
>(getTrailingObjects<Expr *>());
5015 reinterpret_cast<Stmt *
const *
>(getTrailingObjects<Expr *>());
5020 return T->getStmtClass() == CXXParenListInitExprClass;
5042 enum SubExpr { Operand, Common, Ready, Suspend, Resume, Count };
5044 Stmt *SubExprs[SubExpr::Count];
5056 KeywordLoc(KeywordLoc), OpaqueValue(OpaqueValue) {
5057 SubExprs[SubExpr::Operand] = Operand;
5058 SubExprs[SubExpr::Common] = Common;
5059 SubExprs[SubExpr::Ready] = Ready;
5060 SubExprs[SubExpr::Suspend] = Suspend;
5061 SubExprs[SubExpr::Resume] = Resume;
5069 "wrong constructor for non-dependent co_await/co_yield expression");
5070 SubExprs[SubExpr::Operand] = Operand;
5071 SubExprs[SubExpr::Common] = Common;
5072 SubExprs[SubExpr::Ready] =
nullptr;
5073 SubExprs[SubExpr::Suspend] =
nullptr;
5074 SubExprs[SubExpr::Resume] =
nullptr;
5079 SubExprs[SubExpr::Operand] =
nullptr;
5080 SubExprs[SubExpr::Common] =
nullptr;
5081 SubExprs[SubExpr::Ready] =
nullptr;
5082 SubExprs[SubExpr::Suspend] =
nullptr;
5083 SubExprs[SubExpr::Resume] =
nullptr;
5087 return static_cast<Expr*
>(SubExprs[SubExpr::Common]);
5094 return static_cast<Expr*
>(SubExprs[SubExpr::Ready]);
5098 return static_cast<Expr*
>(SubExprs[SubExpr::Suspend]);
5102 return static_cast<Expr*
>(SubExprs[SubExpr::Resume]);
5107 return static_cast<Expr *
>(SubExprs[SubExpr::Operand]);
5112 assert(SuspendExpr);
5114 auto SuspendType = SuspendExpr->getType();
5116 if (SuspendType->isVoidType())
5118 if (SuspendType->isBooleanType())
5124 assert(SuspendType->isVoidPointerType());
5137 return child_range(SubExprs, SubExprs + SubExpr::Count);
5145 return T->getStmtClass() == CoawaitExprClass ||
5146 T->getStmtClass() == CoyieldExprClass;
5159 Ready, Suspend, Resume, OpaqueValue) {
5164 Expr *Common,
bool IsImplicit =
false)
5177 return T->getStmtClass() == CoawaitExprClass;
5193 KeywordLoc(KeywordLoc) {
5197 "wrong constructor for non-dependent co_await/co_yield expression");
5199 SubExprs[1] = OpCoawait;
5204 :
Expr(DependentCoawaitExprClass, Empty) {}
5209 return cast<UnresolvedLookupExpr>(SubExprs[1]);
5227 return T->getStmtClass() == DependentCoawaitExprClass;
5240 Ready, Suspend, Resume, OpaqueValue) {}
5249 return T->getStmtClass() == CoyieldExprClass;
5258 private llvm::TrailingObjects<BuiltinBitCastExpr, CXXBaseSpecifier *> {
5261 friend TrailingObjects;
5272 KWLoc(KWLoc), RParenLoc(RParenLoc) {}
5280 return T->getStmtClass() == BuiltinBitCastExprClass;
This file provides AST data structures related to concepts.
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.
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?
CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee, SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Opcode, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, std::optional< unsigned > NumExpansions)
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 a value-initialized rvalue of type T, which is a non-class type.
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)
QualType getTypeOperand(ASTContext &Context) const
Retrieves the type operand of this typeid() expression after various required adjustments (removing r...
CXXTypeidExpr(QualType Ty, TypeSourceInfo *Operand, SourceRange R)
bool isTypeOperand() const
TypeSourceInfo * getTypeOperandSourceInfo() const
Retrieve source information for the type operand.
SourceLocation getBeginLoc() const LLVM_READONLY
Expr * getExprOperand() const
bool isMostDerived(ASTContext &Context) const
Best-effort check if the expression operand refers to a most derived object.
SourceRange getSourceRange() const LLVM_READONLY
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)
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).
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
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-...
unsigned getManglingNumber() const
Stmt::child_range childrenExpr()
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Expr * getTemporaryExpr()
Retrieve the expression to which the temporary materialization conversion was applied.
ValueDecl * getExtendingDecl()
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 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
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
Expr * getPackIdExpression() const
Expr * getSelectedExpr() const
static bool classof(const Stmt *T)
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.
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 isSpecificBuiltinType(unsigned K) const
Test for a particular builtin 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.
@ Create
'copyin' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...
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)
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 ...
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 HasFormOfMemberPointer
OverloadExpr * Expression
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....