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) {}
1559 inline Stmt **getTrailingArgs();
1560 const Stmt *
const *getTrailingArgs()
const {
1566 CXXConstructExpr(
StmtClass SC, QualType Ty, SourceLocation Loc,
1567 CXXConstructorDecl *Ctor,
bool Elidable,
1568 ArrayRef<Expr *> Args,
bool HadMultipleCandidates,
1569 bool ListInitialization,
bool StdInitListInitialization,
1571 SourceRange ParenOrBraceRange);
1574 CXXConstructExpr(
StmtClass SC, EmptyShell Empty,
unsigned NumArgs);
1579 return NumArgs *
sizeof(
Stmt *);
1587 bool HadMultipleCandidates,
bool ListInitialization,
1588 bool StdInitListInitialization,
bool ZeroInitialization,
1667 return reinterpret_cast<const Expr *
const *
>(getTrailingArgs());
1675 assert(Arg <
getNumArgs() &&
"Arg access out of range!");
1679 assert(Arg <
getNumArgs() &&
"Arg access out of range!");
1685 assert(Arg <
getNumArgs() &&
"Arg access out of range!");
1730 unsigned ConstructsVirtualBase : 1;
1734 unsigned InheritedFromVirtualBase : 1;
1742 bool InheritedFromVirtualBase)
1744 Constructor(Ctor), Loc(Loc),
1745 ConstructsVirtualBase(ConstructsVirtualBase),
1746 InheritedFromVirtualBase(InheritedFromVirtualBase) {
1753 :
Expr(CXXInheritedCtorInitExprClass, Empty),
1754 ConstructsVirtualBase(
false), InheritedFromVirtualBase(
false) {}
1778 return T->
getStmtClass() == CXXInheritedCtorInitExprClass;
1799 private llvm::TrailingObjects<CXXFunctionalCastExpr, CXXBaseSpecifier *,
1800 FPOptionsOverride> {
1811 LParenLoc(lParenLoc), RParenLoc(rParenLoc) {
1821 unsigned numTrailingObjects(OverloadToken<CXXBaseSpecifier *>)
const {
1849 return T->getStmtClass() == CXXFunctionalCastExprClass;
1880 bool HadMultipleCandidates,
bool ListInitialization,
1881 bool StdInitListInitialization,
1882 bool ZeroInitialization);
1890 SourceRange ParenOrBraceRange,
bool HadMultipleCandidates,
1891 bool ListInitialization,
bool StdInitListInitialization,
1892 bool ZeroInitialization);
1903 return T->getStmtClass() == CXXTemporaryObjectExprClass;
1907Stmt **CXXConstructExpr::getTrailingArgs() {
1908 if (
auto *E = dyn_cast<CXXTemporaryObjectExpr>(
this))
1909 return reinterpret_cast<Stmt **
>(E + 1);
1911 "Unexpected class deriving from CXXConstructExpr!");
1912 return reinterpret_cast<Stmt **
>(
this + 1);
1937 private llvm::TrailingObjects<LambdaExpr, Stmt *> {
1961 SourceLocation ClosingBrace,
bool ContainsUnexpandedParameterPack);
1966 Stmt **getStoredStmts() {
return getTrailingObjects<Stmt *>(); }
1967 Stmt *
const *getStoredStmts()
const {
return getTrailingObjects<Stmt *>(); }
1969 void initBodyIfNeeded()
const;
1980 bool ExplicitParams,
bool ExplicitResultType,
1982 bool ContainsUnexpandedParameterPack);
1987 unsigned NumCaptures);
2064 return reinterpret_cast<Expr **
>(getStoredStmts());
2070 return reinterpret_cast<Expr *
const *
>(getStoredStmts());
2130 const auto *ConstThis =
this;
2131 return const_cast<CompoundStmt *
>(ConstThis->getCompoundStmtBody());
2152 return IntroducerRange.getBegin();
2181 :
Expr(CXXScalarValueInitExprClass, Shell) {}
2195 return T->
getStmtClass() == CXXScalarValueInitExprClass;
2212 private llvm::TrailingObjects<CXXNewExpr, Stmt *, SourceRange> {
2215 friend TrailingObjects;
2247 unsigned arraySizeOffset()
const {
return 0; }
2248 unsigned initExprOffset()
const {
return arraySizeOffset() +
isArray(); }
2249 unsigned placementNewArgsOffset()
const {
2253 unsigned numTrailingObjects(OverloadToken<Stmt *>)
const {
2257 unsigned numTrailingObjects(OverloadToken<SourceRange>)
const {
2276 FunctionDecl *OperatorDelete,
bool ShouldPassAlignment,
2278 SourceRange TypeIdParens, std::optional<Expr *> ArraySize,
2284 CXXNewExpr(EmptyShell Empty,
bool IsArray,
unsigned NumPlacementArgs,
2285 bool IsParenTypeId);
2291 FunctionDecl *OperatorDelete,
bool ShouldPassAlignment,
2293 SourceRange TypeIdParens, std::optional<Expr *> ArraySize,
2300 bool HasInit,
unsigned NumPlacementArgs,
2301 bool IsParenTypeId);
2308 return AllocatedTypeInfo;
2340 return std::nullopt;
2343 cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]))
2346 return std::nullopt;
2354 return std::nullopt;
2357 cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]))
2360 return std::nullopt;
2368 return reinterpret_cast<Expr **
>(getTrailingObjects<Stmt *>() +
2369 placementNewArgsOffset());
2382 return isParenTypeId() ? getTrailingObjects<SourceRange>()[0]
2404 ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])
2409 ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])
2441 return getTrailingObjects<Stmt *>() + placementNewArgsOffset();
2447 return getTrailingObjects<Stmt *>() + placementNewArgsOffset();
2457 return raw_arg_begin() + numTrailingObjects(OverloadToken<Stmt *>());
2460 return getTrailingObjects<Stmt *>();
2463 return raw_arg_begin() + numTrailingObjects(OverloadToken<Stmt *>());
2493 Stmt *Argument =
nullptr;
2497 bool ArrayFormAsWritten,
bool UsualArrayDeleteWantsSize,
2500 OperatorDelete(OperatorDelete), Argument(Arg) {
2557 llvm::PointerUnion<TypeSourceInfo *, IdentifierInfo *>
Type;
2566 :
Type(II), Location(Loc) {}
2646 :
Expr(CXXPseudoDestructorExprClass, Shell), IsArrow(
false) {}
2729 return Base->getBeginLoc();
2734 return T->getStmtClass() == CXXPseudoDestructorExprClass;
2755 private llvm::TrailingObjects<TypeTraitExpr, TypeSourceInfo *> {
2772 size_t numTrailingObjects(OverloadToken<TypeSourceInfo *>)
const {
2806 assert(I <
getNumArgs() &&
"Argument out-of-range");
2866 Value(value), Dimension(dimension), Loc(loc), RParen(rparen),
2867 QueriedType(queried) {
2868 assert(att <=
ATT_Last &&
"invalid enum value!");
2869 assert(
static_cast<unsigned>(att) == ATT &&
"ATT overflow!");
2874 :
Expr(ArrayTypeTraitExprClass, Empty), ATT(0) {}
2924 Expr* QueriedExpression =
nullptr;
2932 ET(et),
Value(value), Loc(loc), RParen(rparen),
2933 QueriedExpression(queried) {
2934 assert(et <=
ET_Last &&
"invalid enum value!");
2935 assert(
static_cast<unsigned>(et) == ET &&
"ET overflow!");
2984 bool KnownDependent,
bool KnownInstantiationDependent,
2985 bool KnownContainsUnexpandedParameterPack);
2988 bool HasTemplateKWAndArgsInfo);
3033 if (isa<UnaryOperator>(E)) {
3034 assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
3035 E = cast<UnaryOperator>(E)->getSubExpr();
3038 Result.HasFormOfMemberPointer = (E == Ovl && Ovl->getQualifier());
3039 Result.IsAddressOfOperand =
true;
3042 Result.HasFormOfMemberPointer =
false;
3043 Result.IsAddressOfOperand =
false;
3044 Result.Expression = cast<OverloadExpr>(E);
3065 llvm::iterator_range<decls_iterator>
decls()
const {
3144 return T->
getStmtClass() == UnresolvedLookupExprClass ||
3162 private llvm::TrailingObjects<UnresolvedLookupExpr, DeclAccessPair,
3163 ASTTemplateKWAndArgsInfo,
3164 TemplateArgumentLoc> {
3167 friend TrailingObjects;
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);
3214 static UnresolvedLookupExpr *
3215 Create(
const ASTContext &Context, CXXRecordDecl *NamingClass,
3216 NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
3217 const DeclarationNameInfo &NameInfo,
bool RequiresADL,
3218 const TemplateArgumentListInfo *Args, UnresolvedSetIterator
Begin,
3219 UnresolvedSetIterator End);
3221 static UnresolvedLookupExpr *
CreateEmpty(
const ASTContext &Context,
3222 unsigned NumResults,
3223 bool HasTemplateKWAndArgsInfo,
3224 unsigned NumTemplateArgs);
3241 return l.getBeginLoc();
3280 private llvm::TrailingObjects<DependentScopeDeclRefExpr,
3281 ASTTemplateKWAndArgsInfo,
3282 TemplateArgumentLoc> {
3285 friend TrailingObjects;
3299 size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)
const {
3300 return hasTemplateKWAndArgsInfo();
3303 bool hasTemplateKWAndArgsInfo()
const {
3308 static DependentScopeDeclRefExpr *
3309 Create(
const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
3310 SourceLocation TemplateKWLoc,
const DeclarationNameInfo &NameInfo,
3311 const TemplateArgumentListInfo *TemplateArgs);
3313 static DependentScopeDeclRefExpr *
CreateEmpty(
const ASTContext &Context,
3314 bool HasTemplateKWAndArgsInfo,
3315 unsigned NumTemplateArgs);
3341 if (!hasTemplateKWAndArgsInfo())
3343 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
3349 if (!hasTemplateKWAndArgsInfo())
3351 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
3357 if (!hasTemplateKWAndArgsInfo())
3359 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
3372 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
3373 getTrailingObjects<TemplateArgumentLoc>(), List);
3380 return getTrailingObjects<TemplateArgumentLoc>();
3387 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
3407 return T->
getStmtClass() == DependentScopeDeclRefExprClass;
3431 private llvm::TrailingObjects<
3433 llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>> {
3443 friend TrailingObjects;
3451 unsigned numObjects);
3454 bool CleanupsHaveSideEffects,
3516 private llvm::TrailingObjects<CXXUnresolvedConstructExpr, Expr *> {
3518 friend TrailingObjects;
3522 llvm::PointerIntPair<TypeSourceInfo *, 1> TypeAndInitForm;
3535 :
Expr(CXXUnresolvedConstructExprClass, Empty) {
3555 return TypeAndInitForm.getPointer();
3593 assert(I <
getNumArgs() &&
"Argument index out-of-range");
3598 assert(I <
getNumArgs() &&
"Argument index out-of-range");
3603 assert(I <
getNumArgs() &&
"Argument index out-of-range");
3615 return T->
getStmtClass() == CXXUnresolvedConstructExprClass;
3625 auto **begin =
reinterpret_cast<Stmt **
>(
3640 private llvm::TrailingObjects<CXXDependentScopeMemberExpr,
3641 ASTTemplateKWAndArgsInfo,
3642 TemplateArgumentLoc, NamedDecl *> {
3645 friend TrailingObjects;
3681 bool hasTemplateKWAndArgsInfo()
const {
3685 bool hasFirstQualifierFoundInScope()
const {
3689 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)
const {
3690 return hasTemplateKWAndArgsInfo();
3693 unsigned numTrailingObjects(OverloadToken<TemplateArgumentLoc>)
const {
3697 unsigned numTrailingObjects(OverloadToken<NamedDecl *>)
const {
3698 return hasFirstQualifierFoundInScope();
3701 CXXDependentScopeMemberExpr(
const ASTContext &Ctx,
Expr *
Base,
3702 QualType BaseType,
bool IsArrow,
3703 SourceLocation OperatorLoc,
3704 NestedNameSpecifierLoc QualifierLoc,
3705 SourceLocation TemplateKWLoc,
3706 NamedDecl *FirstQualifierFoundInScope,
3707 DeclarationNameInfo MemberNameInfo,
3708 const TemplateArgumentListInfo *TemplateArgs);
3710 CXXDependentScopeMemberExpr(EmptyShell Empty,
bool HasTemplateKWAndArgsInfo,
3711 bool HasFirstQualifierFoundInScope);
3714 static CXXDependentScopeMemberExpr *
3715 Create(
const ASTContext &Ctx,
Expr *
Base, QualType BaseType,
bool IsArrow,
3716 SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
3717 SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope,
3718 DeclarationNameInfo MemberNameInfo,
3719 const TemplateArgumentListInfo *TemplateArgs);
3721 static CXXDependentScopeMemberExpr *
3722 CreateEmpty(
const ASTContext &Ctx,
bool HasTemplateKWAndArgsInfo,
3723 unsigned NumTemplateArgs,
bool HasFirstQualifierFoundInScope);
3731 return cast<Expr>(
Base)->isImplicitCXXThis();
3738 return cast<Expr>(
Base);
3773 if (!hasFirstQualifierFoundInScope())
3775 return *getTrailingObjects<NamedDecl *>();
3780 return MemberNameInfo;
3793 if (!hasTemplateKWAndArgsInfo())
3795 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
3801 if (!hasTemplateKWAndArgsInfo())
3803 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
3809 if (!hasTemplateKWAndArgsInfo())
3811 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
3825 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
3826 getTrailingObjects<TemplateArgumentLoc>(), List);
3835 return getTrailingObjects<TemplateArgumentLoc>();
3844 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
3853 return Base->getBeginLoc();
3866 return T->
getStmtClass() == CXXDependentScopeMemberExprClass;
3900 private llvm::TrailingObjects<UnresolvedMemberExpr, DeclAccessPair,
3901 ASTTemplateKWAndArgsInfo,
3902 TemplateArgumentLoc> {
3905 friend TrailingObjects;
3943 bool HasTemplateKWAndArgsInfo);
3945 unsigned numTrailingObjects(OverloadToken<DeclAccessPair>)
const {
3949 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)
const {
3954 static UnresolvedMemberExpr *
3955 Create(
const ASTContext &Context,
bool HasUnresolvedUsing, Expr *
Base,
3956 QualType BaseType,
bool IsArrow, SourceLocation OperatorLoc,
3957 NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
3958 const DeclarationNameInfo &MemberNameInfo,
3959 const TemplateArgumentListInfo *TemplateArgs,
3960 UnresolvedSetIterator
Begin, UnresolvedSetIterator End);
3962 static UnresolvedMemberExpr *
CreateEmpty(
const ASTContext &Context,
3963 unsigned NumResults,
3964 bool HasTemplateKWAndArgsInfo,
3965 unsigned NumTemplateArgs);
3977 return cast<Expr>(
Base);
3981 return cast<Expr>(
Base);
4022 return Base->getBeginLoc();
4024 return l.getBeginLoc();
4053 if (
auto *ULE = dyn_cast<UnresolvedLookupExpr>(
this))
4055 return cast<UnresolvedMemberExpr>(
this)->getTrailingObjects<
DeclAccessPair>();
4062 if (
auto *ULE = dyn_cast<UnresolvedLookupExpr>(
this))
4064 return cast<UnresolvedMemberExpr>(
this)
4069 if (
auto *ULE = dyn_cast<UnresolvedLookupExpr>(
this))
4071 return cast<UnresolvedMemberExpr>(
this)
4076 if (
auto *ULE = dyn_cast<UnresolvedLookupExpr>(
this))
4077 return ULE->getNamingClass();
4078 return cast<UnresolvedMemberExpr>(
this)->getNamingClass();
4095 Operand(Operand), Range(Keyword, RParen) {
4150 unsigned NumExpansions;
4156 std::optional<unsigned> NumExpansions)
4159 EllipsisLoc(EllipsisLoc),
4160 NumExpansions(NumExpansions ? *NumExpansions + 1 : 0),
4181 return NumExpansions - 1;
4183 return std::nullopt;
4217 private llvm::TrailingObjects<SizeOfPackExpr, TemplateArgument> {
4220 friend TrailingObjects;
4250 std::optional<unsigned> Length,
4253 OperatorLoc(OperatorLoc), PackLoc(PackLoc), RParenLoc(RParenLoc),
4254 Length(Length ? *Length : PartialArgs.size()), Pack(Pack) {
4255 assert((!Length || PartialArgs.empty()) &&
4256 "have partial args for non-dependent sizeof... expression");
4257 auto *Args = getTrailingObjects<TemplateArgument>();
4258 std::uninitialized_copy(PartialArgs.begin(), PartialArgs.end(), Args);
4260 : ExprDependence::ValueInstantiation);
4265 :
Expr(SizeOfPackExprClass, Empty), Length(NumPartialArgs) {}
4268 static SizeOfPackExpr *
4269 Create(ASTContext &Context, SourceLocation OperatorLoc, NamedDecl *Pack,
4270 SourceLocation PackLoc, SourceLocation RParenLoc,
4271 std::optional<unsigned> Length = std::nullopt,
4272 ArrayRef<TemplateArgument> PartialArgs = std::nullopt);
4274 unsigned NumPartialArgs);
4294 "Cannot get the length of a value-dependent pack size expression");
4310 const auto *Args = getTrailingObjects<TemplateArgument>();
4343 llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndRef;
4345 unsigned Index : 15;
4346 unsigned PackIndex : 16;
4349 :
Expr(SubstNonTypeTemplateParmExprClass, Empty) {}
4354 Decl *AssociatedDecl,
unsigned Index,
4355 std::optional<unsigned> PackIndex,
bool RefParam)
4356 :
Expr(SubstNonTypeTemplateParmExprClass, Ty, ValueKind,
OK_Ordinary),
4357 Replacement(Replacement),
4358 AssociatedDeclAndRef(AssociatedDecl, RefParam), Index(Index),
4359 PackIndex(PackIndex ? *PackIndex + 1 : 0) {
4360 assert(AssociatedDecl !=
nullptr);
4383 return std::nullopt;
4384 return PackIndex - 1;
4395 return s->getStmtClass() == SubstNonTypeTemplateParmExprClass;
4423 Decl *AssociatedDecl;
4430 unsigned NumArguments : 16;
4432 unsigned Index : 16;
4438 :
Expr(SubstNonTypeTemplateParmPackExprClass, Empty) {}
4444 Decl *AssociatedDecl,
unsigned Index);
4468 return T->
getStmtClass() == SubstNonTypeTemplateParmPackExprClass;
4497 private llvm::TrailingObjects<FunctionParmPackExpr, VarDecl *> {
4500 friend TrailingObjects;