34 #include "llvm/ADT/ArrayRef.h"
35 #include "llvm/Support/Casting.h"
36 #include "llvm/Support/ErrorHandling.h"
43 using namespace clang;
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();
82 Result.LHS = BO->getLHS();
83 Result.RHS = BO->getRHS();
84 Result.InnerBinOp = BO;
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);
99 Result.InnerBinOp = BO;
101 llvm_unreachable(
"unexpected rewritten operator form");
107 std::swap(Result.LHS, Result.RHS);
110 if (Result.Opcode == BO_EQ || Result.Opcode == BO_NE)
114 E = Result.LHS->IgnoreImplicitAsWritten();
115 if (
auto *BO = dyn_cast<BinaryOperator>(E)) {
116 assert(BO->getOpcode() == BO_Cmp);
117 Result.LHS = BO->getLHS();
118 Result.RHS = BO->getRHS();
119 Result.InnerBinOp = BO;
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);
124 Result.InnerBinOp = BO;
126 llvm_unreachable(
"unexpected rewritten operator form");
131 std::swap(Result.LHS, Result.RHS);
144 if (RD->isPolymorphic() && E->
isGLValue())
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)");
170 assert(
isTypeOperand() &&
"Cannot call getTypeOperand for __uuidof(expr)");
182 CXXNewExpr::CXXNewExpr(
bool IsGlobalNew,
FunctionDecl *OperatorNew,
184 bool UsualArrayDeleteWantsSize,
186 std::optional<Expr *> ArraySize,
187 InitializationStyle InitializationStyle,
192 OperatorNew(OperatorNew), OperatorDelete(OperatorDelete),
193 AllocatedTypeInfo(AllocatedTypeInfo), Range(Range),
194 DirectInitRange(DirectInitRange) {
196 assert((Initializer !=
nullptr || InitializationStyle == NoInit) &&
197 "Only NoInit can have no initializer!");
202 CXXNewExprBits.UsualArrayDeleteWantsSize = UsualArrayDeleteWantsSize;
205 bool IsParenTypeId = TypeIdParens.
isValid();
210 getTrailingObjects<Stmt *>()[arraySizeOffset()] = *ArraySize;
212 getTrailingObjects<Stmt *>()[initExprOffset()] =
Initializer;
213 for (
unsigned I = 0; I != PlacementArgs.size(); ++I)
214 getTrailingObjects<Stmt *>()[placementNewArgsOffset() + I] =
217 getTrailingObjects<SourceRange>()[0] = TypeIdParens;
219 switch (getInitializationStyle()) {
235 CXXNewExpr::CXXNewExpr(EmptyShell Empty,
bool IsArray,
236 unsigned NumPlacementArgs,
bool IsParenTypeId)
237 :
Expr(CXXNewExprClass, Empty) {
246 bool ShouldPassAlignment,
bool UsualArrayDeleteWantsSize,
248 std::optional<Expr *> ArraySize,
252 bool IsArray = ArraySize.has_value();
254 unsigned NumPlacementArgs = PlacementArgs.size();
255 bool IsParenTypeId = TypeIdParens.
isValid();
257 Ctx.
Allocate(totalSizeToAlloc<Stmt *, SourceRange>(
258 IsArray + HasInit + NumPlacementArgs, IsParenTypeId),
261 CXXNewExpr(IsGlobalNew, OperatorNew, OperatorDelete, ShouldPassAlignment,
262 UsualArrayDeleteWantsSize, PlacementArgs, TypeIdParens,
264 AllocatedTypeInfo, Range, DirectInitRange);
268 bool HasInit,
unsigned NumPlacementArgs,
269 bool IsParenTypeId) {
271 Ctx.
Allocate(totalSizeToAlloc<Stmt *, SourceRange>(
272 IsArray + HasInit + NumPlacementArgs, IsParenTypeId),
294 while (
const auto *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
295 if (ICE->getCastKind() == CK_DerivedToBase ||
296 ICE->getCastKind() == CK_UncheckedDerivedToBase ||
297 ICE->getCastKind() == CK_NoOp) {
298 assert((ICE->getCastKind() == CK_NoOp ||
300 "only a destroying operator delete can have a converted arg");
301 Arg = ICE->getSubExpr();
326 :
Expr(CXXPseudoDestructorExprClass, Context.BoundMemberTy,
VK_PRValue,
329 OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
330 ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc),
331 DestroyedType(DestroyedType) {
337 return TInfo->getType();
345 End = TInfo->getTypeLoc().getSourceRange().getEnd();
350 UnresolvedLookupExpr::UnresolvedLookupExpr(
356 :
OverloadExpr(UnresolvedLookupExprClass, Context, QualifierLoc,
359 NamingClass(NamingClass) {
364 UnresolvedLookupExpr::UnresolvedLookupExpr(EmptyShell Empty,
366 bool HasTemplateKWAndArgsInfo)
367 :
OverloadExpr(UnresolvedLookupExprClass, Empty, NumResults,
368 HasTemplateKWAndArgsInfo) {}
390 assert(Args || TemplateKWLoc.
isValid());
392 unsigned NumTemplateArgs = Args ? Args->
size() : 0;
398 TemplateKWLoc, NameInfo, RequiresADL,
403 const ASTContext &Context,
unsigned NumResults,
404 bool HasTemplateKWAndArgsInfo,
unsigned NumTemplateArgs) {
405 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
408 NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
421 bool KnownInstantiationDependent,
422 bool KnownContainsUnexpandedParameterPack)
424 QualifierLoc(QualifierLoc) {
428 (TemplateArgs != nullptr ) || TemplateKWLoc.
isValid();
441 }
else if (TemplateKWLoc.
isValid()) {
446 KnownInstantiationDependent,
447 KnownContainsUnexpandedParameterPack));
453 bool HasTemplateKWAndArgsInfo)
460 DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(
465 QualifierLoc(QualifierLoc), NameInfo(NameInfo) {
467 (Args !=
nullptr) || TemplateKWLoc.
isValid();
470 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
471 TemplateKWLoc, *Args, getTrailingObjects<TemplateArgumentLoc>(), Deps);
472 }
else if (TemplateKWLoc.
isValid()) {
473 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
483 assert(QualifierLoc &&
"should be created for dependent qualifiers");
484 bool HasTemplateKWAndArgsInfo = Args || TemplateKWLoc.
isValid();
486 totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
487 HasTemplateKWAndArgsInfo, Args ? Args->
size() : 0);
490 TemplateKWLoc, NameInfo, Args);
495 bool HasTemplateKWAndArgsInfo,
496 unsigned NumTemplateArgs) {
497 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
499 totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
500 HasTemplateKWAndArgsInfo, NumTemplateArgs);
506 HasTemplateKWAndArgsInfo;
511 if (isa<CXXTemporaryObjectExpr>(
this))
512 return cast<CXXTemporaryObjectExpr>(
this)->getBeginLoc();
517 if (isa<CXXTemporaryObjectExpr>(
this))
518 return cast<CXXTemporaryObjectExpr>(
this)->getEndLoc();
520 if (ParenOrBraceRange.
isValid())
521 return ParenOrBraceRange.
getEnd();
544 :
CallExpr(CXXOperatorCallExprClass, Fn, {}, Args, Ty, VK,
545 OperatorLoc, FPFeatures, 0, UsesADL) {
546 CXXOperatorCallExprBits.OperatorKind = OpKind;
548 (CXXOperatorCallExprBits.OperatorKind ==
static_cast<unsigned>(OpKind)) &&
549 "OperatorKind overflow!");
550 Range = getSourceRangeImpl();
553 CXXOperatorCallExpr::CXXOperatorCallExpr(
unsigned NumArgs,
bool HasFPFeatures,
555 :
CallExpr(CXXOperatorCallExprClass, 0, NumArgs,
556 HasFPFeatures, Empty) {}
565 unsigned NumArgs = Args.size();
579 unsigned SizeOfTrailingObjects =
586 SourceRange CXXOperatorCallExpr::getSourceRangeImpl()
const {
588 if (
Kind == OO_PlusPlus ||
Kind == OO_MinusMinus) {
595 }
else if (
Kind == OO_Arrow) {
597 }
else if (
Kind == OO_Call) {
599 }
else if (
Kind == OO_Subscript) {
615 :
CallExpr(CXXMemberCallExprClass, Fn, {}, Args, Ty, VK, RP,
618 CXXMemberCallExpr::CXXMemberCallExpr(
unsigned NumArgs,
bool HasFPFeatures,
620 :
CallExpr(CXXMemberCallExprClass, 0, NumArgs, HasFPFeatures,
628 unsigned MinNumArgs) {
630 unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
644 unsigned SizeOfTrailingObjects =
653 if (
const auto *MemExpr = dyn_cast<MemberExpr>(Callee))
654 return MemExpr->getBase();
655 if (
const auto *BO = dyn_cast<BinaryOperator>(Callee))
656 if (BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI)
672 return cast<CXXMethodDecl>(MemExpr->getMemberDecl());
699 case CXXStaticCastExprClass:
return "static_cast";
700 case CXXDynamicCastExprClass:
return "dynamic_cast";
701 case CXXReinterpretCastExprClass:
return "reinterpret_cast";
702 case CXXConstCastExprClass:
return "const_cast";
703 case CXXAddrspaceCastExprClass:
return "addrspace_cast";
704 default:
return "<invalid cast>";
714 unsigned PathSize = (BasePath ? BasePath->size() : 0);
716 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
719 FPO, L, RParenLoc, AngleBrackets);
721 std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
728 bool HasFPFeatures) {
730 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
731 PathSize, HasFPFeatures));
743 unsigned PathSize = (BasePath ? BasePath->size() : 0);
744 void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
747 RParenLoc, AngleBrackets);
749 std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
756 void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
784 if (!SrcRD->hasAttr<FinalAttr>())
790 return !DestRD->isDerivedFrom(SrcRD);
800 unsigned PathSize = (BasePath ? BasePath->size() : 0);
801 void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
804 RParenLoc, AngleBrackets);
806 std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
813 void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
823 return new (C)
CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc, AngleBrackets);
847 unsigned PathSize = (BasePath ? BasePath->size() : 0);
849 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
851 auto *E =
new (Buffer)
854 std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
861 bool HasFPFeatures) {
863 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
864 PathSize, HasFPFeatures));
882 :
CallExpr(UserDefinedLiteralClass, Fn, {}, Args, Ty, VK,
883 LitEndLoc, FPFeatures, 0, NotADL),
884 UDSuffixLoc(SuffixLoc) {}
886 UserDefinedLiteral::UserDefinedLiteral(
unsigned NumArgs,
bool HasFPFeatures,
888 :
CallExpr(UserDefinedLiteralClass, 0, NumArgs,
889 HasFPFeatures, Empty) {}
898 unsigned NumArgs = Args.size();
912 unsigned SizeOfTrailingObjects =
926 assert(
getNumArgs() == 1 &&
"unexpected #args in literal operator call");
928 cast<FunctionDecl>(
getCalleeDecl())->getParamDecl(0)->getType();
938 llvm_unreachable(
"unknown kind of literal operator");
950 return cast<FunctionDecl>(
getCalleeDecl())->getLiteralIdentifier();
954 bool HasRewrittenInit) {
955 size_t Size = totalSizeToAlloc<Expr *>(HasRewrittenInit);
965 size_t Size = totalSizeToAlloc<Expr *>(RewrittenExpr !=
nullptr);
968 RewrittenExpr, UsedContext);
978 "expected this CXXDefaultArgExpr to have a rewritten init.");
980 if (
auto *E = dyn_cast_if_present<FullExpr>(Init))
981 if (!isa<ConstantExpr>(E))
982 return E->getSubExpr();
986 CXXDefaultInitExpr::CXXDefaultInitExpr(
const ASTContext &Ctx,
989 Expr *RewrittenInitExpr)
990 :
Expr(CXXDefaultInitExprClass, Ty.getNonLValueExprType(Ctx),
992 : Ty->isRValueReferenceType() ?
VK_XValue
995 Field(Field), UsedContext(UsedContext) {
1000 *getTrailingObjects<Expr *>() = RewrittenInitExpr;
1002 assert(Field->hasInClassInitializer());
1008 bool HasRewrittenInit) {
1009 size_t Size = totalSizeToAlloc<Expr *>(HasRewrittenInit);
1018 Expr *RewrittenInitExpr) {
1020 size_t Size = totalSizeToAlloc<Expr *>(RewrittenInitExpr !=
nullptr);
1023 UsedContext, RewrittenInitExpr);
1027 assert(Field->getInClassInitializer() &&
"initializer hasn't been parsed");
1031 return Field->getInClassInitializer();
1044 "Expression bound to a temporary must have record or array type!");
1049 CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(
1052 bool HadMultipleCandidates,
bool ListInitialization,
1053 bool StdInitListInitialization,
bool ZeroInitialization)
1055 CXXTemporaryObjectExprClass, Ty, TSI->getTypeLoc().getBeginLoc(),
1056 Cons,
false, Args, HadMultipleCandidates,
1057 ListInitialization, StdInitListInitialization, ZeroInitialization,
1063 CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(EmptyShell Empty,
1070 bool HadMultipleCandidates,
bool ListInitialization,
1071 bool StdInitListInitialization,
bool ZeroInitialization) {
1077 Cons, Ty, TSI, Args, ParenOrBraceRange, HadMultipleCandidates,
1078 ListInitialization, StdInitListInitialization, ZeroInitialization);
1104 bool HadMultipleCandidates,
bool ListInitialization,
1105 bool StdInitListInitialization,
bool ZeroInitialization,
1111 CXXConstructExprClass, Ty, Loc, Ctor, Elidable, Args,
1112 HadMultipleCandidates, ListInitialization, StdInitListInitialization,
1113 ZeroInitialization, ConstructKind, ParenOrBraceRange);
1128 bool ListInitialization,
bool StdInitListInitialization,
1132 ParenOrBraceRange(ParenOrBraceRange), NumArgs(Args.size()) {
1141 Stmt **TrailingArgs = getTrailingArgs();
1142 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
1143 assert(Args[I] &&
"NULL argument in CXXConstructExpr!");
1144 TrailingArgs[I] = Args[I];
1148 if (SC == CXXConstructExprClass)
1154 :
Expr(SC, Empty), NumArgs(NumArgs) {}
1159 : DeclAndBits(Var, 0), Loc(Loc), EllipsisLoc(EllipsisLoc) {
1162 Bits |= Capture_Implicit;
1166 Bits |= Capture_ByCopy;
1169 assert(!Var &&
"'this' capture cannot have a variable!");
1170 Bits |= Capture_This;
1174 Bits |= Capture_ByCopy;
1177 assert(Var &&
"capture must have a variable!");
1180 assert(!Var &&
"VLA type capture cannot have a variable!");
1183 DeclAndBits.setInt(Bits);
1189 bool CapByCopy = DeclAndBits.getInt() & Capture_ByCopy;
1200 bool ContainsUnexpandedParameterPack)
1202 IntroducerRange(IntroducerRange), CaptureDefaultLoc(CaptureDefaultLoc),
1203 ClosingBrace(ClosingBrace) {
1204 LambdaExprBits.NumCaptures = CaptureInits.size();
1205 LambdaExprBits.CaptureDefault = CaptureDefault;
1206 LambdaExprBits.ExplicitParams = ExplicitParams;
1207 LambdaExprBits.ExplicitResultType = ExplicitResultType;
1211 assert(capture_size() == Class->capture_size() &&
"Wrong number of captures");
1212 assert(getCaptureDefault() == Class->getLambdaCaptureDefault());
1215 Stmt **Stored = getStoredStmts();
1216 for (
unsigned I = 0, N = CaptureInits.size(); I != N; ++I)
1217 *Stored++ = CaptureInits[I];
1220 *Stored++ = getCallOperator()->getBody();
1225 LambdaExpr::LambdaExpr(EmptyShell Empty,
unsigned NumCaptures)
1226 :
Expr(LambdaExprClass, Empty) {
1227 LambdaExprBits.NumCaptures = NumCaptures;
1231 getStoredStmts()[NumCaptures] =
nullptr;
1238 bool ExplicitParams,
bool ExplicitResultType,
1241 bool ContainsUnexpandedParameterPack) {
1246 unsigned Size = totalSizeToAlloc<Stmt *>(CaptureInits.size() + 1);
1247 void *Mem = Context.
Allocate(Size);
1249 LambdaExpr(T, IntroducerRange, CaptureDefault, CaptureDefaultLoc,
1250 ExplicitParams, ExplicitResultType, CaptureInits, ClosingBrace,
1251 ContainsUnexpandedParameterPack);
1255 unsigned NumCaptures) {
1256 unsigned Size = totalSizeToAlloc<Stmt *>(NumCaptures + 1);
1257 void *Mem = C.Allocate(Size);
1261 void LambdaExpr::initBodyIfNeeded()
const {
1275 if (
const auto *CoroBody = dyn_cast<CoroutineBodyStmt>(Body))
1276 return cast<CompoundStmt>(CoroBody->getBody());
1277 return cast<CompoundStmt>(Body);
1281 return C->capturesVariable() && C->getCapturedVar()->isInitCapture() &&
1363 ExprWithCleanups::ExprWithCleanups(
Expr *subexpr,
1364 bool CleanupsHaveSideEffects,
1366 :
FullExpr(ExprWithCleanupsClass, subexpr) {
1369 for (
unsigned i = 0, e = objects.size(); i != e; ++i)
1370 getTrailingObjects<CleanupObject>()[i] = objects[i];
1374 bool CleanupsHaveSideEffects,
1376 void *buffer = C.Allocate(totalSizeToAlloc<CleanupObject>(objects.size()),
1382 ExprWithCleanups::ExprWithCleanups(EmptyShell empty,
unsigned numObjects)
1383 :
FullExpr(ExprWithCleanupsClass, empty) {
1389 unsigned numObjects) {
1390 void *buffer = C.Allocate(totalSizeToAlloc<CleanupObject>(numObjects),
1395 CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(
QualType T,
1400 :
Expr(CXXUnresolvedConstructExprClass, T,
1401 (TSI->getType()->isLValueReferenceType() ?
VK_LValue
1402 : TSI->getType()->isRValueReferenceType() ?
VK_XValue
1405 TSI(TSI), LParenLoc(LParenLoc), RParenLoc(RParenLoc) {
1407 auto **StoredArgs = getTrailingObjects<Expr *>();
1408 for (
unsigned I = 0; I != Args.size(); ++I)
1409 StoredArgs[I] = Args[I];
1416 void *Mem = Context.
Allocate(totalSizeToAlloc<Expr *>(Args.size()));
1424 void *Mem = Context.
Allocate(totalSizeToAlloc<Expr *>(NumArgs));
1432 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(
1438 :
Expr(CXXDependentScopeMemberExprClass, Ctx.DependentTy,
VK_LValue,
1440 Base(
Base), BaseType(BaseType), QualifierLoc(QualifierLoc),
1441 MemberNameInfo(MemberNameInfo) {
1444 (TemplateArgs !=
nullptr) || TemplateKWLoc.
isValid();
1446 FirstQualifierFoundInScope !=
nullptr;
1451 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
1452 TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(),
1454 }
else if (TemplateKWLoc.
isValid()) {
1455 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
1459 if (hasFirstQualifierFoundInScope())
1460 *getTrailingObjects<NamedDecl *>() = FirstQualifierFoundInScope;
1464 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(
1465 EmptyShell Empty,
bool HasTemplateKWAndArgsInfo,
1466 bool HasFirstQualifierFoundInScope)
1467 :
Expr(CXXDependentScopeMemberExprClass, Empty) {
1469 HasTemplateKWAndArgsInfo;
1471 HasFirstQualifierFoundInScope;
1480 bool HasTemplateKWAndArgsInfo =
1481 (TemplateArgs !=
nullptr) || TemplateKWLoc.
isValid();
1482 unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->
size() : 0;
1483 bool HasFirstQualifierFoundInScope = FirstQualifierFoundInScope !=
nullptr;
1487 HasTemplateKWAndArgsInfo, NumTemplateArgs, HasFirstQualifierFoundInScope);
1491 Ctx,
Base, BaseType, IsArrow, OperatorLoc, QualifierLoc, TemplateKWLoc,
1492 FirstQualifierFoundInScope, MemberNameInfo, TemplateArgs);
1496 const ASTContext &Ctx,
bool HasTemplateKWAndArgsInfo,
1497 unsigned NumTemplateArgs,
bool HasFirstQualifierFoundInScope) {
1498 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
1502 HasTemplateKWAndArgsInfo, NumTemplateArgs, HasFirstQualifierFoundInScope);
1506 EmptyShell(), HasTemplateKWAndArgsInfo, HasFirstQualifierFoundInScope);
1513 if (isa<UnresolvedUsingValueDecl>(
decl))
1518 if (cast<CXXMethodDecl>(
decl->getUnderlyingDecl()->getAsFunction())
1521 }
while (++begin != end);
1526 UnresolvedMemberExpr::UnresolvedMemberExpr(
1534 UnresolvedMemberExprClass, Context, QualifierLoc, TemplateKWLoc,
1535 MemberNameInfo, TemplateArgs,
Begin,
End,
1537 ((
Base &&
Base->isTypeDependent()) || BaseType->isDependentType()),
1538 ((
Base &&
Base->isInstantiationDependent()) ||
1539 BaseType->isInstantiationDependentType()),
1541 ((
Base &&
Base->containsUnexpandedParameterPack()) ||
1542 BaseType->containsUnexpandedParameterPack())),
1543 Base(
Base), BaseType(BaseType), OperatorLoc(OperatorLoc) {
1544 UnresolvedMemberExprBits.IsArrow = IsArrow;
1545 UnresolvedMemberExprBits.HasUnresolvedUsing = HasUnresolvedUsing;
1553 UnresolvedMemberExpr::UnresolvedMemberExpr(EmptyShell Empty,
1554 unsigned NumResults,
1555 bool HasTemplateKWAndArgsInfo)
1556 :
OverloadExpr(UnresolvedMemberExprClass, Empty, NumResults,
1557 HasTemplateKWAndArgsInfo) {}
1559 bool UnresolvedMemberExpr::isImplicitAccess()
const {
1574 bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.
isValid();
1575 unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->
size() : 0;
1578 NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
1581 Context, HasUnresolvedUsing,
Base, BaseType, IsArrow, OperatorLoc,
1582 QualifierLoc, TemplateKWLoc, MemberNameInfo, TemplateArgs,
Begin,
End);
1586 const ASTContext &Context,
unsigned NumResults,
1587 bool HasTemplateKWAndArgsInfo,
unsigned NumTemplateArgs) {
1588 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
1591 NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
1607 assert(T &&
"qualifier in member expression does not name type");
1609 assert(Record &&
"qualifier in member expression does not name record");
1618 assert(Record &&
"base of member expression does not name record");
1628 std::optional<unsigned> Length,
1631 Context.
Allocate(totalSizeToAlloc<TemplateArgument>(PartialArgs.size()));
1633 PackLoc, RParenLoc, Length, PartialArgs);
1637 unsigned NumPartialArgs) {
1639 Context.
Allocate(totalSizeToAlloc<TemplateArgument>(NumPartialArgs));
1644 return cast<NonTypeTemplateParmDecl>(
1657 SubstNonTypeTemplateParmPackExpr::SubstNonTypeTemplateParmPackExpr(
1660 :
Expr(SubstNonTypeTemplateParmPackExprClass, T, ValueKind,
OK_Ordinary),
1661 AssociatedDecl(AssociatedDecl), Arguments(ArgPack.pack_begin()),
1662 NumArguments(ArgPack.pack_size()), Index(Index), NameLoc(NameLoc) {
1663 assert(AssociatedDecl !=
nullptr);
1665 ExprDependence::UnexpandedPack);
1670 return cast<NonTypeTemplateParmDecl>(
1678 FunctionParmPackExpr::FunctionParmPackExpr(
QualType T,
VarDecl *ParamPack,
1683 ParamPack(ParamPack), NameLoc(NameLoc), NumParameters(NumParams) {
1685 std::uninitialized_copy(Params, Params + NumParams,
1686 getTrailingObjects<VarDecl *>());
1688 ExprDependence::UnexpandedPack);
1695 return new (Context.
Allocate(totalSizeToAlloc<VarDecl *>(Params.size())))
1701 unsigned NumParams) {
1702 return new (Context.
Allocate(totalSizeToAlloc<VarDecl *>(NumParams)))
1707 QualType T,
Expr *Temporary,
bool BoundToLvalueReference,
1709 :
Expr(MaterializeTemporaryExprClass, T,
1713 MTD->ExprWithTemporary = Temporary;
1721 unsigned ManglingNumber) {
1730 cast<Expr>(State.get<
Stmt *>()), ExtendedBy, ManglingNumber);
1733 ES->ExtendingDecl = ExtendedBy;
1734 ES->ManglingNumber = ManglingNumber;
1748 VD->isUsableInConstantExpressions(Context);
1755 RParenLoc(RParenLoc) {
1759 "TypeTraitExprBits.Kind overflow!");
1763 "TypeTraitExprBits.NumArgs overflow!");
1765 auto **ToArgs = getTrailingObjects<TypeSourceInfo *>();
1766 for (
unsigned I = 0, N = Args.size(); I != N; ++I)
1767 ToArgs[I] = Args[I];
1778 void *Mem = C.Allocate(totalSizeToAlloc<TypeSourceInfo *>(Args.size()));
1784 void *Mem = C.Allocate(totalSizeToAlloc<TypeSourceInfo *>(NumArgs));
1788 CUDAKernelCallExpr::CUDAKernelCallExpr(
Expr *Fn,
CallExpr *Config,
1792 unsigned MinNumArgs)
1793 :
CallExpr(CUDAKernelCallExprClass, Fn, Config, Args, Ty, VK,
1794 RP, FPFeatures, MinNumArgs, NotADL) {}
1796 CUDAKernelCallExpr::CUDAKernelCallExpr(
unsigned NumArgs,
bool HasFPFeatures,
1798 :
CallExpr(CUDAKernelCallExprClass, END_PREARG, NumArgs,
1799 HasFPFeatures, Empty) {}
1805 unsigned MinNumArgs) {
1807 unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
1822 END_PREARG, NumArgs, HasFPFeatures);
1830 unsigned NumUserSpecifiedExprs,
1833 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(Args.size()));
1835 LParenLoc, RParenLoc);
1841 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumExprs),