34#include "llvm/ADT/ArrayRef.h"
35#include "llvm/Support/ErrorHandling.h"
57 case OO_Call:
case OO_Subscript:
70 bool SkippedNot =
false;
71 if (
auto *NotEq = dyn_cast<UnaryOperator>(
E)) {
72 assert(NotEq->getOpcode() == UO_LNot);
78 if (
auto *BO = dyn_cast<BinaryOperator>(
E)) {
79 assert(!SkippedNot || BO->getOpcode() == BO_EQ);
80 Result.Opcode = SkippedNot ? BO_NE : BO->getOpcode();
84 }
else if (
auto *BO = dyn_cast<CXXOperatorCallExpr>(
E)) {
85 assert(!SkippedNot || BO->getOperator() == OO_EqualEqual);
86 assert(BO->isInfixBinaryOp());
87 switch (BO->getOperator()) {
88 case OO_Less:
Result.Opcode = BO_LT;
break;
89 case OO_LessEqual:
Result.Opcode = BO_LE;
break;
90 case OO_Greater:
Result.Opcode = BO_GT;
break;
91 case OO_GreaterEqual:
Result.Opcode = BO_GE;
break;
92 case OO_Spaceship:
Result.Opcode = BO_Cmp;
break;
93 case OO_EqualEqual:
Result.Opcode = SkippedNot ? BO_NE : BO_EQ;
break;
94 default: llvm_unreachable(
"unexpected binop in rewritten operator expr");
96 Result.LHS = BO->getArg(0);
97 Result.RHS = BO->getArg(1);
100 llvm_unreachable(
"unexpected rewritten operator form");
113 E =
Result.LHS->IgnoreUnlessSpelledInSource();
114 if (
auto *BO = dyn_cast<BinaryOperator>(
E)) {
115 assert(BO->getOpcode() == BO_Cmp);
116 Result.LHS = BO->getLHS();
117 Result.RHS = BO->getRHS();
119 }
else if (
auto *BO = dyn_cast<CXXOperatorCallExpr>(
E)) {
120 assert(BO->getOperator() == OO_Spaceship);
121 Result.LHS = BO->getArg(0);
122 Result.RHS = BO->getArg(1);
125 llvm_unreachable(
"unexpected rewritten operator form");
150 assert(!
isTypeOperand() &&
"Cannot call isMostDerived for typeid(type)");
152 if (
const auto *DRE = dyn_cast<DeclRefExpr>(
E)) {
153 QualType Ty = DRE->getDecl()->getType();
162 assert(
isTypeOperand() &&
"Cannot call getTypeOperand for typeid(expr)");
165 cast<TypeSourceInfo *>(Operand)->
getType().getNonReferenceType(), Quals);
171 if (
const auto *CE = dyn_cast<CastExpr>(
E)) {
172 if (!CE->getSubExpr()->isGLValue())
177 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(
E))
180 if (
const auto *BO = dyn_cast<BinaryOperator>(
E))
181 if (BO->getOpcode() == BO_Comma)
184 if (
const auto *ACO = dyn_cast<AbstractConditionalOperator>(
E))
190 if (isa<ArraySubscriptExpr>(
E))
193 if (
const auto *UO = dyn_cast<UnaryOperator>(
E))
194 if (UO->getOpcode() == UO_Deref)
216 assert(
isTypeOperand() &&
"Cannot call getTypeOperand for __uuidof(expr)");
219 cast<TypeSourceInfo *>(Operand)->
getType().getNonReferenceType(), Quals);
228CXXNewExpr::CXXNewExpr(
bool IsGlobalNew,
FunctionDecl *OperatorNew,
231 bool UsualArrayDeleteWantsSize,
233 std::optional<Expr *> ArraySize,
239 OperatorNew(OperatorNew), OperatorDelete(OperatorDelete),
240 AllocatedTypeInfo(AllocatedTypeInfo),
Range(
Range),
241 DirectInitRange(DirectInitRange) {
245 "Only CXXNewInitializationStyle::None can have no initializer!");
252 CXXNewExprBits.UsualArrayDeleteWantsSize = UsualArrayDeleteWantsSize;
255 llvm::to_underlying(InitializationStyle);
256 bool IsParenTypeId = TypeIdParens.
isValid();
261 getTrailingObjects<Stmt *>()[arraySizeOffset()] = *ArraySize;
263 getTrailingObjects<Stmt *>()[initExprOffset()] =
Initializer;
264 llvm::copy(PlacementArgs,
265 getTrailingObjects<Stmt *>() + placementNewArgsOffset());
267 getTrailingObjects<SourceRange>()[0] = TypeIdParens;
269 switch (getInitializationStyle()) {
285CXXNewExpr::CXXNewExpr(EmptyShell
Empty,
bool IsArray,
286 unsigned NumPlacementArgs,
bool IsParenTypeId)
297 SourceRange TypeIdParens, std::optional<Expr *> ArraySize,
301 bool IsArray = ArraySize.has_value();
303 unsigned NumPlacementArgs = PlacementArgs.size();
304 bool IsParenTypeId = TypeIdParens.
isValid();
306 Ctx.
Allocate(totalSizeToAlloc<Stmt *, SourceRange>(
307 IsArray + HasInit + NumPlacementArgs, IsParenTypeId),
310 IsGlobalNew, OperatorNew, OperatorDelete, IAP, UsualArrayDeleteWantsSize,
311 PlacementArgs, TypeIdParens, ArraySize, InitializationStyle,
Initializer,
312 Ty, AllocatedTypeInfo,
Range, DirectInitRange);
316 bool HasInit,
unsigned NumPlacementArgs,
317 bool IsParenTypeId) {
319 Ctx.
Allocate(totalSizeToAlloc<Stmt *, SourceRange>(
320 IsArray + HasInit + NumPlacementArgs, IsParenTypeId),
344 while (
const auto *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
345 if (ICE->getCastKind() == CK_DerivedToBase ||
346 ICE->getCastKind() == CK_UncheckedDerivedToBase ||
347 ICE->getCastKind() == CK_NoOp) {
348 assert((ICE->getCastKind() == CK_NoOp ||
350 "only a destroying operator delete can have a converted arg");
351 Arg = ICE->getSubExpr();
376 :
Expr(CXXPseudoDestructorExprClass, Context.BoundMemberTy,
VK_PRValue,
379 OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
380 ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc),
381 DestroyedType(DestroyedType) {
387 return TInfo->getType();
395 End = TInfo->getTypeLoc().getSourceRange().getEnd();
401 if (std::distance(
Begin, End) != 1)
404 if (
const auto *TTP = llvm::dyn_cast<TemplateTemplateParmDecl>(ND))
405 return TTP->isParameterPack();
410UnresolvedLookupExpr::UnresolvedLookupExpr(
416 bool KnownInstantiationDependent)
418 UnresolvedLookupExprClass, Context, QualifierLoc, TemplateKWLoc,
419 NameInfo, TemplateArgs,
Begin, End, KnownDependent,
420 KnownInstantiationDependent,
422 NamingClass(NamingClass) {
423 UnresolvedLookupExprBits.RequiresADL = RequiresADL;
426UnresolvedLookupExpr::UnresolvedLookupExpr(EmptyShell
Empty,
428 bool HasTemplateKWAndArgsInfo)
430 HasTemplateKWAndArgsInfo) {}
436 bool KnownDependent,
bool KnownInstantiationDependent) {
437 unsigned NumResults = End -
Begin;
442 Context, NamingClass, QualifierLoc,
444 nullptr,
Begin, End, KnownDependent,
445 KnownInstantiationDependent);
454 bool KnownInstantiationDependent) {
455 unsigned NumResults = End -
Begin;
456 bool HasTemplateKWAndArgsInfo = Args || TemplateKWLoc.
isValid();
457 unsigned NumTemplateArgs = Args ? Args->
size() : 0;
460 NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
463 Context, NamingClass, QualifierLoc, TemplateKWLoc, NameInfo, RequiresADL,
464 Args,
Begin, End, KnownDependent, KnownInstantiationDependent);
468 const ASTContext &Context,
unsigned NumResults,
469 bool HasTemplateKWAndArgsInfo,
unsigned NumTemplateArgs) {
470 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
473 NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
486 bool KnownInstantiationDependent,
487 bool KnownContainsUnexpandedParameterPack)
489 QualifierLoc(QualifierLoc) {
490 unsigned NumResults = End -
Begin;
493 (TemplateArgs != nullptr ) || TemplateKWLoc.
isValid();
503 auto Deps = TemplateArgumentDependence::None;
506 }
else if (TemplateKWLoc.
isValid()) {
511 KnownInstantiationDependent,
512 KnownContainsUnexpandedParameterPack));
518 bool HasTemplateKWAndArgsInfo)
525DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(
530 QualifierLoc(QualifierLoc), NameInfo(NameInfo) {
532 (Args !=
nullptr) || TemplateKWLoc.
isValid();
534 auto Deps = TemplateArgumentDependence::None;
535 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
536 TemplateKWLoc, *Args, getTrailingObjects<TemplateArgumentLoc>(), Deps);
537 }
else if (TemplateKWLoc.
isValid()) {
538 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
548 assert(QualifierLoc &&
"should be created for dependent qualifiers");
549 bool HasTemplateKWAndArgsInfo = Args || TemplateKWLoc.
isValid();
551 totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
552 HasTemplateKWAndArgsInfo, Args ? Args->
size() : 0);
555 TemplateKWLoc, NameInfo, Args);
560 bool HasTemplateKWAndArgsInfo,
561 unsigned NumTemplateArgs) {
562 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
564 totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
565 HasTemplateKWAndArgsInfo, NumTemplateArgs);
571 HasTemplateKWAndArgsInfo;
576 if (
const auto *TOE = dyn_cast<CXXTemporaryObjectExpr>(
this))
577 return TOE->getBeginLoc();
582 if (
const auto *TOE = dyn_cast<CXXTemporaryObjectExpr>(
this))
583 return TOE->getEndLoc();
585 if (ParenOrBraceRange.
isValid())
586 return ParenOrBraceRange.
getEnd();
609 :
CallExpr(CXXOperatorCallExprClass, Fn, {}, Args, Ty,
VK,
610 OperatorLoc, FPFeatures, 0, UsesADL) {
611 CXXOperatorCallExprBits.OperatorKind = OpKind;
613 (CXXOperatorCallExprBits.OperatorKind ==
static_cast<unsigned>(OpKind)) &&
614 "OperatorKind overflow!");
615 BeginLoc = getSourceRangeImpl().getBegin();
618CXXOperatorCallExpr::CXXOperatorCallExpr(
unsigned NumArgs,
bool HasFPFeatures,
620 :
CallExpr(CXXOperatorCallExprClass, 0, NumArgs,
621 HasFPFeatures,
Empty) {}
630 unsigned NumArgs = Args.size();
634 Ctx.
Allocate(sizeToAllocateForCallExprSubclass<CXXOperatorCallExpr>(
635 SizeOfTrailingObjects),
646 unsigned SizeOfTrailingObjects =
649 Ctx.
Allocate(sizeToAllocateForCallExprSubclass<CXXOperatorCallExpr>(
650 SizeOfTrailingObjects),
655SourceRange CXXOperatorCallExpr::getSourceRangeImpl()
const {
657 if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
664 }
else if (Kind == OO_Arrow) {
666 }
else if (Kind == OO_Call) {
668 }
else if (Kind == OO_Subscript) {
684 :
CallExpr(CXXMemberCallExprClass,
Fn, {}, Args, Ty,
VK, RP,
687CXXMemberCallExpr::CXXMemberCallExpr(
unsigned NumArgs,
bool HasFPFeatures,
689 :
CallExpr(CXXMemberCallExprClass, 0, NumArgs, HasFPFeatures,
697 unsigned MinNumArgs) {
699 unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
702 void *Mem = Ctx.
Allocate(sizeToAllocateForCallExprSubclass<CXXMemberCallExpr>(
703 SizeOfTrailingObjects),
714 unsigned SizeOfTrailingObjects =
716 void *Mem = Ctx.
Allocate(sizeToAllocateForCallExprSubclass<CXXMemberCallExpr>(
717 SizeOfTrailingObjects),
724 if (
const auto *MemExpr = dyn_cast<MemberExpr>(Callee))
725 return MemExpr->getBase();
726 if (
const auto *BO = dyn_cast<BinaryOperator>(Callee))
727 if (BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI)
743 return cast<CXXMethodDecl>(MemExpr->getMemberDecl());
770 case CXXStaticCastExprClass:
return "static_cast";
771 case CXXDynamicCastExprClass:
return "dynamic_cast";
772 case CXXReinterpretCastExprClass:
return "reinterpret_cast";
773 case CXXConstCastExprClass:
return "const_cast";
774 case CXXAddrspaceCastExprClass:
return "addrspace_cast";
775 default:
return "<invalid cast>";
785 unsigned PathSize = (BasePath ? BasePath->size() : 0);
787 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
790 FPO, L, RParenLoc, AngleBrackets);
792 llvm::uninitialized_copy(*BasePath,
799 bool HasFPFeatures) {
801 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
802 PathSize, HasFPFeatures));
814 unsigned PathSize = (BasePath ? BasePath->size() : 0);
815 void *Buffer =
C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
818 RParenLoc, AngleBrackets);
820 llvm::uninitialized_copy(*BasePath,
E->getTrailingObjects());
826 void *Buffer =
C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
855 assert(SrcRD && DestRD);
857 if (SrcRD->isEffectivelyFinal()) {
858 assert(!SrcRD->isDerivedFrom(DestRD) &&
859 "upcasts should not use CK_Dynamic");
863 if (DestRD->isEffectivelyFinal() && !DestRD->isDerivedFrom(SrcRD))
876 unsigned PathSize = (BasePath ? BasePath->size() : 0);
877 void *Buffer =
C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
880 RParenLoc, AngleBrackets);
882 llvm::uninitialized_copy(*BasePath,
E->getTrailingObjects());
888 void *Buffer =
C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
922 unsigned PathSize = (BasePath ? BasePath->size() : 0);
924 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
926 auto *
E =
new (Buffer)
929 llvm::uninitialized_copy(*BasePath,
936 bool HasFPFeatures) {
938 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
939 PathSize, HasFPFeatures));
957 :
CallExpr(UserDefinedLiteralClass, Fn, {}, Args, Ty,
VK,
958 LitEndLoc, FPFeatures, 0, NotADL),
959 UDSuffixLoc(SuffixLoc) {}
961UserDefinedLiteral::UserDefinedLiteral(
unsigned NumArgs,
bool HasFPFeatures,
963 :
CallExpr(UserDefinedLiteralClass, 0, NumArgs,
964 HasFPFeatures,
Empty) {}
973 unsigned NumArgs = Args.size();
977 Ctx.
Allocate(sizeToAllocateForCallExprSubclass<UserDefinedLiteral>(
978 SizeOfTrailingObjects),
989 unsigned SizeOfTrailingObjects =
992 Ctx.
Allocate(sizeToAllocateForCallExprSubclass<UserDefinedLiteral>(
993 SizeOfTrailingObjects),
1005 assert(
getNumArgs() == 1 &&
"unexpected #args in literal operator call");
1007 cast<FunctionDecl>(
getCalleeDecl())->getParamDecl(0)->getType();
1017 llvm_unreachable(
"unknown kind of literal operator");
1029 return cast<FunctionDecl>(
getCalleeDecl())->getLiteralIdentifier();
1033 bool HasRewrittenInit) {
1034 size_t Size = totalSizeToAlloc<Expr *>(HasRewrittenInit);
1042 Expr *RewrittenExpr,
1044 size_t Size = totalSizeToAlloc<Expr *>(RewrittenExpr !=
nullptr);
1047 RewrittenExpr, UsedContext);
1057 "expected this CXXDefaultArgExpr to have a rewritten init.");
1059 if (
auto *
E = dyn_cast_if_present<FullExpr>(
Init))
1060 if (!isa<ConstantExpr>(
E))
1061 return E->getSubExpr();
1065CXXDefaultInitExpr::CXXDefaultInitExpr(
const ASTContext &Ctx,
1068 Expr *RewrittenInitExpr)
1069 :
Expr(CXXDefaultInitExprClass, Ty.getNonLValueExprType(Ctx),
1071 : Ty->isRValueReferenceType() ?
VK_XValue
1074 Field(Field), UsedContext(UsedContext) {
1079 *getTrailingObjects() = RewrittenInitExpr;
1081 assert(Field->hasInClassInitializer());
1087 bool HasRewrittenInit) {
1088 size_t Size = totalSizeToAlloc<Expr *>(HasRewrittenInit);
1097 Expr *RewrittenInitExpr) {
1099 size_t Size = totalSizeToAlloc<Expr *>(RewrittenInitExpr !=
nullptr);
1102 UsedContext, RewrittenInitExpr);
1106 assert(Field->getInClassInitializer() &&
"initializer hasn't been parsed");
1110 return Field->getInClassInitializer();
1123 "Expression bound to a temporary must have record or array type!");
1128CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(
1131 bool HadMultipleCandidates,
bool ListInitialization,
1132 bool StdInitListInitialization,
bool ZeroInitialization)
1134 CXXTemporaryObjectExprClass, Ty, TSI->getTypeLoc().getBeginLoc(),
1135 Cons,
false, Args, HadMultipleCandidates,
1136 ListInitialization, StdInitListInitialization, ZeroInitialization,
1142CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(EmptyShell
Empty,
1149 bool HadMultipleCandidates,
bool ListInitialization,
1150 bool StdInitListInitialization,
bool ZeroInitialization) {
1156 Cons, Ty, TSI, Args, ParenOrBraceRange, HadMultipleCandidates,
1157 ListInitialization, StdInitListInitialization, ZeroInitialization);
1183 bool HadMultipleCandidates,
bool ListInitialization,
1184 bool StdInitListInitialization,
bool ZeroInitialization,
1190 CXXConstructExprClass, Ty,
Loc, Ctor, Elidable, Args,
1191 HadMultipleCandidates, ListInitialization, StdInitListInitialization,
1192 ZeroInitialization, ConstructKind, ParenOrBraceRange);
1207 bool ListInitialization,
bool StdInitListInitialization,
1211 ParenOrBraceRange(ParenOrBraceRange), NumArgs(Args.size()) {
1221 Stmt **TrailingArgs = getTrailingArgs();
1222 llvm::copy(Args, TrailingArgs);
1223 assert(!llvm::is_contained(Args,
nullptr));
1226 if (SC == CXXConstructExprClass)
1237 : DeclAndBits(Var, 0),
Loc(
Loc), EllipsisLoc(EllipsisLoc) {
1240 Bits |= Capture_Implicit;
1244 Bits |= Capture_ByCopy;
1247 assert(!Var &&
"'this' capture cannot have a variable!");
1248 Bits |= Capture_This;
1252 Bits |= Capture_ByCopy;
1255 assert(Var &&
"capture must have a variable!");
1258 assert(!Var &&
"VLA type capture cannot have a variable!");
1261 DeclAndBits.setInt(Bits);
1267 bool CapByCopy = DeclAndBits.getInt() & Capture_ByCopy;
1278 bool ContainsUnexpandedParameterPack)
1280 IntroducerRange(IntroducerRange), CaptureDefaultLoc(CaptureDefaultLoc),
1281 ClosingBrace(ClosingBrace) {
1282 LambdaExprBits.NumCaptures = CaptureInits.size();
1283 LambdaExprBits.CaptureDefault = CaptureDefault;
1284 LambdaExprBits.ExplicitParams = ExplicitParams;
1285 LambdaExprBits.ExplicitResultType = ExplicitResultType;
1289 assert(capture_size() ==
Class->capture_size() &&
"Wrong number of captures");
1290 assert(getCaptureDefault() ==
Class->getLambdaCaptureDefault());
1293 Stmt **Stored = getStoredStmts();
1294 for (
unsigned I = 0, N = CaptureInits.size(); I != N; ++I)
1295 *Stored++ = CaptureInits[I];
1298 *Stored++ = getCallOperator()->getBody();
1303LambdaExpr::LambdaExpr(EmptyShell
Empty,
unsigned NumCaptures)
1305 LambdaExprBits.NumCaptures = NumCaptures;
1309 getStoredStmts()[NumCaptures] =
nullptr;
1316 bool ExplicitParams,
bool ExplicitResultType,
1319 bool ContainsUnexpandedParameterPack) {
1324 unsigned Size = totalSizeToAlloc<Stmt *>(CaptureInits.size() + 1);
1325 void *Mem = Context.
Allocate(Size);
1327 LambdaExpr(
T, IntroducerRange, CaptureDefault, CaptureDefaultLoc,
1328 ExplicitParams, ExplicitResultType, CaptureInits, ClosingBrace,
1329 ContainsUnexpandedParameterPack);
1333 unsigned NumCaptures) {
1334 unsigned Size = totalSizeToAlloc<Stmt *>(NumCaptures + 1);
1335 void *Mem =
C.Allocate(Size);
1339void LambdaExpr::initBodyIfNeeded()
const {
1353 if (
const auto *CoroBody = dyn_cast<CoroutineBodyStmt>(Body))
1354 return cast<CompoundStmt>(CoroBody->getBody());
1355 return cast<CompoundStmt>(Body);
1359 return C->capturesVariable() &&
C->getCapturedVar()->isInitCapture() &&
1406 return Record->getLambdaCallOperator();
1411 return Record->getDependentLambdaCallOperator();
1416 return Record->getGenericLambdaTemplateParameterList();
1421 return Record->getLambdaExplicitTemplateParameters();
1441ExprWithCleanups::ExprWithCleanups(
Expr *subexpr,
1442 bool CleanupsHaveSideEffects,
1444 :
FullExpr(ExprWithCleanupsClass, subexpr) {
1447 llvm::copy(objects, getTrailingObjects());
1451 bool CleanupsHaveSideEffects,
1453 void *buffer =
C.Allocate(totalSizeToAlloc<CleanupObject>(objects.size()),
1459ExprWithCleanups::ExprWithCleanups(EmptyShell empty,
unsigned numObjects)
1460 :
FullExpr(ExprWithCleanupsClass, empty) {
1466 unsigned numObjects) {
1467 void *buffer =
C.Allocate(totalSizeToAlloc<CleanupObject>(numObjects),
1472CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(
1475 :
Expr(CXXUnresolvedConstructExprClass,
T,
1476 (TSI->getType()->isLValueReferenceType() ?
VK_LValue
1477 : TSI->getType()->isRValueReferenceType() ?
VK_XValue
1480 TypeAndInitForm(TSI, IsListInit), LParenLoc(LParenLoc),
1481 RParenLoc(RParenLoc) {
1483 auto **StoredArgs = getTrailingObjects();
1484 llvm::copy(Args, StoredArgs);
1492 void *Mem = Context.
Allocate(totalSizeToAlloc<Expr *>(Args.size()));
1494 RParenLoc, IsListInit);
1500 void *Mem = Context.
Allocate(totalSizeToAlloc<Expr *>(NumArgs));
1505 return TypeAndInitForm.getPointer()->getTypeLoc().getBeginLoc();
1508CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(
1514 :
Expr(CXXDependentScopeMemberExprClass, Ctx.DependentTy,
VK_LValue,
1516 Base(
Base), BaseType(BaseType), QualifierLoc(QualifierLoc),
1517 MemberNameInfo(MemberNameInfo) {
1520 (TemplateArgs !=
nullptr) || TemplateKWLoc.
isValid();
1522 FirstQualifierFoundInScope !=
nullptr;
1526 auto Deps = TemplateArgumentDependence::None;
1527 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
1528 TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(),
1530 }
else if (TemplateKWLoc.
isValid()) {
1531 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
1535 if (hasFirstQualifierFoundInScope())
1536 *getTrailingObjects<NamedDecl *>() = FirstQualifierFoundInScope;
1540CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(
1541 EmptyShell
Empty,
bool HasTemplateKWAndArgsInfo,
1542 bool HasFirstQualifierFoundInScope)
1543 :
Expr(CXXDependentScopeMemberExprClass,
Empty) {
1545 HasTemplateKWAndArgsInfo;
1547 HasFirstQualifierFoundInScope;
1556 bool HasTemplateKWAndArgsInfo =
1557 (TemplateArgs !=
nullptr) || TemplateKWLoc.
isValid();
1558 unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->
size() : 0;
1559 bool HasFirstQualifierFoundInScope = FirstQualifierFoundInScope !=
nullptr;
1563 HasTemplateKWAndArgsInfo, NumTemplateArgs, HasFirstQualifierFoundInScope);
1567 Ctx,
Base, BaseType, IsArrow, OperatorLoc, QualifierLoc, TemplateKWLoc,
1568 FirstQualifierFoundInScope, MemberNameInfo, TemplateArgs);
1572 const ASTContext &Ctx,
bool HasTemplateKWAndArgsInfo,
1573 unsigned NumTemplateArgs,
bool HasFirstQualifierFoundInScope) {
1574 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
1578 HasTemplateKWAndArgsInfo, NumTemplateArgs, HasFirstQualifierFoundInScope);
1582 EmptyShell(), HasTemplateKWAndArgsInfo, HasFirstQualifierFoundInScope);
1599 if (isa<UnresolvedUsingValueDecl>(
decl))
1604 if (cast<CXXMethodDecl>(
decl->getUnderlyingDecl()->getAsFunction())
1607 }
while (++begin != end);
1612UnresolvedMemberExpr::UnresolvedMemberExpr(
1620 UnresolvedMemberExprClass, Context, QualifierLoc, TemplateKWLoc,
1621 MemberNameInfo, TemplateArgs,
Begin, End,
1623 ((
Base &&
Base->isTypeDependent()) || BaseType->isDependentType()),
1624 ((
Base &&
Base->isInstantiationDependent()) ||
1625 BaseType->isInstantiationDependentType()),
1627 ((
Base &&
Base->containsUnexpandedParameterPack()) ||
1628 BaseType->containsUnexpandedParameterPack())),
1629 Base(
Base), BaseType(BaseType), OperatorLoc(OperatorLoc) {
1630 UnresolvedMemberExprBits.IsArrow = IsArrow;
1631 UnresolvedMemberExprBits.HasUnresolvedUsing = HasUnresolvedUsing;
1639UnresolvedMemberExpr::UnresolvedMemberExpr(EmptyShell
Empty,
1640 unsigned NumResults,
1641 bool HasTemplateKWAndArgsInfo)
1643 HasTemplateKWAndArgsInfo) {}
1649 return cast<Expr>(
Base)->isImplicitCXXThis();
1659 unsigned NumResults = End -
Begin;
1660 bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.
isValid();
1661 unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->
size() : 0;
1664 NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
1667 Context, HasUnresolvedUsing,
Base, BaseType, IsArrow, OperatorLoc,
1668 QualifierLoc, TemplateKWLoc, MemberNameInfo, TemplateArgs,
Begin, End);
1672 const ASTContext &Context,
unsigned NumResults,
1673 bool HasTemplateKWAndArgsInfo,
unsigned NumTemplateArgs) {
1674 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
1677 NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
1694 assert(
Record &&
"qualifier in member expression does not name record");
1703 assert(
Record &&
"base of member expression does not name record");
1716 Context.
Allocate(totalSizeToAlloc<TemplateArgument>(PartialArgs.size()));
1718 PackLoc, RParenLoc, Length, PartialArgs);
1722 unsigned NumPartialArgs) {
1724 Context.
Allocate(totalSizeToAlloc<TemplateArgument>(NumPartialArgs));
1729 return cast<NamedDecl>(
1735 Expr *PackIdExpr,
Expr *IndexExpr, std::optional<int64_t> Index,
1738 if (Index && FullySubstituted && !SubstitutedExprs.empty())
1739 Type = SubstitutedExprs[*Index]->getType();
1744 Context.
Allocate(totalSizeToAlloc<Expr *>(SubstitutedExprs.size()));
1745 return new (Storage)
1747 SubstitutedExprs, FullySubstituted);
1752 NamedDecl *ND = dyn_cast<NamedDecl>(
D->getDecl());
1753 assert(ND &&
"exected a named decl");
1756 assert(
false &&
"invalid declaration kind in pack indexing expression");
1762 unsigned NumTransformedExprs) {
1764 Context.
Allocate(totalSizeToAlloc<Expr *>(NumTransformedExprs));
1777 return Type.getUnqualifiedType();
1780SubstNonTypeTemplateParmPackExpr::SubstNonTypeTemplateParmPackExpr(
1785 AssociatedDecl(AssociatedDecl), Arguments(ArgPack.pack_begin()),
1786 NumArguments(ArgPack.pack_size()), Final(Final), Index(Index),
1788 assert(AssociatedDecl !=
nullptr);
1790 ExprDependence::UnexpandedPack);
1795 return cast<NonTypeTemplateParmDecl>(
1808 ParamPack(ParamPack), NameLoc(NameLoc), NumParameters(NumParams) {
1810 std::uninitialized_copy(Params, Params + NumParams, getTrailingObjects());
1812 ExprDependence::UnexpandedPack);
1819 return new (Context.
Allocate(totalSizeToAlloc<ValueDecl *>(Params.size())))
1825 unsigned NumParams) {
1826 return new (Context.
Allocate(totalSizeToAlloc<ValueDecl *>(NumParams)))
1833 :
Expr(MaterializeTemporaryExprClass,
T,
1837 MTD->ExprWithTemporary = Temporary;
1845 unsigned ManglingNumber) {
1852 if (!isa<LifetimeExtendedTemporaryDecl *>(State))
1854 cast<Expr>(cast<Stmt *>(State)), ExtendedBy, ManglingNumber);
1856 auto ES = cast<LifetimeExtendedTemporaryDecl *>(State);
1857 ES->ExtendingDecl = ExtendedBy;
1858 ES->ManglingNumber = ManglingNumber;
1872 VD->isUsableInConstantExpressions(Context);
1878 std::variant<bool, APValue>
Value)
1880 RParenLoc(RParenLoc) {
1881 assert(Kind <=
TT_Last &&
"invalid enum value!");
1885 "TypeTraitExprBits.Kind overflow!");
1891 ::new (getTrailingObjects<APValue>())
1898 llvm::copy(Args, ToArgs);
1903 getAPValue().isInt() || getAPValue().isAbsent()) &&
1904 "Only
int values are supported by
clang");
1910 if (!IsStoredAsBool)
1911 ::new (getTrailingObjects<APValue>())
APValue();
1921 C.Allocate(totalSizeToAlloc<APValue, TypeSourceInfo *>(0, Args.size()));
1930 C.Allocate(totalSizeToAlloc<APValue, TypeSourceInfo *>(1, Args.size()));
1935 bool IsStoredAsBool,
1937 void *Mem =
C.Allocate(totalSizeToAlloc<APValue, TypeSourceInfo *>(
1938 IsStoredAsBool ? 0 : 1, NumArgs));
1942CUDAKernelCallExpr::CUDAKernelCallExpr(
Expr *Fn,
CallExpr *Config,
1946 unsigned MinNumArgs)
1947 :
CallExpr(CUDAKernelCallExprClass, Fn, Config, Args, Ty,
VK,
1948 RP, FPFeatures, MinNumArgs, NotADL) {}
1950CUDAKernelCallExpr::CUDAKernelCallExpr(
unsigned NumArgs,
bool HasFPFeatures,
1952 :
CallExpr(CUDAKernelCallExprClass, END_PREARG, NumArgs,
1953 HasFPFeatures,
Empty) {}
1959 unsigned MinNumArgs) {
1961 unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
1965 Ctx.
Allocate(sizeToAllocateForCallExprSubclass<CUDAKernelCallExpr>(
1966 SizeOfTrailingObjects),
1978 END_PREARG, NumArgs, HasFPFeatures);
1980 Ctx.
Allocate(sizeToAllocateForCallExprSubclass<CUDAKernelCallExpr>(
1981 SizeOfTrailingObjects),
1988 unsigned NumUserSpecifiedExprs,
1991 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(Args.size()));
1993 LParenLoc, RParenLoc);
1999 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(NumExprs),
2010 EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc),
2011 NumExpansions(NumExpansions) {
2017 "Exactly one of LHS or RHS should contain an unexpanded pack");
2018 SubExprs[SubExpr::Callee] = Callee;
2019 SubExprs[SubExpr::LHS] = LHS;
2020 SubExprs[SubExpr::RHS] = RHS;
Defines the clang::ASTContext interface.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
static bool hasOnlyNonStaticMemberFunctions(UnresolvedSetIterator begin, UnresolvedSetIterator end)
static bool isGLValueFromPointerDeref(const Expr *E)
static bool UnresolvedLookupExprIsVariableOrConceptParameterPack(UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Defines the clang::Expr interface and subclasses for C++ expressions.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the LambdaCapture class.
llvm::MachO::Record Record
Defines an enumeration for C++ overloaded operators.
Defines the clang::SourceLocation class and associated facilities.
Defines various enumerations that describe declaration and type specifiers.
static QualType getPointeeType(const MemRegion *R)
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
a trap message and trap category.
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 ...
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
const LangOptions & getLangOpts() const
CanQualType BoundMemberTy
void * Allocate(size_t Size, unsigned Align=8) const
QualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
CanQualType getCanonicalTagType(const TagDecl *TD) const
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
Represents a call to a CUDA kernel function.
static CUDAKernelCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)
static CUDAKernelCallExpr * Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RP, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0)
A C++ addrspace_cast expression (currently only enabled for OpenCL).
static CXXAddrspaceCastExpr * CreateEmpty(const ASTContext &Context)
static CXXAddrspaceCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Represents a base class of a C++ class.
Represents binding an expression to a temporary.
static CXXBindTemporaryExpr * Create(const ASTContext &C, CXXTemporary *Temp, Expr *SubExpr)
A C++ const_cast expression (C++ [expr.const.cast]).
static CXXConstCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, Expr *Op, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
static CXXConstCastExpr * CreateEmpty(const ASTContext &Context)
Represents a call to a C++ constructor.
SourceRange getParenOrBraceRange() const
static CXXConstructExpr * Create(const ASTContext &Ctx, QualType Ty, SourceLocation Loc, CXXConstructorDecl *Ctor, bool Elidable, ArrayRef< Expr * > Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, CXXConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
Create a C++ construction expression.
Expr * getArg(unsigned Arg)
Return the specified argument.
CXXConstructExpr(StmtClass SC, QualType Ty, SourceLocation Loc, CXXConstructorDecl *Ctor, bool Elidable, ArrayRef< Expr * > Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, CXXConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
Build a C++ construction expression.
SourceLocation getLocation() const
static unsigned sizeOfTrailingObjects(unsigned NumArgs)
Return the size in bytes of the trailing objects.
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getBeginLoc() const LLVM_READONLY
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
static CXXConstructExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs)
Create an empty C++ construction expression.
Represents a C++ constructor within a class.
A default argument (C++ [dcl.fct.default]).
const ParmVarDecl * getParam() const
Expr * getRewrittenExpr()
Expr * getAdjustedRewrittenExpr()
static CXXDefaultArgExpr * Create(const ASTContext &C, SourceLocation Loc, ParmVarDecl *Param, Expr *RewrittenExpr, DeclContext *UsedContext)
static CXXDefaultArgExpr * CreateEmpty(const ASTContext &C, bool HasRewrittenInit)
bool hasRewrittenInit() const
A use of a default initializer in a constructor or in aggregate initialization.
static CXXDefaultInitExpr * Create(const ASTContext &Ctx, SourceLocation Loc, FieldDecl *Field, DeclContext *UsedContext, Expr *RewrittenInitExpr)
Field is the non-static data member whose default initializer is used by this expression.
const Expr * getRewrittenExpr() const
Retrieve the initializing expression with evaluated immediate calls, if any.
bool hasRewrittenInit() const
Expr * getExpr()
Get the initialization expression that will be used.
static CXXDefaultInitExpr * CreateEmpty(const ASTContext &C, bool HasRewrittenInit)
FunctionDecl * getOperatorDelete() const
QualType getDestroyedType() const
Retrieve the type being destroyed.
Represents a C++ member access expression where the actual member referenced could not be resolved be...
static CXXDependentScopeMemberExpr * Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
static CXXDependentScopeMemberExpr * CreateEmpty(const ASTContext &Ctx, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs, bool HasFirstQualifierFoundInScope)
Represents a C++ destructor within a class.
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
static CXXDynamicCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
static CXXDynamicCastExpr * CreateEmpty(const ASTContext &Context, unsigned pathSize)
bool isAlwaysNull() const
isAlwaysNull - Return whether the result of the dynamic_cast is proven to always be null.
CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee, SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Opcode, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, UnsignedOrNone NumExpansions)
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....
static CXXFunctionalCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getEndLoc() const LLVM_READONLY
static CXXFunctionalCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, TypeSourceInfo *Written, CastKind Kind, Expr *Op, const CXXCastPath *Path, FPOptionsOverride FPO, SourceLocation LPLoc, SourceLocation RPLoc)
Represents a call to a member function that may be written either with member call syntax (e....
CXXMethodDecl * getMethodDecl() const
Retrieve the declaration of the called method.
Expr * getImplicitObjectArgument() const
Retrieve the implicit object argument for the member call.
static CXXMemberCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)
static CXXMemberCallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RP, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0)
QualType getObjectType() const
Retrieve the type of the object argument.
CXXRecordDecl * getRecordDecl() const
Retrieve the CXXRecordDecl for the underlying type of the implicit object argument.
Represents a static or instance method of a struct/union/class.
const char * getCastName() const
getCastName - Get the name of the C++ cast being used, e.g., "static_cast", "dynamic_cast",...
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
static CXXNewExpr * Create(const ASTContext &Ctx, bool IsGlobalNew, FunctionDecl *OperatorNew, FunctionDecl *OperatorDelete, const ImplicitAllocationParameters &IAP, bool UsualArrayDeleteWantsSize, ArrayRef< Expr * > PlacementArgs, SourceRange TypeIdParens, std::optional< Expr * > ArraySize, CXXNewInitializationStyle InitializationStyle, Expr *Initializer, QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range, SourceRange DirectInitRange)
Create a c++ new expression.
static CXXNewExpr * CreateEmpty(const ASTContext &Ctx, bool IsArray, bool HasInit, unsigned NumPlacementArgs, bool IsParenTypeId)
Create an empty c++ new expression.
bool shouldNullCheckAllocation() const
True if the allocation result needs to be null-checked.
FunctionDecl * getOperatorNew() const
A call to an overloaded operator written using operator syntax.
bool isInfixBinaryOp() const
Is this written as an infix binary operator?
SourceLocation getOperatorLoc() const
Returns the location of the operator symbol in the expression.
SourceLocation getEndLoc() const
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
static CXXOperatorCallExpr * Create(const ASTContext &Ctx, OverloadedOperatorKind OpKind, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation OperatorLoc, FPOptionsOverride FPFeatures, ADLCallKind UsesADL=NotADL)
static CXXOperatorCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)
SourceLocation getBeginLoc() const
Represents a list-initialization with parenthesis.
static CXXParenListInitExpr * Create(ASTContext &C, ArrayRef< Expr * > Args, QualType T, unsigned NumUserSpecifiedExprs, SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
static CXXParenListInitExpr * CreateEmpty(ASTContext &C, unsigned numExprs, EmptyShell Empty)
CXXPseudoDestructorExpr(const ASTContext &Context, Expr *Base, bool isArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, TypeSourceInfo *ScopeType, SourceLocation ColonColonLoc, SourceLocation TildeLoc, PseudoDestructorTypeStorage DestroyedType)
SourceLocation getEndLoc() const LLVM_READONLY
QualType getDestroyedType() const
Retrieve the type being destroyed.
Represents a C++ struct/union/class.
capture_const_iterator captures_end() const
capture_const_iterator captures_begin() const
A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).
static CXXReinterpretCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
static CXXReinterpretCastExpr * CreateEmpty(const ASTContext &Context, unsigned pathSize)
Expr * getSemanticForm()
Get an equivalent semantic form for this expression.
bool isReversed() const
Determine whether this expression was rewritten in reverse form.
DecomposedForm getDecomposedForm() const LLVM_READONLY
Decompose this operator into its syntactic form.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getRParenLoc() const
A C++ static_cast expression (C++ [expr.static.cast]).
static CXXStaticCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written, FPOptionsOverride FPO, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
static CXXStaticCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool hasFPFeatures)
Represents a C++ functional cast expression that builds a temporary object.
static CXXTemporaryObjectExpr * Create(const ASTContext &Ctx, CXXConstructorDecl *Cons, QualType Ty, TypeSourceInfo *TSI, ArrayRef< Expr * > Args, SourceRange ParenOrBraceRange, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization)
TypeSourceInfo * getTypeSourceInfo() const
SourceLocation getEndLoc() const LLVM_READONLY
static CXXTemporaryObjectExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs)
SourceLocation getBeginLoc() const LLVM_READONLY
Represents a C++ temporary.
static CXXTemporary * Create(const ASTContext &C, const CXXDestructorDecl *Destructor)
Represents the this expression in C++.
static CXXThisExpr * CreateEmpty(const ASTContext &Ctx)
static CXXThisExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType Ty, bool IsImplicit)
bool isTypeOperand() const
QualType getTypeOperand(const ASTContext &Context) const
Retrieves the type operand of this typeid() expression after various required adjustments (removing r...
Expr * getExprOperand() const
bool isMostDerived(const ASTContext &Context) const
Best-effort check if the expression operand refers to a most derived object.
bool isPotentiallyEvaluated() const
Determine whether this typeid has a type operand which is potentially evaluated, per C++11 [expr....
bool hasNullCheck() const
Whether this is of a form like "typeid(*ptr)" that can throw a std::bad_typeid if a pointer is a null...
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
static CXXUnresolvedConstructExpr * Create(const ASTContext &Context, QualType T, TypeSourceInfo *TSI, SourceLocation LParenLoc, ArrayRef< Expr * > Args, SourceLocation RParenLoc, bool IsListInit)
SourceLocation getBeginLoc() const LLVM_READONLY
static CXXUnresolvedConstructExpr * CreateEmpty(const ASTContext &Context, unsigned NumArgs)
QualType getTypeOperand(ASTContext &Context) const
Retrieves the type operand of this __uuidof() expression after various required adjustments (removing...
bool isTypeOperand() const
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
static unsigned sizeOfTrailingObjects(unsigned NumPreArgs, unsigned NumArgs, bool HasFPFeatures)
Return the size in bytes needed for the trailing objects.
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
SourceLocation getRParenLoc() const
static constexpr ADLCallKind UsesADL
CastKind getCastKind() const
CompoundStmt - This represents a group of statements like { stmt stmt }.
A POD class for pairing a NamedDecl* with an access specifier.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Decl - This represents one declaration (or definition), e.g.
const AssociatedConstraint & getTrailingRequiresClause() const
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
A qualified reference to a name whose declaration cannot yet be resolved.
static DependentScopeDeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
static DependentScopeDeclRefExpr * CreateEmpty(const ASTContext &Context, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
TypeSourceInfo * getTypeInfoAsWritten() const
getTypeInfoAsWritten - Returns the type source info for the type that this expression is casting to.
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
static ExprWithCleanups * Create(const ASTContext &C, EmptyShell empty, unsigned numObjects)
This represents one expression.
Expr * IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY
Skip past any parentheses and casts which do not change the value (including ptr->int casts of the sa...
bool isValueDependent() const
Determines whether the value of this expression depends on.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates).
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool isDefaultArgument() const
Determine whether this expression is a default function argument.
void setDependence(ExprDependence Deps)
Each concrete expr subclass is expected to compute its dependence and call this in the constructor.
Represents difference between two FPOptions values.
bool requiresTrailingStorage() const
Represents a member of a struct/union/class.
FullExpr - Represents a "full-expression" node.
Represents a function declaration or definition.
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
bool isReservedGlobalPlacementOperator() const
Determines whether this operator new or delete is one of the reserved global placement operators: voi...
Represents a reference to a function parameter pack, init-capture pack, or binding pack that has been...
static FunctionParmPackExpr * Create(const ASTContext &Context, QualType T, ValueDecl *ParamPack, SourceLocation NameLoc, ArrayRef< ValueDecl * > Params)
static FunctionParmPackExpr * CreateEmpty(const ASTContext &Context, unsigned NumParams)
Represents a prototype with parameter type info, e.g.
Declaration of a template function.
One of these records is kept for each identifier that is lexed.
Describes the capture of a variable or of this, or of a C++1y init-capture.
bool capturesVLAType() const
Determine whether this captures a variable length array bound expression.
LambdaCapture(SourceLocation Loc, bool Implicit, LambdaCaptureKind Kind, ValueDecl *Var=nullptr, SourceLocation EllipsisLoc=SourceLocation())
Create a new capture of a variable or of this.
LambdaCaptureKind getCaptureKind() const
Determine the kind of capture.
bool capturesThis() const
Determine whether this capture handles the C++ this pointer.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
capture_iterator capture_begin() const
Retrieve an iterator pointing to the first lambda capture.
static LambdaExpr * CreateDeserialized(const ASTContext &C, unsigned NumCaptures)
Construct a new lambda expression that will be deserialized from an external source.
static LambdaExpr * Create(const ASTContext &C, CXXRecordDecl *Class, SourceRange IntroducerRange, LambdaCaptureDefault CaptureDefault, SourceLocation CaptureDefaultLoc, bool ExplicitParams, bool ExplicitResultType, ArrayRef< Expr * > CaptureInits, SourceLocation ClosingBrace, bool ContainsUnexpandedParameterPack)
Construct a new lambda expression.
Stmt * getBody() const
Retrieve the body of the lambda.
bool isMutable() const
Determine whether the lambda is mutable, meaning that any captures values can be modified.
capture_iterator implicit_capture_end() const
Retrieve an iterator pointing past the end of the sequence of implicit lambda captures.
unsigned capture_size() const
Determine the number of captures in this lambda.
capture_range explicit_captures() const
Retrieve this lambda's explicit captures.
bool isInitCapture(const LambdaCapture *Capture) const
Determine whether one of this lambda's captures is an init-capture.
CXXMethodDecl * getCallOperator() const
Retrieve the function call operator associated with this lambda expression.
const CompoundStmt * getCompoundStmtBody() const
Retrieve the CompoundStmt representing the body of the lambda.
capture_range implicit_captures() const
Retrieve this lambda's implicit captures.
const AssociatedConstraint & getTrailingRequiresClause() const
Get the trailing requires clause, if any.
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.
capture_iterator explicit_capture_begin() const
Retrieve an iterator pointing to the first explicit lambda capture.
child_range children()
Includes the captures and the body of the lambda.
FunctionTemplateDecl * getDependentCallOperator() const
Retrieve the function template call operator associated with this lambda expression.
capture_range captures() const
Retrieve this lambda's captures.
CXXRecordDecl * getLambdaClass() const
Retrieve the class that corresponds to the lambda.
Implicit declaration of a temporary that was materialized by a MaterializeTemporaryExpr and lifetime-...
static LifetimeExtendedTemporaryDecl * Create(Expr *Temp, ValueDecl *EDec, unsigned Mangling)
MaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference, LifetimeExtendedTemporaryDecl *MTD=nullptr)
ValueDecl * getExtendingDecl()
Get the declaration which triggered the lifetime-extension of this temporary, if any.
bool isUsableInConstantExpressions(const ASTContext &Context) const
Determine whether this temporary object is usable in constant expressions, as specified in C++20 [exp...
void setExtendingDecl(ValueDecl *ExtendedBy, unsigned ManglingNumber)
This represents a decl that may have a name.
A C++ nested-name-specifier augmented with source location information.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
const Type * getAsType() const
@ Type
A type, stored as a Type*.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
ASTTemplateKWAndArgsInfo * getTrailingASTTemplateKWAndArgsInfo()
Return the optional template keyword and arguments info.
NestedNameSpecifier getQualifier() const
Fetches the nested-name qualifier, if one was given.
TemplateArgumentLoc * getTrailingTemplateArgumentLoc()
Return the optional template arguments.
DeclAccessPair * getTrailingResults()
Return the results. Defined after UnresolvedMemberExpr.
OverloadExpr(StmtClass SC, const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent, bool KnownInstantiationDependent, bool KnownContainsUnexpandedParameterPack)
NamedDecl * getPackDecl() const
static PackIndexingExpr * CreateDeserialized(ASTContext &Context, unsigned NumTransformedExprs)
Expr * getPackIdExpression() const
static PackIndexingExpr * Create(ASTContext &Context, SourceLocation EllipsisLoc, SourceLocation RSquareLoc, Expr *PackIdExpr, Expr *IndexExpr, std::optional< int64_t > Index, ArrayRef< Expr * > SubstitutedExprs={}, bool FullySubstituted=false)
Represents a parameter to a function.
PointerType - C99 6.7.5.1 - Pointer Declarators.
Stores the type being destroyed by a pseudo-destructor expression.
PseudoDestructorTypeStorage()=default
SourceLocation getLocation() const
TypeSourceInfo * getTypeSourceInfo() const
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isConstant(const ASTContext &Ctx) const
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
The collection of all-type qualifiers we support.
Represents an expression that computes the length of a parameter pack.
static SizeOfPackExpr * CreateDeserialized(ASTContext &Context, unsigned NumPartialArgs)
static SizeOfPackExpr * Create(ASTContext &Context, SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, UnsignedOrNone Length=std::nullopt, ArrayRef< TemplateArgument > PartialArgs={})
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
void setEnd(SourceLocation e)
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
CXXUnresolvedConstructExprBitfields CXXUnresolvedConstructExprBits
ExprWithCleanupsBitfields ExprWithCleanupsBits
StmtClass getStmtClass() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
OverloadExprBitfields OverloadExprBits
CXXConstructExprBitfields CXXConstructExprBits
CXXDependentScopeMemberExprBitfields CXXDependentScopeMemberExprBits
TypeTraitExprBitfields TypeTraitExprBits
CXXNewExprBitfields CXXNewExprBits
llvm::iterator_range< child_iterator > child_range
CXXFoldExprBitfields CXXFoldExprBits
CXXDefaultInitExprBitfields CXXDefaultInitExprBits
DependentScopeDeclRefExprBitfields DependentScopeDeclRefExprBits
llvm::iterator_range< const_child_iterator > const_child_range
CXXDefaultArgExprBitfields CXXDefaultArgExprBits
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
QualType getParameterType(const ASTContext &Ctx) const
Determine the substituted type of the template parameter.
bool isReferenceParameter() const
NamedDecl * getParameter() const
TemplateArgument getArgumentPack() const
Retrieve the template argument pack containing the substituted template arguments.
NonTypeTemplateParmDecl * getParameterPack() const
Retrieve the non-type template parameter pack being substituted.
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
A convenient class for passing around template argument information.
Location wrapper for a TemplateArgument.
Represents a template argument.
Stores a list of template parameters for a TemplateDecl and its derived classes.
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
static TypeTraitExpr * Create(const ASTContext &C, QualType T, SourceLocation Loc, TypeTrait Kind, ArrayRef< TypeSourceInfo * > Args, SourceLocation RParenLoc, bool Value)
Create a new type trait expression.
static TypeTraitExpr * CreateDeserialized(const ASTContext &C, bool IsStoredAsBool, unsigned NumArgs)
The base class of the type hierarchy.
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isVoidPointerType() const
bool isPointerType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isPointerOrReferenceType() const
bool isFloatingType() const
bool isAnyPointerType() const
bool isRecordType() const
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
static UnresolvedLookupExpr * CreateEmpty(const ASTContext &Context, unsigned NumResults, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent, bool KnownInstantiationDependent)
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
QualType getBaseType() const
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '.
static UnresolvedMemberExpr * Create(const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
CXXRecordDecl * getNamingClass()
Retrieve the naming class of this lookup.
bool isImplicitAccess() const
True if this is an implicit access, i.e., one in which the member being accessed was not written in t...
static UnresolvedMemberExpr * CreateEmpty(const ASTContext &Context, unsigned NumResults, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
The iterator over UnresolvedSets.
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit....
LiteralOperatorKind getLiteralOperatorKind() const
Returns the kind of literal operator invocation which this expression represents.
const IdentifierInfo * getUDSuffix() const
Returns the ud-suffix specified for this literal.
static UserDefinedLiteral * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation LitEndLoc, SourceLocation SuffixLoc, FPOptionsOverride FPFeatures)
static UserDefinedLiteral * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPOptions, EmptyShell Empty)
Expr * getCookedLiteral()
If this is not a raw user-defined literal, get the underlying cooked literal (representing the litera...
LiteralOperatorKind
The kind of literal operator which is invoked.
@ LOK_String
operator "" X (const CharT *, size_t)
@ LOK_Raw
Raw form: operator "" X (const char *)
@ LOK_Floating
operator "" X (long double)
@ LOK_Integer
operator "" X (unsigned long long)
@ LOK_Template
Raw form: operator "" X<cs...> ()
@ LOK_Character
operator "" X (CharT)
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
The JSON file list parser is used to communicate input to InstallAPI.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ OK_Ordinary
An ordinary object is located at an address in memory.
LambdaCaptureKind
The different capture forms in a lambda introducer.
@ LCK_ByCopy
Capturing by copy (a.k.a., by value)
@ LCK_ByRef
Capturing by reference.
@ LCK_VLAType
Capturing variable-length array type.
@ LCK_StarThis
Capturing the *this object by copy.
@ LCK_This
Capturing the *this object by reference.
ExprDependence computeDependence(FullExpr *E)
@ Create
'create' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...
bool isAlignedAllocation(AlignedAllocationMode Mode)
@ Result
The result type of a method or function.
bool isTypeAwareAllocation(TypeAwareAllocationMode Mode)
CastKind
CastKind - The kind of operation required for a conversion.
LambdaCaptureDefault
The default, if any, capture method for a lambda expression.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
TemplateParameterList * getReplacedTemplateParameterList(const Decl *D)
Internal helper used by Subst* nodes to retrieve the parameter list for their AssociatedDecl.
const FunctionProtoType * T
@ Class
The "class" keyword introduces the elaborated-type-specifier.
TypeTrait
Names for traits that operate specifically on types.
CXXNewInitializationStyle
@ Parens
New-expression has a C++98 paren-delimited initializer.
@ None
New-expression has no initializer as written.
@ Braces
New-expression has a C++11 list-initializer.
@ Implicit
An implicit conversion.
Diagnostic wrappers for TextAPI types for error reporting.
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
void initializeFrom(SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &List, TemplateArgumentLoc *OutArgArray)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
AlignedAllocationMode PassAlignment
TypeAwareAllocationMode PassTypeIdentity
A placeholder type used to construct an empty shell of a type, that will be filled in later (e....