34#include "llvm/ADT/ArrayRef.h"
35#include "llvm/Support/Casting.h"
36#include "llvm/Support/ErrorHandling.h"
58 case OO_Call:
case OO_Subscript:
71 bool SkippedNot =
false;
72 if (
auto *NotEq = dyn_cast<UnaryOperator>(
E)) {
73 assert(NotEq->getOpcode() == UO_LNot);
79 if (
auto *BO = dyn_cast<BinaryOperator>(
E)) {
80 assert(!SkippedNot || BO->getOpcode() == BO_EQ);
81 Result.Opcode = SkippedNot ? BO_NE : BO->getOpcode();
85 }
else if (
auto *BO = dyn_cast<CXXOperatorCallExpr>(
E)) {
86 assert(!SkippedNot || BO->getOperator() == OO_EqualEqual);
87 assert(BO->isInfixBinaryOp());
88 switch (BO->getOperator()) {
89 case OO_Less:
Result.Opcode = BO_LT;
break;
90 case OO_LessEqual:
Result.Opcode = BO_LE;
break;
91 case OO_Greater:
Result.Opcode = BO_GT;
break;
92 case OO_GreaterEqual:
Result.Opcode = BO_GE;
break;
93 case OO_Spaceship:
Result.Opcode = BO_Cmp;
break;
94 case OO_EqualEqual:
Result.Opcode = SkippedNot ? BO_NE : BO_EQ;
break;
95 default: llvm_unreachable(
"unexpected binop in rewritten operator expr");
97 Result.LHS = BO->getArg(0);
98 Result.RHS = BO->getArg(1);
101 llvm_unreachable(
"unexpected rewritten operator form");
114 E =
Result.LHS->IgnoreUnlessSpelledInSource();
115 if (
auto *BO = dyn_cast<BinaryOperator>(
E)) {
116 assert(BO->getOpcode() == BO_Cmp);
117 Result.LHS = BO->getLHS();
118 Result.RHS = BO->getRHS();
120 }
else if (
auto *BO = dyn_cast<CXXOperatorCallExpr>(
E)) {
121 assert(BO->getOperator() == OO_Spaceship);
122 Result.LHS = BO->getArg(0);
123 Result.RHS = BO->getArg(1);
126 llvm_unreachable(
"unexpected rewritten operator form");
151 assert(!
isTypeOperand() &&
"Cannot call isMostDerived for typeid(type)");
153 if (
const auto *DRE = dyn_cast<DeclRefExpr>(
E)) {
154 QualType Ty = DRE->getDecl()->getType();
163 assert(
isTypeOperand() &&
"Cannot call getTypeOperand for typeid(expr)");
172 if (
const auto *CE = dyn_cast<CastExpr>(
E)) {
173 if (!CE->getSubExpr()->isGLValue())
178 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(
E))
181 if (
const auto *BO = dyn_cast<BinaryOperator>(
E))
182 if (BO->getOpcode() == BO_Comma)
185 if (
const auto *ACO = dyn_cast<AbstractConditionalOperator>(
E))
191 if (isa<ArraySubscriptExpr>(
E))
194 if (
const auto *UO = dyn_cast<UnaryOperator>(
E))
195 if (UO->getOpcode() == UO_Deref)
217 assert(
isTypeOperand() &&
"Cannot call getTypeOperand for __uuidof(expr)");
229CXXNewExpr::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!");
250 CXXNewExprBits.UsualArrayDeleteWantsSize = UsualArrayDeleteWantsSize;
253 llvm::to_underlying(InitializationStyle);
254 bool IsParenTypeId = TypeIdParens.
isValid();
259 getTrailingObjects<Stmt *>()[arraySizeOffset()] = *ArraySize;
261 getTrailingObjects<Stmt *>()[initExprOffset()] =
Initializer;
262 for (
unsigned I = 0; I != PlacementArgs.size(); ++I)
263 getTrailingObjects<Stmt *>()[placementNewArgsOffset() + I] =
266 getTrailingObjects<SourceRange>()[0] = TypeIdParens;
268 switch (getInitializationStyle()) {
284CXXNewExpr::CXXNewExpr(EmptyShell
Empty,
bool IsArray,
285 unsigned NumPlacementArgs,
bool IsParenTypeId)
296 SourceRange TypeIdParens, std::optional<Expr *> ArraySize,
300 bool IsArray = ArraySize.has_value();
302 unsigned NumPlacementArgs = PlacementArgs.size();
303 bool IsParenTypeId = TypeIdParens.
isValid();
305 Ctx.
Allocate(totalSizeToAlloc<Stmt *, SourceRange>(
306 IsArray + HasInit + NumPlacementArgs, IsParenTypeId),
309 CXXNewExpr(IsGlobalNew, OperatorNew, OperatorDelete, ShouldPassAlignment,
310 UsualArrayDeleteWantsSize, PlacementArgs, TypeIdParens,
312 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();
400UnresolvedLookupExpr::UnresolvedLookupExpr(
406 :
OverloadExpr(UnresolvedLookupExprClass, Context, QualifierLoc,
407 TemplateKWLoc, NameInfo, TemplateArgs,
Begin, End,
409 NamingClass(NamingClass) {
413UnresolvedLookupExpr::UnresolvedLookupExpr(EmptyShell
Empty,
415 bool HasTemplateKWAndArgsInfo)
417 HasTemplateKWAndArgsInfo) {}
423 bool KnownDependent) {
424 unsigned NumResults = End -
Begin;
429 Context, NamingClass, QualifierLoc,
431 nullptr,
Begin, End, KnownDependent);
440 unsigned NumResults = End -
Begin;
441 bool HasTemplateKWAndArgsInfo = Args || TemplateKWLoc.
isValid();
442 unsigned NumTemplateArgs = Args ? Args->
size() : 0;
445 NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
448 TemplateKWLoc, NameInfo, RequiresADL,
449 Args,
Begin, End, KnownDependent);
453 const ASTContext &Context,
unsigned NumResults,
454 bool HasTemplateKWAndArgsInfo,
unsigned NumTemplateArgs) {
455 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
458 NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
471 bool KnownInstantiationDependent,
472 bool KnownContainsUnexpandedParameterPack)
474 QualifierLoc(QualifierLoc) {
475 unsigned NumResults = End -
Begin;
478 (TemplateArgs != nullptr ) || TemplateKWLoc.
isValid();
488 auto Deps = TemplateArgumentDependence::None;
491 }
else if (TemplateKWLoc.
isValid()) {
496 KnownInstantiationDependent,
497 KnownContainsUnexpandedParameterPack));
503 bool HasTemplateKWAndArgsInfo)
510DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(
515 QualifierLoc(QualifierLoc), NameInfo(NameInfo) {
517 (Args !=
nullptr) || TemplateKWLoc.
isValid();
519 auto Deps = TemplateArgumentDependence::None;
520 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
521 TemplateKWLoc, *Args, getTrailingObjects<TemplateArgumentLoc>(), Deps);
522 }
else if (TemplateKWLoc.
isValid()) {
523 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
533 assert(QualifierLoc &&
"should be created for dependent qualifiers");
534 bool HasTemplateKWAndArgsInfo = Args || TemplateKWLoc.
isValid();
536 totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
537 HasTemplateKWAndArgsInfo, Args ? Args->
size() : 0);
540 TemplateKWLoc, NameInfo, Args);
545 bool HasTemplateKWAndArgsInfo,
546 unsigned NumTemplateArgs) {
547 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
549 totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
550 HasTemplateKWAndArgsInfo, NumTemplateArgs);
556 HasTemplateKWAndArgsInfo;
561 if (
const auto *TOE = dyn_cast<CXXTemporaryObjectExpr>(
this))
562 return TOE->getBeginLoc();
567 if (
const auto *TOE = dyn_cast<CXXTemporaryObjectExpr>(
this))
568 return TOE->getEndLoc();
570 if (ParenOrBraceRange.
isValid())
571 return ParenOrBraceRange.
getEnd();
594 :
CallExpr(CXXOperatorCallExprClass, Fn, {}, Args, Ty, VK,
595 OperatorLoc, FPFeatures, 0, UsesADL) {
596 CXXOperatorCallExprBits.OperatorKind = OpKind;
598 (CXXOperatorCallExprBits.OperatorKind ==
static_cast<unsigned>(OpKind)) &&
599 "OperatorKind overflow!");
600 Range = getSourceRangeImpl();
603CXXOperatorCallExpr::CXXOperatorCallExpr(
unsigned NumArgs,
bool HasFPFeatures,
605 :
CallExpr(CXXOperatorCallExprClass, 0, NumArgs,
606 HasFPFeatures,
Empty) {}
615 unsigned NumArgs = Args.size();
629 unsigned SizeOfTrailingObjects =
636SourceRange CXXOperatorCallExpr::getSourceRangeImpl()
const {
638 if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
645 }
else if (Kind == OO_Arrow) {
647 }
else if (Kind == OO_Call) {
649 }
else if (Kind == OO_Subscript) {
665 :
CallExpr(CXXMemberCallExprClass,
Fn, {}, Args, Ty, VK, RP,
668CXXMemberCallExpr::CXXMemberCallExpr(
unsigned NumArgs,
bool HasFPFeatures,
670 :
CallExpr(CXXMemberCallExprClass, 0, NumArgs, HasFPFeatures,
678 unsigned MinNumArgs) {
680 unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
694 unsigned SizeOfTrailingObjects =
703 if (
const auto *MemExpr = dyn_cast<MemberExpr>(Callee))
704 return MemExpr->getBase();
705 if (
const auto *BO = dyn_cast<BinaryOperator>(Callee))
706 if (BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI)
722 return cast<CXXMethodDecl>(MemExpr->getMemberDecl());
749 case CXXStaticCastExprClass:
return "static_cast";
750 case CXXDynamicCastExprClass:
return "dynamic_cast";
751 case CXXReinterpretCastExprClass:
return "reinterpret_cast";
752 case CXXConstCastExprClass:
return "const_cast";
753 case CXXAddrspaceCastExprClass:
return "addrspace_cast";
754 default:
return "<invalid cast>";
764 unsigned PathSize = (BasePath ? BasePath->size() : 0);
766 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
769 FPO, L, RParenLoc, AngleBrackets);
771 std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
778 bool HasFPFeatures) {
780 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
781 PathSize, HasFPFeatures));
793 unsigned PathSize = (BasePath ? BasePath->size() : 0);
794 void *Buffer =
C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
797 RParenLoc, AngleBrackets);
799 std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
806 void *Buffer =
C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
835 assert(SrcRD && DestRD);
837 if (SrcRD->isEffectivelyFinal()) {
838 assert(!SrcRD->isDerivedFrom(DestRD) &&
839 "upcasts should not use CK_Dynamic");
843 if (DestRD->isEffectivelyFinal() && !DestRD->isDerivedFrom(SrcRD))
856 unsigned PathSize = (BasePath ? BasePath->size() : 0);
857 void *Buffer =
C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
860 RParenLoc, AngleBrackets);
862 std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
869 void *Buffer =
C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
903 unsigned PathSize = (BasePath ? BasePath->size() : 0);
905 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
907 auto *
E =
new (Buffer)
910 std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
917 bool HasFPFeatures) {
919 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
920 PathSize, HasFPFeatures));
938 :
CallExpr(UserDefinedLiteralClass, Fn, {}, Args, Ty, VK,
939 LitEndLoc, FPFeatures, 0, NotADL),
940 UDSuffixLoc(SuffixLoc) {}
942UserDefinedLiteral::UserDefinedLiteral(
unsigned NumArgs,
bool HasFPFeatures,
944 :
CallExpr(UserDefinedLiteralClass, 0, NumArgs,
945 HasFPFeatures,
Empty) {}
954 unsigned NumArgs = Args.size();
968 unsigned SizeOfTrailingObjects =
982 assert(
getNumArgs() == 1 &&
"unexpected #args in literal operator call");
984 cast<FunctionDecl>(
getCalleeDecl())->getParamDecl(0)->getType();
994 llvm_unreachable(
"unknown kind of literal operator");
1006 return cast<FunctionDecl>(
getCalleeDecl())->getLiteralIdentifier();
1010 bool HasRewrittenInit) {
1011 size_t Size = totalSizeToAlloc<Expr *>(HasRewrittenInit);
1019 Expr *RewrittenExpr,
1021 size_t Size = totalSizeToAlloc<Expr *>(RewrittenExpr !=
nullptr);
1024 RewrittenExpr, UsedContext);
1034 "expected this CXXDefaultArgExpr to have a rewritten init.");
1036 if (
auto *
E = dyn_cast_if_present<FullExpr>(
Init))
1037 if (!isa<ConstantExpr>(
E))
1038 return E->getSubExpr();
1042CXXDefaultInitExpr::CXXDefaultInitExpr(
const ASTContext &Ctx,
1045 Expr *RewrittenInitExpr)
1046 :
Expr(CXXDefaultInitExprClass, Ty.getNonLValueExprType(Ctx),
1048 : Ty->isRValueReferenceType() ?
VK_XValue
1051 Field(Field), UsedContext(UsedContext) {
1056 *getTrailingObjects<Expr *>() = RewrittenInitExpr;
1058 assert(Field->hasInClassInitializer());
1064 bool HasRewrittenInit) {
1065 size_t Size = totalSizeToAlloc<Expr *>(HasRewrittenInit);
1074 Expr *RewrittenInitExpr) {
1076 size_t Size = totalSizeToAlloc<Expr *>(RewrittenInitExpr !=
nullptr);
1079 UsedContext, RewrittenInitExpr);
1083 assert(Field->getInClassInitializer() &&
"initializer hasn't been parsed");
1087 return Field->getInClassInitializer();
1100 "Expression bound to a temporary must have record or array type!");
1105CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(
1108 bool HadMultipleCandidates,
bool ListInitialization,
1109 bool StdInitListInitialization,
bool ZeroInitialization)
1111 CXXTemporaryObjectExprClass, Ty, TSI->getTypeLoc().getBeginLoc(),
1112 Cons,
false, Args, HadMultipleCandidates,
1113 ListInitialization, StdInitListInitialization, ZeroInitialization,
1119CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(EmptyShell
Empty,
1126 bool HadMultipleCandidates,
bool ListInitialization,
1127 bool StdInitListInitialization,
bool ZeroInitialization) {
1133 Cons, Ty, TSI, Args, ParenOrBraceRange, HadMultipleCandidates,
1134 ListInitialization, StdInitListInitialization, ZeroInitialization);
1160 bool HadMultipleCandidates,
bool ListInitialization,
1161 bool StdInitListInitialization,
bool ZeroInitialization,
1167 CXXConstructExprClass, Ty,
Loc, Ctor, Elidable, Args,
1168 HadMultipleCandidates, ListInitialization, StdInitListInitialization,
1169 ZeroInitialization, ConstructKind, ParenOrBraceRange);
1184 bool ListInitialization,
bool StdInitListInitialization,
1188 ParenOrBraceRange(ParenOrBraceRange), NumArgs(Args.size()) {
1198 Stmt **TrailingArgs = getTrailingArgs();
1199 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
1200 assert(Args[I] &&
"NULL argument in CXXConstructExpr!");
1201 TrailingArgs[I] = Args[I];
1205 if (SC == CXXConstructExprClass)
1216 : DeclAndBits(Var, 0),
Loc(
Loc), EllipsisLoc(EllipsisLoc) {
1219 Bits |= Capture_Implicit;
1223 Bits |= Capture_ByCopy;
1226 assert(!Var &&
"'this' capture cannot have a variable!");
1227 Bits |= Capture_This;
1231 Bits |= Capture_ByCopy;
1234 assert(Var &&
"capture must have a variable!");
1237 assert(!Var &&
"VLA type capture cannot have a variable!");
1240 DeclAndBits.setInt(Bits);
1246 bool CapByCopy = DeclAndBits.getInt() & Capture_ByCopy;
1257 bool ContainsUnexpandedParameterPack)
1259 IntroducerRange(IntroducerRange), CaptureDefaultLoc(CaptureDefaultLoc),
1260 ClosingBrace(ClosingBrace) {
1261 LambdaExprBits.NumCaptures = CaptureInits.size();
1262 LambdaExprBits.CaptureDefault = CaptureDefault;
1263 LambdaExprBits.ExplicitParams = ExplicitParams;
1264 LambdaExprBits.ExplicitResultType = ExplicitResultType;
1268 assert(capture_size() ==
Class->capture_size() &&
"Wrong number of captures");
1269 assert(getCaptureDefault() ==
Class->getLambdaCaptureDefault());
1272 Stmt **Stored = getStoredStmts();
1273 for (
unsigned I = 0, N = CaptureInits.size(); I != N; ++I)
1274 *Stored++ = CaptureInits[I];
1277 *Stored++ = getCallOperator()->getBody();
1282LambdaExpr::LambdaExpr(EmptyShell
Empty,
unsigned NumCaptures)
1284 LambdaExprBits.NumCaptures = NumCaptures;
1288 getStoredStmts()[NumCaptures] =
nullptr;
1295 bool ExplicitParams,
bool ExplicitResultType,
1298 bool ContainsUnexpandedParameterPack) {
1303 unsigned Size = totalSizeToAlloc<Stmt *>(CaptureInits.size() + 1);
1304 void *Mem = Context.
Allocate(Size);
1306 LambdaExpr(
T, IntroducerRange, CaptureDefault, CaptureDefaultLoc,
1307 ExplicitParams, ExplicitResultType, CaptureInits, ClosingBrace,
1308 ContainsUnexpandedParameterPack);
1312 unsigned NumCaptures) {
1313 unsigned Size = totalSizeToAlloc<Stmt *>(NumCaptures + 1);
1314 void *Mem =
C.Allocate(Size);
1318void LambdaExpr::initBodyIfNeeded()
const {
1332 if (
const auto *CoroBody = dyn_cast<CoroutineBodyStmt>(Body))
1333 return cast<CompoundStmt>(CoroBody->getBody());
1334 return cast<CompoundStmt>(Body);
1338 return C->capturesVariable() &&
C->getCapturedVar()->isInitCapture() &&
1385 return Record->getLambdaCallOperator();
1390 return Record->getDependentLambdaCallOperator();
1395 return Record->getGenericLambdaTemplateParameterList();
1400 return Record->getLambdaExplicitTemplateParameters();
1420ExprWithCleanups::ExprWithCleanups(
Expr *subexpr,
1421 bool CleanupsHaveSideEffects,
1423 :
FullExpr(ExprWithCleanupsClass, subexpr) {
1426 for (
unsigned i = 0, e = objects.size(); i != e; ++i)
1427 getTrailingObjects<CleanupObject>()[i] = objects[i];
1431 bool CleanupsHaveSideEffects,
1433 void *buffer =
C.Allocate(totalSizeToAlloc<CleanupObject>(objects.size()),
1439ExprWithCleanups::ExprWithCleanups(EmptyShell empty,
unsigned numObjects)
1440 :
FullExpr(ExprWithCleanupsClass, empty) {
1446 unsigned numObjects) {
1447 void *buffer =
C.Allocate(totalSizeToAlloc<CleanupObject>(numObjects),
1452CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(
1455 :
Expr(CXXUnresolvedConstructExprClass,
T,
1456 (TSI->getType()->isLValueReferenceType() ?
VK_LValue
1457 : TSI->getType()->isRValueReferenceType() ?
VK_XValue
1460 TypeAndInitForm(TSI, IsListInit), LParenLoc(LParenLoc),
1461 RParenLoc(RParenLoc) {
1463 auto **StoredArgs = getTrailingObjects<Expr *>();
1464 for (
unsigned I = 0; I != Args.size(); ++I)
1465 StoredArgs[I] = Args[I];
1473 void *Mem = Context.
Allocate(totalSizeToAlloc<Expr *>(Args.size()));
1475 RParenLoc, IsListInit);
1481 void *Mem = Context.
Allocate(totalSizeToAlloc<Expr *>(NumArgs));
1486 return TypeAndInitForm.getPointer()->getTypeLoc().getBeginLoc();
1489CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(
1495 :
Expr(CXXDependentScopeMemberExprClass, Ctx.DependentTy,
VK_LValue,
1497 Base(
Base), BaseType(BaseType), QualifierLoc(QualifierLoc),
1498 MemberNameInfo(MemberNameInfo) {
1501 (TemplateArgs !=
nullptr) || TemplateKWLoc.
isValid();
1503 FirstQualifierFoundInScope !=
nullptr;
1507 auto Deps = TemplateArgumentDependence::None;
1508 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
1509 TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(),
1511 }
else if (TemplateKWLoc.
isValid()) {
1512 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
1516 if (hasFirstQualifierFoundInScope())
1517 *getTrailingObjects<NamedDecl *>() = FirstQualifierFoundInScope;
1521CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(
1522 EmptyShell
Empty,
bool HasTemplateKWAndArgsInfo,
1523 bool HasFirstQualifierFoundInScope)
1524 :
Expr(CXXDependentScopeMemberExprClass,
Empty) {
1526 HasTemplateKWAndArgsInfo;
1528 HasFirstQualifierFoundInScope;
1537 bool HasTemplateKWAndArgsInfo =
1538 (TemplateArgs !=
nullptr) || TemplateKWLoc.
isValid();
1539 unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->
size() : 0;
1540 bool HasFirstQualifierFoundInScope = FirstQualifierFoundInScope !=
nullptr;
1544 HasTemplateKWAndArgsInfo, NumTemplateArgs, HasFirstQualifierFoundInScope);
1548 Ctx,
Base, BaseType, IsArrow, OperatorLoc, QualifierLoc, TemplateKWLoc,
1549 FirstQualifierFoundInScope, MemberNameInfo, TemplateArgs);
1553 const ASTContext &Ctx,
bool HasTemplateKWAndArgsInfo,
1554 unsigned NumTemplateArgs,
bool HasFirstQualifierFoundInScope) {
1555 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
1559 HasTemplateKWAndArgsInfo, NumTemplateArgs, HasFirstQualifierFoundInScope);
1563 EmptyShell(), HasTemplateKWAndArgsInfo, HasFirstQualifierFoundInScope);
1580 if (isa<UnresolvedUsingValueDecl>(
decl))
1585 if (cast<CXXMethodDecl>(
decl->getUnderlyingDecl()->getAsFunction())
1588 }
while (++begin != end);
1593UnresolvedMemberExpr::UnresolvedMemberExpr(
1601 UnresolvedMemberExprClass, Context, QualifierLoc, TemplateKWLoc,
1602 MemberNameInfo, TemplateArgs,
Begin, End,
1604 ((
Base &&
Base->isTypeDependent()) || BaseType->isDependentType()),
1605 ((
Base &&
Base->isInstantiationDependent()) ||
1606 BaseType->isInstantiationDependentType()),
1608 ((
Base &&
Base->containsUnexpandedParameterPack()) ||
1609 BaseType->containsUnexpandedParameterPack())),
1610 Base(
Base), BaseType(BaseType), OperatorLoc(OperatorLoc) {
1611 UnresolvedMemberExprBits.IsArrow = IsArrow;
1612 UnresolvedMemberExprBits.HasUnresolvedUsing = HasUnresolvedUsing;
1620UnresolvedMemberExpr::UnresolvedMemberExpr(EmptyShell
Empty,
1621 unsigned NumResults,
1622 bool HasTemplateKWAndArgsInfo)
1624 HasTemplateKWAndArgsInfo) {}
1630 return cast<Expr>(
Base)->isImplicitCXXThis();
1640 unsigned NumResults = End -
Begin;
1641 bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.
isValid();
1642 unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->
size() : 0;
1645 NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
1648 Context, HasUnresolvedUsing,
Base, BaseType, IsArrow, OperatorLoc,
1649 QualifierLoc, TemplateKWLoc, MemberNameInfo, TemplateArgs,
Begin, End);
1653 const ASTContext &Context,
unsigned NumResults,
1654 bool HasTemplateKWAndArgsInfo,
unsigned NumTemplateArgs) {
1655 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
1658 NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
1674 assert(
T &&
"qualifier in member expression does not name type");
1676 assert(
Record &&
"qualifier in member expression does not name record");
1685 assert(
Record &&
"base of member expression does not name record");
1695 std::optional<unsigned> Length,
1698 Context.
Allocate(totalSizeToAlloc<TemplateArgument>(PartialArgs.size()));
1700 PackLoc, RParenLoc, Length, PartialArgs);
1704 unsigned NumPartialArgs) {
1706 Context.
Allocate(totalSizeToAlloc<TemplateArgument>(NumPartialArgs));
1711 return cast<NonTypeTemplateParmDecl>(
1717 Expr *PackIdExpr,
Expr *IndexExpr, std::optional<int64_t> Index,
1720 if (Index && !SubstitutedExprs.empty())
1721 Type = SubstitutedExprs[*Index]->getType();
1726 Context.
Allocate(totalSizeToAlloc<Expr *>(SubstitutedExprs.size()));
1727 return new (Storage)
1729 SubstitutedExprs, ExpandedToEmptyPack);
1734 NamedDecl *ND = dyn_cast<NamedDecl>(
D->getDecl());
1735 assert(ND &&
"exected a named decl");
1738 assert(
false &&
"invalid declaration kind in pack indexing expression");
1744 unsigned NumTransformedExprs) {
1746 Context.
Allocate(totalSizeToAlloc<Expr *>(NumTransformedExprs));
1759SubstNonTypeTemplateParmPackExpr::SubstNonTypeTemplateParmPackExpr(
1763 AssociatedDecl(AssociatedDecl), Arguments(ArgPack.pack_begin()),
1764 NumArguments(ArgPack.pack_size()), Index(Index), NameLoc(NameLoc) {
1765 assert(AssociatedDecl !=
nullptr);
1767 ExprDependence::UnexpandedPack);
1772 return cast<NonTypeTemplateParmDecl>(
1785 ParamPack(ParamPack), NameLoc(NameLoc), NumParameters(NumParams) {
1787 std::uninitialized_copy(Params, Params + NumParams,
1788 getTrailingObjects<VarDecl *>());
1790 ExprDependence::UnexpandedPack);
1797 return new (Context.
Allocate(totalSizeToAlloc<VarDecl *>(Params.size())))
1803 unsigned NumParams) {
1804 return new (Context.
Allocate(totalSizeToAlloc<VarDecl *>(NumParams)))
1811 :
Expr(MaterializeTemporaryExprClass,
T,
1815 MTD->ExprWithTemporary = Temporary;
1823 unsigned ManglingNumber) {
1832 cast<Expr>(State.get<
Stmt *>()), ExtendedBy, ManglingNumber);
1835 ES->ExtendingDecl = ExtendedBy;
1836 ES->ManglingNumber = ManglingNumber;
1850 VD->isUsableInConstantExpressions(Context);
1857 RParenLoc(RParenLoc) {
1858 assert(Kind <=
TT_Last &&
"invalid enum value!");
1861 "TypeTraitExprBits.Kind overflow!");
1865 "TypeTraitExprBits.NumArgs overflow!");
1867 auto **ToArgs = getTrailingObjects<TypeSourceInfo *>();
1868 for (
unsigned I = 0, N = Args.size(); I != N; ++I)
1869 ToArgs[I] = Args[I];
1880 void *Mem =
C.Allocate(totalSizeToAlloc<TypeSourceInfo *>(Args.size()));
1886 void *Mem =
C.Allocate(totalSizeToAlloc<TypeSourceInfo *>(NumArgs));
1890CUDAKernelCallExpr::CUDAKernelCallExpr(
Expr *Fn,
CallExpr *Config,
1894 unsigned MinNumArgs)
1895 :
CallExpr(CUDAKernelCallExprClass, Fn, Config, Args, Ty, VK,
1896 RP, FPFeatures, MinNumArgs, NotADL) {}
1898CUDAKernelCallExpr::CUDAKernelCallExpr(
unsigned NumArgs,
bool HasFPFeatures,
1900 :
CallExpr(CUDAKernelCallExprClass, END_PREARG, NumArgs,
1901 HasFPFeatures,
Empty) {}
1907 unsigned MinNumArgs) {
1909 unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
1924 END_PREARG, NumArgs, HasFPFeatures);
1932 unsigned NumUserSpecifiedExprs,
1935 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(Args.size()));
1937 LParenLoc, RParenLoc);
1943 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(NumExprs),
1953 std::optional<unsigned> NumExpansions)
1955 EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc),
1956 NumExpansions(NumExpansions ? *NumExpansions + 1 : 0), Opcode(Opcode) {
1960 "Exactly one of LHS or RHS should contain an unexpanded pack");
1961 SubExprs[SubExpr::Callee] = Callee;
1962 SubExprs[SubExpr::LHS] = LHS;
1963 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)
Defines the clang::Expr interface and subclasses for C++ expressions.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the LambdaCapture class.
llvm::MachO::Record Record
Defines an enumeration for C++ overloaded operators.
Defines the clang::SourceLocation class and associated facilities.
Defines various enumerations that describe declaration and type specifiers.
static QualType getPointeeType(const MemRegion *R)
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
const LangOptions & getLangOpts() const
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
CanQualType BoundMemberTy
void * Allocate(size_t Size, unsigned Align=8) const
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
Represents a call to a CUDA kernel function.
static CUDAKernelCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)
static CUDAKernelCallExpr * Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RP, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0)
A C++ addrspace_cast expression (currently only enabled for OpenCL).
static CXXAddrspaceCastExpr * CreateEmpty(const ASTContext &Context)
static CXXAddrspaceCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Represents a base class of a C++ class.
Represents binding an expression to a temporary.
static CXXBindTemporaryExpr * Create(const ASTContext &C, CXXTemporary *Temp, Expr *SubExpr)
A C++ const_cast expression (C++ [expr.const.cast]).
static CXXConstCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, Expr *Op, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
static CXXConstCastExpr * CreateEmpty(const ASTContext &Context)
Represents a call to a C++ constructor.
SourceRange getParenOrBraceRange() const
static CXXConstructExpr * Create(const ASTContext &Ctx, QualType Ty, SourceLocation Loc, CXXConstructorDecl *Ctor, bool Elidable, ArrayRef< Expr * > Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, CXXConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
Create a C++ construction expression.
Expr * getArg(unsigned Arg)
Return the specified argument.
CXXConstructExpr(StmtClass SC, QualType Ty, SourceLocation Loc, CXXConstructorDecl *Ctor, bool Elidable, ArrayRef< Expr * > Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, CXXConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
Build a C++ construction expression.
SourceLocation getLocation() const
static unsigned sizeOfTrailingObjects(unsigned NumArgs)
Return the size in bytes of the trailing objects.
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getBeginLoc() const LLVM_READONLY
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
static CXXConstructExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs)
Create an empty C++ construction expression.
Represents a C++ constructor within a class.
A default argument (C++ [dcl.fct.default]).
const ParmVarDecl * getParam() const
Expr * getRewrittenExpr()
Expr * getAdjustedRewrittenExpr()
static CXXDefaultArgExpr * Create(const ASTContext &C, SourceLocation Loc, ParmVarDecl *Param, Expr *RewrittenExpr, DeclContext *UsedContext)
static CXXDefaultArgExpr * CreateEmpty(const ASTContext &C, bool HasRewrittenInit)
bool hasRewrittenInit() const
A use of a default initializer in a constructor or in aggregate initialization.
static CXXDefaultInitExpr * Create(const ASTContext &Ctx, SourceLocation Loc, FieldDecl *Field, DeclContext *UsedContext, Expr *RewrittenInitExpr)
Field is the non-static data member whose default initializer is used by this expression.
const Expr * getRewrittenExpr() const
Retrieve the initializing expression with evaluated immediate calls, if any.
bool hasRewrittenInit() const
Expr * getExpr()
Get the initialization expression that will be used.
static CXXDefaultInitExpr * CreateEmpty(const ASTContext &C, bool HasRewrittenInit)
FunctionDecl * getOperatorDelete() const
QualType getDestroyedType() const
Retrieve the type being destroyed.
Represents a C++ member access expression where the actual member referenced could not be resolved be...
static CXXDependentScopeMemberExpr * Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
static CXXDependentScopeMemberExpr * CreateEmpty(const ASTContext &Ctx, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs, bool HasFirstQualifierFoundInScope)
Represents a C++ destructor within a class.
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
static CXXDynamicCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
static CXXDynamicCastExpr * CreateEmpty(const ASTContext &Context, unsigned pathSize)
bool isAlwaysNull() const
isAlwaysNull - Return whether the result of the dynamic_cast is proven to always be null.
CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee, SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Opcode, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, std::optional< unsigned > NumExpansions)
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....
static CXXFunctionalCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getEndLoc() const LLVM_READONLY
static CXXFunctionalCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, TypeSourceInfo *Written, CastKind Kind, Expr *Op, const CXXCastPath *Path, FPOptionsOverride FPO, SourceLocation LPLoc, SourceLocation RPLoc)
Represents a call to a member function that may be written either with member call syntax (e....
CXXMethodDecl * getMethodDecl() const
Retrieve the declaration of the called method.
Expr * getImplicitObjectArgument() const
Retrieve the implicit object argument for the member call.
static CXXMemberCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)
static CXXMemberCallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RP, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0)
QualType getObjectType() const
Retrieve the type of the object argument.
CXXRecordDecl * getRecordDecl() const
Retrieve the CXXRecordDecl for the underlying type of the implicit object argument.
Represents a static or instance method of a struct/union/class.
const char * getCastName() const
getCastName - Get the name of the C++ cast being used, e.g., "static_cast", "dynamic_cast",...
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
static CXXNewExpr * CreateEmpty(const ASTContext &Ctx, bool IsArray, bool HasInit, unsigned NumPlacementArgs, bool IsParenTypeId)
Create an empty c++ new expression.
bool shouldNullCheckAllocation() const
True if the allocation result needs to be null-checked.
FunctionDecl * getOperatorNew() const
static CXXNewExpr * Create(const ASTContext &Ctx, bool IsGlobalNew, FunctionDecl *OperatorNew, FunctionDecl *OperatorDelete, bool ShouldPassAlignment, bool UsualArrayDeleteWantsSize, ArrayRef< Expr * > PlacementArgs, SourceRange TypeIdParens, std::optional< Expr * > ArraySize, CXXNewInitializationStyle InitializationStyle, Expr *Initializer, QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range, SourceRange DirectInitRange)
Create a c++ new expression.
A call to an overloaded operator written using operator syntax.
bool isInfixBinaryOp() const
Is this written as an infix binary operator?
SourceLocation getOperatorLoc() const
Returns the location of the operator symbol in the expression.
SourceLocation getEndLoc() const
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
static CXXOperatorCallExpr * Create(const ASTContext &Ctx, OverloadedOperatorKind OpKind, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation OperatorLoc, FPOptionsOverride FPFeatures, ADLCallKind UsesADL=NotADL)
static CXXOperatorCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)
SourceLocation getBeginLoc() const
Represents a list-initialization with parenthesis.
static CXXParenListInitExpr * Create(ASTContext &C, ArrayRef< Expr * > Args, QualType T, unsigned NumUserSpecifiedExprs, SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
static CXXParenListInitExpr * CreateEmpty(ASTContext &C, unsigned numExprs, EmptyShell Empty)
CXXPseudoDestructorExpr(const ASTContext &Context, Expr *Base, bool isArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, TypeSourceInfo *ScopeType, SourceLocation ColonColonLoc, SourceLocation TildeLoc, PseudoDestructorTypeStorage DestroyedType)
SourceLocation getEndLoc() const LLVM_READONLY
QualType getDestroyedType() const
Retrieve the type being destroyed.
Represents a C++ struct/union/class.
capture_const_iterator captures_end() const
capture_const_iterator captures_begin() const
A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).
static CXXReinterpretCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
static CXXReinterpretCastExpr * CreateEmpty(const ASTContext &Context, unsigned pathSize)
Expr * getSemanticForm()
Get an equivalent semantic form for this expression.
bool isReversed() const
Determine whether this expression was rewritten in reverse form.
DecomposedForm getDecomposedForm() const LLVM_READONLY
Decompose this operator into its syntactic form.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getRParenLoc() const
A C++ static_cast expression (C++ [expr.static.cast]).
static CXXStaticCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written, FPOptionsOverride FPO, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
static CXXStaticCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool hasFPFeatures)
Represents a C++ functional cast expression that builds a temporary object.
static CXXTemporaryObjectExpr * Create(const ASTContext &Ctx, CXXConstructorDecl *Cons, QualType Ty, TypeSourceInfo *TSI, ArrayRef< Expr * > Args, SourceRange ParenOrBraceRange, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization)
TypeSourceInfo * getTypeSourceInfo() const
SourceLocation getEndLoc() const LLVM_READONLY
static CXXTemporaryObjectExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs)
SourceLocation getBeginLoc() const LLVM_READONLY
Represents a C++ temporary.
static CXXTemporary * Create(const ASTContext &C, const CXXDestructorDecl *Destructor)
Represents the this expression in C++.
static CXXThisExpr * CreateEmpty(const ASTContext &Ctx)
static CXXThisExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType Ty, bool IsImplicit)
QualType getTypeOperand(ASTContext &Context) const
Retrieves the type operand of this typeid() expression after various required adjustments (removing r...
bool isTypeOperand() const
Expr * getExprOperand() const
bool isMostDerived(ASTContext &Context) const
Best-effort check if the expression operand refers to a most derived object.
bool isPotentiallyEvaluated() const
Determine whether this typeid has a type operand which is potentially evaluated, per C++11 [expr....
bool hasNullCheck() const
Whether this is of a form like "typeid(*ptr)" that can throw a std::bad_typeid if a pointer is a null...
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
static CXXUnresolvedConstructExpr * Create(const ASTContext &Context, QualType T, TypeSourceInfo *TSI, SourceLocation LParenLoc, ArrayRef< Expr * > Args, SourceLocation RParenLoc, bool IsListInit)
SourceLocation getBeginLoc() const LLVM_READONLY
static CXXUnresolvedConstructExpr * CreateEmpty(const ASTContext &Context, unsigned NumArgs)
QualType getTypeOperand(ASTContext &Context) const
Retrieves the type operand of this __uuidof() expression after various required adjustments (removing...
bool isTypeOperand() const
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
static unsigned sizeOfTrailingObjects(unsigned NumPreArgs, unsigned NumArgs, bool HasFPFeatures)
Return the size in bytes needed for the trailing objects.
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
SourceLocation getRParenLoc() const
static constexpr ADLCallKind UsesADL
CastKind getCastKind() const
CompoundStmt - This represents a group of statements like { stmt stmt }.
A POD class for pairing a NamedDecl* with an access specifier.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Decl - This represents one declaration (or definition), e.g.
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
A qualified reference to a name whose declaration cannot yet be resolved.
static DependentScopeDeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
static DependentScopeDeclRefExpr * CreateEmpty(const ASTContext &Context, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
TypeSourceInfo * getTypeInfoAsWritten() const
getTypeInfoAsWritten - Returns the type source info for the type that this expression is casting to.
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
static ExprWithCleanups * Create(const ASTContext &C, EmptyShell empty, unsigned numObjects)
This represents one expression.
Expr * IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY
Skip past any parentheses and casts which do not change the value (including ptr->int casts of the sa...
bool isValueDependent() const
Determines whether the value of this expression depends on.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates).
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool isDefaultArgument() const
Determine whether this expression is a default function argument.
void setDependence(ExprDependence Deps)
Each concrete expr subclass is expected to compute its dependence and call this in the constructor.
Represents difference between two FPOptions values.
bool requiresTrailingStorage() const
Represents a member of a struct/union/class.
FullExpr - Represents a "full-expression" node.
Represents a function declaration or definition.
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
bool isReservedGlobalPlacementOperator() const
Determines whether this operator new or delete is one of the reserved global placement operators: voi...
Represents a reference to a function parameter pack or init-capture pack that has been substituted bu...
static FunctionParmPackExpr * Create(const ASTContext &Context, QualType T, VarDecl *ParamPack, SourceLocation NameLoc, ArrayRef< VarDecl * > Params)
static FunctionParmPackExpr * CreateEmpty(const ASTContext &Context, unsigned NumParams)
Represents a prototype with parameter type info, e.g.
Declaration of a template function.
One of these records is kept for each identifier that is lexed.
Describes the capture of a variable or of this, or of a C++1y init-capture.
bool capturesVLAType() const
Determine whether this captures a variable length array bound expression.
LambdaCapture(SourceLocation Loc, bool Implicit, LambdaCaptureKind Kind, ValueDecl *Var=nullptr, SourceLocation EllipsisLoc=SourceLocation())
Create a new capture of a variable or of this.
LambdaCaptureKind getCaptureKind() const
Determine the kind of capture.
bool capturesThis() const
Determine whether this capture handles the C++ this pointer.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
capture_iterator capture_begin() const
Retrieve an iterator pointing to the first lambda capture.
static LambdaExpr * CreateDeserialized(const ASTContext &C, unsigned NumCaptures)
Construct a new lambda expression that will be deserialized from an external source.
static LambdaExpr * Create(const ASTContext &C, CXXRecordDecl *Class, SourceRange IntroducerRange, LambdaCaptureDefault CaptureDefault, SourceLocation CaptureDefaultLoc, bool ExplicitParams, bool ExplicitResultType, ArrayRef< Expr * > CaptureInits, SourceLocation ClosingBrace, bool ContainsUnexpandedParameterPack)
Construct a new lambda expression.
Stmt * getBody() const
Retrieve the body of the lambda.
bool isMutable() const
Determine whether the lambda is mutable, meaning that any captures values can be modified.
capture_iterator implicit_capture_end() const
Retrieve an iterator pointing past the end of the sequence of implicit lambda captures.
unsigned capture_size() const
Determine the number of captures in this lambda.
capture_range explicit_captures() const
Retrieve this lambda's explicit captures.
bool isInitCapture(const LambdaCapture *Capture) const
Determine whether one of this lambda's captures is an init-capture.
CXXMethodDecl * getCallOperator() const
Retrieve the function call operator associated with this lambda expression.
const CompoundStmt * getCompoundStmtBody() const
Retrieve the CompoundStmt representing the body of the lambda.
capture_range implicit_captures() const
Retrieve this lambda's implicit captures.
TemplateParameterList * getTemplateParameterList() const
If this is a generic lambda expression, retrieve the template parameter list associated with it,...
ArrayRef< NamedDecl * > getExplicitTemplateParameters() const
Get the template parameters were explicitly specified (as opposed to being invented by use of an auto...
capture_iterator implicit_capture_begin() const
Retrieve an iterator pointing to the first implicit lambda capture.
capture_iterator explicit_capture_end() const
Retrieve an iterator pointing past the end of the sequence of explicit lambda captures.
capture_iterator capture_end() const
Retrieve an iterator pointing past the end of the sequence of lambda captures.
llvm::iterator_range< capture_iterator > capture_range
An iterator over a range of lambda captures.
Expr * getTrailingRequiresClause() const
Get the trailing requires clause, if any.
capture_iterator explicit_capture_begin() const
Retrieve an iterator pointing to the first explicit lambda capture.
child_range children()
Includes the captures and the body of the lambda.
FunctionTemplateDecl * getDependentCallOperator() const
Retrieve the function template call operator associated with this lambda expression.
capture_range captures() const
Retrieve this lambda's captures.
CXXRecordDecl * getLambdaClass() const
Retrieve the class that corresponds to the lambda.
Implicit declaration of a temporary that was materialized by a MaterializeTemporaryExpr and lifetime-...
static LifetimeExtendedTemporaryDecl * Create(Expr *Temp, ValueDecl *EDec, unsigned Mangling)
MaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference, LifetimeExtendedTemporaryDecl *MTD=nullptr)
ValueDecl * getExtendingDecl()
Get the declaration which triggered the lifetime-extension of this temporary, if any.
bool isUsableInConstantExpressions(const ASTContext &Context) const
Determine whether this temporary object is usable in constant expressions, as specified in C++20 [exp...
void setExtendingDecl(ValueDecl *ExtendedBy, unsigned ManglingNumber)
This represents a decl that may have a name.
A C++ nested-name-specifier augmented with source location information.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
NestedNameSpecifier * getQualifier() const
Fetches the nested-name qualifier, if one was given.
ASTTemplateKWAndArgsInfo * getTrailingASTTemplateKWAndArgsInfo()
Return the optional template keyword and arguments info.
TemplateArgumentLoc * getTrailingTemplateArgumentLoc()
Return the optional template arguments.
DeclAccessPair * getTrailingResults()
Return the results. Defined after UnresolvedMemberExpr.
OverloadExpr(StmtClass SC, const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent, bool KnownInstantiationDependent, bool KnownContainsUnexpandedParameterPack)
NamedDecl * getPackDecl() const
static PackIndexingExpr * CreateDeserialized(ASTContext &Context, unsigned NumTransformedExprs)
static PackIndexingExpr * Create(ASTContext &Context, SourceLocation EllipsisLoc, SourceLocation RSquareLoc, Expr *PackIdExpr, Expr *IndexExpr, std::optional< int64_t > Index, ArrayRef< Expr * > SubstitutedExprs={}, bool ExpandedToEmptyPack=false)
Expr * getPackIdExpression() const
Represents a parameter to a function.
PointerType - C99 6.7.5.1 - Pointer Declarators.
Stores the type being destroyed by a pseudo-destructor expression.
PseudoDestructorTypeStorage()=default
SourceLocation getLocation() const
TypeSourceInfo * getTypeSourceInfo() const
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isConstant(const ASTContext &Ctx) const
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
The collection of all-type qualifiers we support.
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, std::optional< unsigned > Length=std::nullopt, ArrayRef< TemplateArgument > PartialArgs=std::nullopt)
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
void setEnd(SourceLocation e)
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
CXXUnresolvedConstructExprBitfields CXXUnresolvedConstructExprBits
UnresolvedLookupExprBitfields UnresolvedLookupExprBits
ExprWithCleanupsBitfields ExprWithCleanupsBits
StmtClass getStmtClass() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
OverloadExprBitfields OverloadExprBits
CXXConstructExprBitfields CXXConstructExprBits
CXXDependentScopeMemberExprBitfields CXXDependentScopeMemberExprBits
TypeTraitExprBitfields TypeTraitExprBits
CXXNewExprBitfields CXXNewExprBits
llvm::iterator_range< child_iterator > child_range
CXXDefaultInitExprBitfields CXXDefaultInitExprBits
DependentScopeDeclRefExprBitfields DependentScopeDeclRefExprBits
llvm::iterator_range< const_child_iterator > const_child_range
CXXDefaultArgExprBitfields CXXDefaultArgExprBits
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
QualType getParameterType(const ASTContext &Ctx) const
Determine the substituted type of the template parameter.
bool isReferenceParameter() const
NonTypeTemplateParmDecl * getParameter() const
TemplateArgument getArgumentPack() const
Retrieve the template argument pack containing the substituted template arguments.
NonTypeTemplateParmDecl * getParameterPack() const
Retrieve the non-type template parameter pack being substituted.
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
A convenient class for passing around template argument information.
Location wrapper for a TemplateArgument.
Represents a template argument.
Stores a list of template parameters for a TemplateDecl and its derived classes.
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
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.
static TypeTraitExpr * Create(const ASTContext &C, QualType T, SourceLocation Loc, TypeTrait Kind, ArrayRef< TypeSourceInfo * > Args, SourceLocation RParenLoc, bool Value)
Create a new type trait expression.
static TypeTraitExpr * CreateDeserialized(const ASTContext &C, unsigned NumArgs)
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
bool isVoidPointerType() const
bool isPointerType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
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 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 * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent)
static UnresolvedLookupExpr * CreateEmpty(const ASTContext &Context, unsigned NumResults, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
QualType getBaseType() const
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '.
static UnresolvedMemberExpr * Create(const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
CXXRecordDecl * getNamingClass()
Retrieve the naming class of this lookup.
bool isImplicitAccess() const
True if this is an implicit access, i.e., one in which the member being accessed was not written in t...
static UnresolvedMemberExpr * CreateEmpty(const ASTContext &Context, unsigned NumResults, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
The iterator over UnresolvedSets.
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit....
LiteralOperatorKind getLiteralOperatorKind() const
Returns the kind of literal operator invocation which this expression represents.
const IdentifierInfo * getUDSuffix() const
Returns the ud-suffix specified for this literal.
static UserDefinedLiteral * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation LitEndLoc, SourceLocation SuffixLoc, FPOptionsOverride FPFeatures)
static UserDefinedLiteral * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPOptions, EmptyShell Empty)
Expr * getCookedLiteral()
If this is not a raw user-defined literal, get the underlying cooked literal (representing the litera...
LiteralOperatorKind
The kind of literal operator which is invoked.
@ LOK_String
operator "" X (const CharT *, size_t)
@ LOK_Raw
Raw form: operator "" X (const char *)
@ LOK_Floating
operator "" X (long double)
@ LOK_Integer
operator "" X (unsigned long long)
@ LOK_Template
Raw form: operator "" X<cs...> ()
@ LOK_Character
operator "" X (CharT)
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
The JSON file list parser is used to communicate input to InstallAPI.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ OK_Ordinary
An ordinary object is located at an address in memory.
LambdaCaptureKind
The different capture forms in a lambda introducer.
@ LCK_ByCopy
Capturing by copy (a.k.a., by value)
@ LCK_ByRef
Capturing by reference.
@ LCK_VLAType
Capturing variable-length array type.
@ LCK_StarThis
Capturing the *this object by copy.
@ LCK_This
Capturing the *this object by reference.
ExprDependence computeDependence(FullExpr *E)
@ Result
The result type of a method or function.
TemplateParameterList * getReplacedTemplateParameterList(Decl *D)
Internal helper used by Subst* nodes to retrieve the parameter list for their AssociatedDecl.
CastKind
CastKind - The kind of operation required for a conversion.
LambdaCaptureDefault
The default, if any, capture method for a lambda expression.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
const FunctionProtoType * T
@ Class
The "class" keyword introduces the elaborated-type-specifier.
TypeTrait
Names for traits that operate specifically on types.
CXXNewInitializationStyle
@ Parens
New-expression has a C++98 paren-delimited initializer.
@ None
New-expression has no initializer as written.
@ Braces
New-expression has a C++11 list-initializer.
@ Implicit
An implicit conversion.
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
void initializeFrom(SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &List, TemplateArgumentLoc *OutArgArray)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
A placeholder type used to construct an empty shell of a type, that will be filled in later (e....