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)
191 unsigned MinNumArgs = 0);
234 enum { CONFIG, END_PREARG };
251 unsigned MinNumArgs = 0);
254 unsigned NumArgs,
bool HasFPFeatures,
258 return cast_or_null<CallExpr>(
getPreArg(CONFIG));
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) {}
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);
478 private llvm::TrailingObjects<CXXDynamicCastExpr, CXXBaseSpecifier *> {
484 false, writtenTy, l, RParenLoc,
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,
601 private llvm::TrailingObjects<CXXAddrspaceCastExpr, CXXBaseSpecifier *> {
606 false, writtenTy, l, RParenLoc,
661 unsigned NumArgs,
bool HasFPOptions,
715 return S->getStmtClass() == UserDefinedLiteralClass;
730 :
Expr(CXXBoolLiteralExprClass, Empty) {}
774 :
Expr(CXXNullPtrLiteralExprClass, Empty) {}
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 *>());
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)
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 *>());
1123 auto **begin =
reinterpret_cast<Stmt **
>(&Operand);
1204 bool IsThrownVariableInScope)
1239 return child_range(&Operand, Operand ? &Operand + 1 : &Operand);
1254 private llvm::TrailingObjects<CXXDefaultArgExpr, Expr *> {
1257 friend TrailingObjects;
1268 Param->hasUnparsedDefaultArg()
1269 ? Param->
getType().getNonReferenceType()
1270 : Param->getDefaultArg()->
getType(),
1273 Param(Param), UsedContext(UsedContext) {
1277 *getTrailingObjects<Expr *>() = RewrittenExpr;
1282 :
Expr(CXXDefaultArgExprClass, Empty) {
1287 static CXXDefaultArgExpr *
CreateEmpty(
const ASTContext &
C,
1288 bool HasRewrittenInit);
1292 static CXXDefaultArgExpr *
Create(
const ASTContext &
C, SourceLocation Loc,
1293 ParmVarDecl *Param,
Expr *RewrittenExpr,
1294 DeclContext *UsedContext);
1361 private llvm::TrailingObjects<CXXDefaultInitExpr, Expr *> {
1365 friend TrailingObjects;
1374 Expr *RewrittenInitExpr);
1377 :
Expr(CXXDefaultInitExprClass, Empty) {
1383 bool HasRewrittenInit);
1388 Expr *RewrittenInitExpr);
1408 return *getTrailingObjects<Expr *>();
1415 return *getTrailingObjects<Expr *>();
1448 : Destructor(destructor) {}
1477 Stmt *SubExpr =
nullptr;
1480 :
Expr(CXXBindTemporaryExprClass, SubExpr->getType(),
VK_PRValue,
1482 Temp(temp), SubExpr(SubExpr) {
1488 :
Expr(CXXBindTemporaryExprClass, Empty) {}
1557 inline Stmt **getTrailingArgs();
1558 const Stmt *
const *getTrailingArgs()
const {
1567 bool ListInitialization,
bool StdInitListInitialization,
1577 return NumArgs *
sizeof(
Stmt *);
1585 bool HadMultipleCandidates,
bool ListInitialization,
1586 bool StdInitListInitialization,
bool ZeroInitialization,
1666 return reinterpret_cast<const Expr *
const *
>(getTrailingArgs());
1674 assert(Arg <
getNumArgs() &&
"Arg access out of range!");
1678 assert(Arg <
getNumArgs() &&
"Arg access out of range!");
1684 assert(Arg <
getNumArgs() &&
"Arg access out of range!");
1729 LLVM_PREFERRED_TYPE(
bool)
1730 unsigned ConstructsVirtualBase : 1;
1734 LLVM_PREFERRED_TYPE(
bool)
1735 unsigned InheritedFromVirtualBase : 1;
1743 bool InheritedFromVirtualBase)
1745 Constructor(Ctor), Loc(Loc),
1746 ConstructsVirtualBase(ConstructsVirtualBase),
1747 InheritedFromVirtualBase(InheritedFromVirtualBase) {
1754 :
Expr(CXXInheritedCtorInitExprClass, Empty),
1755 ConstructsVirtualBase(
false), InheritedFromVirtualBase(
false) {}
1779 return T->
getStmtClass() == CXXInheritedCtorInitExprClass;
1800 private llvm::TrailingObjects<CXXFunctionalCastExpr, CXXBaseSpecifier *,
1801 FPOptionsOverride> {
1812 LParenLoc(lParenLoc), RParenLoc(rParenLoc) {
1822 unsigned numTrailingObjects(OverloadToken<CXXBaseSpecifier *>)
const {
1850 return T->getStmtClass() == CXXFunctionalCastExprClass;
1881 bool HadMultipleCandidates,
bool ListInitialization,
1882 bool StdInitListInitialization,
1883 bool ZeroInitialization);
1891 SourceRange ParenOrBraceRange,
bool HadMultipleCandidates,
1892 bool ListInitialization,
bool StdInitListInitialization,
1893 bool ZeroInitialization);
1904 return T->getStmtClass() == CXXTemporaryObjectExprClass;
1908Stmt **CXXConstructExpr::getTrailingArgs() {
1909 if (
auto *E = dyn_cast<CXXTemporaryObjectExpr>(
this))
1910 return reinterpret_cast<Stmt **
>(E + 1);
1912 "Unexpected class deriving from CXXConstructExpr!");
1913 return reinterpret_cast<Stmt **
>(
this + 1);
1938 private llvm::TrailingObjects<LambdaExpr, Stmt *> {
1962 SourceLocation ClosingBrace,
bool ContainsUnexpandedParameterPack);
1967 Stmt **getStoredStmts() {
return getTrailingObjects<Stmt *>(); }
1968 Stmt *
const *getStoredStmts()
const {
return getTrailingObjects<Stmt *>(); }
1970 void initBodyIfNeeded()
const;
1981 bool ExplicitParams,
bool ExplicitResultType,
1983 bool ContainsUnexpandedParameterPack);
1988 unsigned NumCaptures);
2065 return reinterpret_cast<Expr **
>(getStoredStmts());
2071 return reinterpret_cast<Expr *
const *
>(getStoredStmts());
2131 const auto *ConstThis =
this;
2132 return const_cast<CompoundStmt *
>(ConstThis->getCompoundStmtBody());
2153 return IntroducerRange.getBegin();
2182 :
Expr(CXXScalarValueInitExprClass, Shell) {}
2196 return T->
getStmtClass() == CXXScalarValueInitExprClass;
2224 private llvm::TrailingObjects<CXXNewExpr, Stmt *, SourceRange> {
2227 friend TrailingObjects;
2259 unsigned arraySizeOffset()
const {
return 0; }
2260 unsigned initExprOffset()
const {
return arraySizeOffset() +
isArray(); }
2261 unsigned placementNewArgsOffset()
const {
2265 unsigned numTrailingObjects(OverloadToken<Stmt *>)
const {
2269 unsigned numTrailingObjects(OverloadToken<SourceRange>)
const {
2274 CXXNewExpr(
bool IsGlobalNew, FunctionDecl *OperatorNew,
2275 FunctionDecl *OperatorDelete,
bool ShouldPassAlignment,
2276 bool UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs,
2277 SourceRange TypeIdParens, std::optional<Expr *> ArraySize,
2279 QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,
2280 SourceRange DirectInitRange);
2283 CXXNewExpr(EmptyShell Empty,
bool IsArray,
unsigned NumPlacementArgs,
2284 bool IsParenTypeId);
2289 Create(
const ASTContext &Ctx,
bool IsGlobalNew, FunctionDecl *OperatorNew,
2290 FunctionDecl *OperatorDelete,
bool ShouldPassAlignment,
2291 bool UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs,
2292 SourceRange TypeIdParens, std::optional<Expr *> ArraySize,
2294 QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,
2295 SourceRange DirectInitRange);
2298 static CXXNewExpr *
CreateEmpty(
const ASTContext &Ctx,
bool IsArray,
2299 bool HasInit,
unsigned NumPlacementArgs,
2300 bool IsParenTypeId);
2307 return AllocatedTypeInfo;
2339 return std::nullopt;
2342 cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]))
2345 return std::nullopt;
2353 return std::nullopt;
2356 cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]))
2359 return std::nullopt;
2367 return reinterpret_cast<Expr **
>(getTrailingObjects<Stmt *>() +
2368 placementNewArgsOffset());
2381 return isParenTypeId() ? getTrailingObjects<SourceRange>()[0]
2399 ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])
2404 ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])
2436 return getTrailingObjects<Stmt *>() + placementNewArgsOffset();
2442 return getTrailingObjects<Stmt *>() + placementNewArgsOffset();
2452 return raw_arg_begin() + numTrailingObjects(OverloadToken<Stmt *>());
2455 return getTrailingObjects<Stmt *>();
2458 return raw_arg_begin() + numTrailingObjects(OverloadToken<Stmt *>());
2488 Stmt *Argument =
nullptr;
2492 bool ArrayFormAsWritten,
bool UsualArrayDeleteWantsSize,
2495 OperatorDelete(OperatorDelete), Argument(Arg) {
2552 llvm::PointerUnion<TypeSourceInfo *, IdentifierInfo *>
Type;
2561 :
Type(II), Location(Loc) {}
2608 LLVM_PREFERRED_TYPE(
bool)
2642 :
Expr(CXXPseudoDestructorExprClass, Shell), IsArrow(
false) {}
2725 return Base->getBeginLoc();
2730 return T->getStmtClass() == CXXPseudoDestructorExprClass;
2751 private llvm::TrailingObjects<TypeTraitExpr, TypeSourceInfo *> {
2768 size_t numTrailingObjects(OverloadToken<TypeSourceInfo *>)
const {
2802 assert(I <
getNumArgs() &&
"Argument out-of-range");
2863 Value(value), Dimension(dimension), Loc(loc), RParen(rparen),
2864 QueriedType(queried) {
2865 assert(att <=
ATT_Last &&
"invalid enum value!");
2866 assert(
static_cast<unsigned>(att) == ATT &&
"ATT overflow!");
2871 :
Expr(ArrayTypeTraitExprClass, Empty), ATT(0) {}
2913 LLVM_PREFERRED_TYPE(
bool)
2923 Expr* QueriedExpression =
nullptr;
2931 ET(et),
Value(value), Loc(loc), RParen(rparen),
2932 QueriedExpression(queried) {
2933 assert(et <=
ET_Last &&
"invalid enum value!");
2934 assert(
static_cast<unsigned>(et) == ET &&
"ET overflow!");
2983 bool KnownDependent,
bool KnownInstantiationDependent,
2984 bool KnownContainsUnexpandedParameterPack);
2987 bool HasTemplateKWAndArgsInfo);
3032 if (isa<UnaryOperator>(E)) {
3033 assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
3034 E = cast<UnaryOperator>(E)->getSubExpr();
3037 Result.HasFormOfMemberPointer = (E == Ovl && Ovl->getQualifier());
3038 Result.IsAddressOfOperand =
true;
3041 Result.HasFormOfMemberPointer =
false;
3042 Result.IsAddressOfOperand =
false;
3043 Result.Expression = cast<OverloadExpr>(E);
3064 llvm::iterator_range<decls_iterator>
decls()
const {
3143 return T->
getStmtClass() == UnresolvedLookupExprClass ||
3161 private llvm::TrailingObjects<UnresolvedLookupExpr, DeclAccessPair,
3162 ASTTemplateKWAndArgsInfo,
3163 TemplateArgumentLoc> {
3166 friend TrailingObjects;
3194 bool KnownDependent);
3197 bool HasTemplateKWAndArgsInfo);
3199 unsigned numTrailingObjects(OverloadToken<DeclAccessPair>)
const {
3203 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)
const {
3208 static UnresolvedLookupExpr *
3209 Create(
const ASTContext &Context, CXXRecordDecl *NamingClass,
3210 NestedNameSpecifierLoc QualifierLoc,
3211 const DeclarationNameInfo &NameInfo,
bool RequiresADL,
bool Overloaded,
3212 UnresolvedSetIterator
Begin, UnresolvedSetIterator End);
3217 static UnresolvedLookupExpr *
3218 Create(
const ASTContext &Context, CXXRecordDecl *NamingClass,
3219 NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
3220 const DeclarationNameInfo &NameInfo,
bool RequiresADL,
3221 const TemplateArgumentListInfo *Args, UnresolvedSetIterator
Begin,
3222 UnresolvedSetIterator End,
bool KnownDependent);
3224 static UnresolvedLookupExpr *
CreateEmpty(
const ASTContext &Context,
3225 unsigned NumResults,
3226 bool HasTemplateKWAndArgsInfo,
3227 unsigned NumTemplateArgs);
3244 return l.getBeginLoc();
3283 private llvm::TrailingObjects<DependentScopeDeclRefExpr,
3284 ASTTemplateKWAndArgsInfo,
3285 TemplateArgumentLoc> {
3288 friend TrailingObjects;
3302 size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)
const {
3303 return hasTemplateKWAndArgsInfo();
3306 bool hasTemplateKWAndArgsInfo()
const {
3311 static DependentScopeDeclRefExpr *
3312 Create(
const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
3313 SourceLocation TemplateKWLoc,
const DeclarationNameInfo &NameInfo,
3314 const TemplateArgumentListInfo *TemplateArgs);
3316 static DependentScopeDeclRefExpr *
CreateEmpty(
const ASTContext &Context,
3317 bool HasTemplateKWAndArgsInfo,
3318 unsigned NumTemplateArgs);
3344 if (!hasTemplateKWAndArgsInfo())
3346 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
3352 if (!hasTemplateKWAndArgsInfo())
3354 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
3360 if (!hasTemplateKWAndArgsInfo())
3362 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
3375 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
3376 getTrailingObjects<TemplateArgumentLoc>(), List);
3383 return getTrailingObjects<TemplateArgumentLoc>();
3390 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
3410 return T->
getStmtClass() == DependentScopeDeclRefExprClass;
3434 private llvm::TrailingObjects<
3436 llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>> {
3446 friend TrailingObjects;
3454 unsigned numObjects);
3457 bool CleanupsHaveSideEffects,
3519 private llvm::TrailingObjects<CXXUnresolvedConstructExpr, Expr *> {
3521 friend TrailingObjects;
3525 llvm::PointerIntPair<TypeSourceInfo *, 1> TypeAndInitForm;
3538 :
Expr(CXXUnresolvedConstructExprClass, Empty) {
3558 return TypeAndInitForm.getPointer();
3596 assert(I <
getNumArgs() &&
"Argument index out-of-range");
3601 assert(I <
getNumArgs() &&
"Argument index out-of-range");
3606 assert(I <
getNumArgs() &&
"Argument index out-of-range");
3618 return T->
getStmtClass() == CXXUnresolvedConstructExprClass;
3628 auto **begin =
reinterpret_cast<Stmt **
>(
3643 private llvm::TrailingObjects<CXXDependentScopeMemberExpr,
3644 ASTTemplateKWAndArgsInfo,
3645 TemplateArgumentLoc, NamedDecl *> {
3648 friend TrailingObjects;
3684 bool hasTemplateKWAndArgsInfo()
const {
3688 bool hasFirstQualifierFoundInScope()
const {
3692 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)
const {
3693 return hasTemplateKWAndArgsInfo();
3696 unsigned numTrailingObjects(OverloadToken<TemplateArgumentLoc>)
const {
3700 unsigned numTrailingObjects(OverloadToken<NamedDecl *>)
const {
3701 return hasFirstQualifierFoundInScope();
3704 CXXDependentScopeMemberExpr(
const ASTContext &Ctx,
Expr *
Base,
3705 QualType BaseType,
bool IsArrow,
3706 SourceLocation OperatorLoc,
3707 NestedNameSpecifierLoc QualifierLoc,
3708 SourceLocation TemplateKWLoc,
3709 NamedDecl *FirstQualifierFoundInScope,
3710 DeclarationNameInfo MemberNameInfo,
3711 const TemplateArgumentListInfo *TemplateArgs);
3713 CXXDependentScopeMemberExpr(EmptyShell Empty,
bool HasTemplateKWAndArgsInfo,
3714 bool HasFirstQualifierFoundInScope);
3717 static CXXDependentScopeMemberExpr *
3718 Create(
const ASTContext &Ctx,
Expr *
Base, QualType BaseType,
bool IsArrow,
3719 SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
3720 SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope,
3721 DeclarationNameInfo MemberNameInfo,
3722 const TemplateArgumentListInfo *TemplateArgs);
3724 static CXXDependentScopeMemberExpr *
3725 CreateEmpty(
const ASTContext &Ctx,
bool HasTemplateKWAndArgsInfo,
3726 unsigned NumTemplateArgs,
bool HasFirstQualifierFoundInScope);
3734 return cast<Expr>(
Base)->isImplicitCXXThis();
3741 return cast<Expr>(
Base);
3776 if (!hasFirstQualifierFoundInScope())
3778 return *getTrailingObjects<NamedDecl *>();
3783 return MemberNameInfo;
3796 if (!hasTemplateKWAndArgsInfo())
3798 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
3804 if (!hasTemplateKWAndArgsInfo())
3806 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
3812 if (!hasTemplateKWAndArgsInfo())
3814 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
3828 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
3829 getTrailingObjects<TemplateArgumentLoc>(), List);
3838 return getTrailingObjects<TemplateArgumentLoc>();
3847 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
3856 return Base->getBeginLoc();
3869 return T->
getStmtClass() == CXXDependentScopeMemberExprClass;
3903 private llvm::TrailingObjects<UnresolvedMemberExpr, DeclAccessPair,
3904 ASTTemplateKWAndArgsInfo,
3905 TemplateArgumentLoc> {
3908 friend TrailingObjects;
3946 bool HasTemplateKWAndArgsInfo);
3948 unsigned numTrailingObjects(OverloadToken<DeclAccessPair>)
const {
3952 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)
const {
3957 static UnresolvedMemberExpr *
3958 Create(
const ASTContext &Context,
bool HasUnresolvedUsing, Expr *
Base,
3959 QualType BaseType,
bool IsArrow, SourceLocation OperatorLoc,
3960 NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
3961 const DeclarationNameInfo &MemberNameInfo,
3962 const TemplateArgumentListInfo *TemplateArgs,
3963 UnresolvedSetIterator
Begin, UnresolvedSetIterator End);
3965 static UnresolvedMemberExpr *
CreateEmpty(
const ASTContext &Context,
3966 unsigned NumResults,
3967 bool HasTemplateKWAndArgsInfo,
3968 unsigned NumTemplateArgs);
3980 return cast<Expr>(
Base);
3984 return cast<Expr>(
Base);
4025 return Base->getBeginLoc();
4027 return l.getBeginLoc();
4056 if (
auto *ULE = dyn_cast<UnresolvedLookupExpr>(
this))
4058 return cast<UnresolvedMemberExpr>(
this)->getTrailingObjects<
DeclAccessPair>();
4065 if (
auto *ULE = dyn_cast<UnresolvedLookupExpr>(
this))
4067 return cast<UnresolvedMemberExpr>(
this)
4072 if (
auto *ULE = dyn_cast<UnresolvedLookupExpr>(
this))
4074 return cast<UnresolvedMemberExpr>(
this)
4079 if (
auto *ULE = dyn_cast<UnresolvedLookupExpr>(
this))
4080 return ULE->getNamingClass();
4081 return cast<UnresolvedMemberExpr>(
this)->getNamingClass();
4098 Operand(Operand), Range(Keyword, RParen) {
4153 unsigned NumExpansions;
4159 std::optional<unsigned> NumExpansions)
4162 EllipsisLoc(EllipsisLoc),
4163 NumExpansions(NumExpansions ? *NumExpansions + 1 : 0),
4184 return NumExpansions - 1;
4186 return std::nullopt;
4220 private llvm::TrailingObjects<SizeOfPackExpr, TemplateArgument> {
4223 friend TrailingObjects;
4253 std::optional<unsigned> Length,
4256 OperatorLoc(OperatorLoc), PackLoc(PackLoc), RParenLoc(RParenLoc),
4257 Length(Length ? *Length : PartialArgs.size()), Pack(Pack) {
4258 assert((!Length || PartialArgs.empty()) &&
4259 "have partial args for non-dependent sizeof... expression");
4260 auto *Args = getTrailingObjects<TemplateArgument>();
4261 std::uninitialized_copy(PartialArgs.begin(), PartialArgs.end(), Args);
4263 : ExprDependence::ValueInstantiation);
4268 :
Expr(SizeOfPackExprClass, Empty), Length(NumPartialArgs) {}
4271 static SizeOfPackExpr *
4272 Create(ASTContext &Context, SourceLocation OperatorLoc, NamedDecl *Pack,
4273 SourceLocation PackLoc, SourceLocation RParenLoc,
4274 std::optional<unsigned> Length = std::nullopt,
4275 ArrayRef<TemplateArgument> PartialArgs = std::nullopt);
4277 unsigned NumPartialArgs);
4297 "Cannot get the length of a value-dependent pack size expression");
4313 const auto *Args = getTrailingObjects<TemplateArgument>();
4336 private llvm::TrailingObjects<PackIndexingExpr, Expr *> {
4339 friend TrailingObjects;
4349 size_t TransformedExpressions;
4355 EllipsisLoc(EllipsisLoc), RSquareLoc(RSquareLoc),
4356 SubExprs{PackIdExpr, IndexExpr},
4357 TransformedExpressions(SubstitutedExprs.size()) {
4359 auto *Exprs = getTrailingObjects<Expr *>();
4360 std::uninitialized_copy(SubstitutedExprs.begin(), SubstitutedExprs.end(),
4369 PackIndexingExpr(EmptyShell Empty) :
Expr(PackIndexingExprClass, Empty) {}
4371 unsigned numTrailingObjects(OverloadToken<Expr *>)
const {
4372 return TransformedExpressions;
4376 static PackIndexingExpr *
Create(ASTContext &Context,
4377 SourceLocation EllipsisLoc,
4378 SourceLocation RSquareLoc,
Expr *PackIdExpr,
4379 Expr *IndexExpr, std::optional<int64_t> Index,
4380 ArrayRef<Expr *> SubstitutedExprs = {});
4382 unsigned NumTransformedExprs);
4404 return std::nullopt;
4407 assert(Index.isNonNegative() &&
"Invalid index");
4408 return static_cast<unsigned>(Index.getExtValue());
4413 assert(Index &&
"extracting the indexed expression of a dependant pack");
4414 return getTrailingObjects<Expr *>()[*Index];
4418 return {getTrailingObjects<Expr *>(), TransformedExpressions};
4445 llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndRef;
4447 unsigned Index : 15;
4448 unsigned PackIndex : 16;
4451 :
Expr(SubstNonTypeTemplateParmExprClass, Empty) {}
4456 Decl *AssociatedDecl,
unsigned Index,
4457 std::optional<unsigned> PackIndex,
bool RefParam)
4458 :
Expr(SubstNonTypeTemplateParmExprClass, Ty, ValueKind,
OK_Ordinary),
4459 Replacement(Replacement),
4460 AssociatedDeclAndRef(AssociatedDecl, RefParam), Index(Index),
4461 PackIndex(PackIndex ? *PackIndex + 1 : 0) {
4462 assert(AssociatedDecl !=
nullptr);
4485 return std::nullopt;
4486 return PackIndex - 1;
4497 return s->getStmtClass() == SubstNonTypeTemplateParmExprClass;
4525 Decl *AssociatedDecl;
4532 unsigned NumArguments : 16;
4534 unsigned Index : 16;
4540 :
Expr(SubstNonTypeTemplateParmPackExprClass, Empty) {}
4546 Decl *AssociatedDecl,
unsigned Index);
4570 return T->
getStmtClass() == SubstNonTypeTemplateParmPackExprClass;
4599 private llvm::TrailingObjects<FunctionParmPackExpr, VarDecl *> {
4602 friend TrailingObjects;
4611 unsigned NumParameters;
4623 unsigned NumParams);
4684 llvm::PointerUnion<Stmt *, LifetimeExtendedTemporaryDecl *> State;
4688 bool BoundToLvalueReference,
4692 :
Expr(MaterializeTemporaryExprClass, Empty) {}
4699 ? State.get<
Stmt *>()
4714 "the temporary has not been lifetime extended");
4730 return State.is<
Stmt *>() ?
nullptr
4741 return State.is<
Stmt *>() ? 0
4763 return T->
getStmtClass() == MaterializeTemporaryExprClass;
4768 return State.is<
Stmt *>()
4769 ?
child_range(State.getAddrOfPtr1(), State.getAddrOfPtr1() + 1)
4774 return State.is<
Stmt *>()
4776 State.getAddrOfPtr1() + 1)
4795 enum SubExpr { Callee, LHS, RHS, Count };
4802 unsigned NumExpansions;
4803 Stmt *SubExprs[SubExpr::Count];
4810 std::optional<unsigned> NumExpansions)
4812 LParenLoc(LParenLoc), EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc),
4813 NumExpansions(NumExpansions ? *NumExpansions + 1 : 0), Opcode(Opcode) {
4814 SubExprs[SubExpr::Callee] = Callee;
4815 SubExprs[SubExpr::LHS] = LHS;
4816 SubExprs[SubExpr::RHS] = RHS;
4849 return NumExpansions - 1;
4850 return std::nullopt;
4875 return child_range(SubExprs, SubExprs + SubExpr::Count);
4913 private llvm::TrailingObjects<CXXParenListInitExpr, Expr *> {
4919 unsigned NumUserSpecifiedExprs;
4921 llvm::PointerUnion<Expr *, FieldDecl *> ArrayFillerOrUnionFieldInit;
4927 NumExprs(Args.size()), NumUserSpecifiedExprs(NumUserSpecifiedExprs),
4928 InitLoc(InitLoc), LParenLoc(LParenLoc), RParenLoc(RParenLoc) {
4929 std::copy(Args.begin(), Args.end(), getTrailingObjects<Expr *>());
4930 assert(NumExprs >= NumUserSpecifiedExprs &&
4931 "number of user specified inits is greater than the number of "
4936 size_t numTrailingObjects(OverloadToken<Expr *>)
const {
return NumExprs; }
4939 static CXXParenListInitExpr *
4940 Create(ASTContext &
C, ArrayRef<Expr *> Args, QualType T,
4941 unsigned NumUserSpecifiedExprs, SourceLocation InitLoc,
4942 SourceLocation LParenLoc, SourceLocation RParenLoc);
4944 static CXXParenListInitExpr *
CreateEmpty(ASTContext &
C,
unsigned numExprs,
4948 :
Expr(CXXParenListInitExprClass, Empty), NumExprs(NumExprs),
4949 NumUserSpecifiedExprs(0) {}
4954 return ArrayRef(getTrailingObjects<Expr *>(), NumExprs);
4958 return ArrayRef(getTrailingObjects<Expr *>(), NumExprs);
4962 return ArrayRef(getTrailingObjects<Expr *>(), NumUserSpecifiedExprs);
4966 return ArrayRef(getTrailingObjects<Expr *>(), NumUserSpecifiedExprs);
4982 return ArrayFillerOrUnionFieldInit.dyn_cast<
Expr *>();
4986 return ArrayFillerOrUnionFieldInit.dyn_cast<
Expr *>();
4990 ArrayFillerOrUnionFieldInit = FD;
4994 return ArrayFillerOrUnionFieldInit.dyn_cast<
FieldDecl *>();
4998 return ArrayFillerOrUnionFieldInit.dyn_cast<
FieldDecl *>();
5002 Stmt **
Begin =
reinterpret_cast<Stmt **
>(getTrailingObjects<Expr *>());
5008 reinterpret_cast<Stmt *
const *
>(getTrailingObjects<Expr *>());
5035 enum SubExpr { Operand, Common, Ready, Suspend, Resume, Count };
5037 Stmt *SubExprs[SubExpr::Count];
5049 KeywordLoc(KeywordLoc), OpaqueValue(OpaqueValue) {
5050 SubExprs[SubExpr::Operand] = Operand;
5051 SubExprs[SubExpr::Common] = Common;
5052 SubExprs[SubExpr::Ready] = Ready;
5053 SubExprs[SubExpr::Suspend] = Suspend;
5054 SubExprs[SubExpr::Resume] = Resume;
5062 "wrong constructor for non-dependent co_await/co_yield expression");
5063 SubExprs[SubExpr::Operand] = Operand;
5064 SubExprs[SubExpr::Common] = Common;
5065 SubExprs[SubExpr::Ready] =
nullptr;
5066 SubExprs[SubExpr::Suspend] =
nullptr;
5067 SubExprs[SubExpr::Resume] =
nullptr;
5072 SubExprs[SubExpr::Operand] =
nullptr;
5073 SubExprs[SubExpr::Common] =
nullptr;
5074 SubExprs[SubExpr::Ready] =
nullptr;
5075 SubExprs[SubExpr::Suspend] =
nullptr;
5076 SubExprs[SubExpr::Resume] =
nullptr;
5080 return static_cast<Expr*
>(SubExprs[SubExpr::Common]);
5087 return static_cast<Expr*
>(SubExprs[SubExpr::Ready]);
5091 return static_cast<Expr*
>(SubExprs[SubExpr::Suspend]);
5095 return static_cast<Expr*
>(SubExprs[SubExpr::Resume]);
5100 return static_cast<Expr *
>(SubExprs[SubExpr::Operand]);
5105 assert(SuspendExpr);
5107 auto SuspendType = SuspendExpr->getType();
5109 if (SuspendType->isVoidType())
5111 if (SuspendType->isBooleanType())
5117 assert(SuspendType->isVoidPointerType());
5130 return child_range(SubExprs, SubExprs + SubExpr::Count);
5152 Ready, Suspend, Resume, OpaqueValue) {
5157 Expr *Common,
bool IsImplicit =
false)
5186 KeywordLoc(KeywordLoc) {
5190 "wrong constructor for non-dependent co_await/co_yield expression");
5192 SubExprs[1] = OpCoawait;
5197 :
Expr(DependentCoawaitExprClass, Empty) {}
5202 return cast<UnresolvedLookupExpr>(SubExprs[1]);
5233 Ready, Suspend, Resume, OpaqueValue) {}
5251 private llvm::TrailingObjects<BuiltinBitCastExpr, CXXBaseSpecifier *> {
5254 friend TrailingObjects;
5265 KWLoc(KWLoc), RParenLoc(RParenLoc) {}
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)
IdentifierInfo * getDestroyedTypeIdentifier() const
In a dependent pseudo-destructor expression for which we do not have full type information on the des...
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.
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++.
SourceLocation getBeginLoc() const
void setLocation(SourceLocation L)
SourceLocation getEndLoc() 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(IdentifierInfo *II, SourceLocation Loc)
PseudoDestructorTypeStorage()=default
SourceLocation getLocation() const
TypeSourceInfo * getTypeSourceInfo() const
IdentifierInfo * getIdentifier() 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)
bool isOverloaded() const
True if this lookup is overloaded.
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.
@ 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....