13#ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
14#define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
40#include "llvm/ADT/ArrayRef.h"
41#include "llvm/Support/ErrorHandling.h"
45using namespace llvm::omp;
101template<
typename Derived>
106 class ForgetPartiallySubstitutedPackRAII {
111 ForgetPartiallySubstitutedPackRAII(Derived &Self) : Self(Self) {
112 Old = Self.ForgetPartiallySubstitutedPack();
115 ~ForgetPartiallySubstitutedPackRAII() {
116 Self.RememberPartiallySubstitutedPack(Old);
133 Derived &
getDerived() {
return static_cast<Derived&
>(*this); }
137 return static_cast<const Derived&
>(*this);
202 OldLocation = Self.
getDerived().getBaseLocation();
203 OldEntity = Self.
getDerived().getBaseEntity();
210 Self.
getDerived().setBase(OldLocation, OldEntity);
283 bool &ShouldExpand,
bool &RetainExpansion,
284 std::optional<unsigned> &NumExpansions) {
285 ShouldExpand =
false;
400 const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; }
401#include "clang/Basic/AttrList.inc"
411 const X##Attr *TransformStmt##X##Attr(const Stmt *, const Stmt *, \
412 const X##Attr *A) { \
413 return getDerived().Transform##X##Attr(A); \
415#include "clang/Basic/AttrList.inc"
461 bool *ArgChanged =
nullptr);
470 llvm::DenseMap<Decl *, Decl *>::iterator Known
473 return Known->second;
501 assert(New.size() == 1 &&
502 "must override transformedLocalDecl if performing pack expansion");
540 NamedDecl *FirstQualifierInScope =
nullptr);
584 NamedDecl *FirstQualifierInScope =
nullptr,
585 bool AllowInjectedClassName =
false);
597 bool Uneval =
false);
620 bool Uneval =
false) {
639 template<
typename InputIterator>
643 bool Uneval =
false);
655#define ABSTRACT_TYPELOC(CLASS, PARENT)
656#define TYPELOC(CLASS, PARENT) \
657 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
658#include "clang/AST/TypeLocNodes.def"
662 bool SuppressObjCLifetime);
666 bool SuppressObjCLifetime);
668 template<
typename Fn>
721 return getDerived().TransformFunctionTypeParams(
722 Loc, Params, ParamTypes, ParamInfos, PTypes, PVars, PInfos,
nullptr);
740 KWLoc, Params,
nullptr,
741 nullptr, PTypes, &TransParams, PInfos))
754 std::optional<unsigned> NumExpansions,
755 bool ExpectParameterPack);
776 bool IsAddressOfOperand,
787#define STMT(Node, Parent) \
788 LLVM_ATTRIBUTE_NOINLINE \
789 StmtResult Transform##Node(Node *S);
790#define VALUESTMT(Node, Parent) \
791 LLVM_ATTRIBUTE_NOINLINE \
792 StmtResult Transform##Node(Node *S, StmtDiscardKind SDK);
793#define EXPR(Node, Parent) \
794 LLVM_ATTRIBUTE_NOINLINE \
795 ExprResult Transform##Node(Node *E);
796#define ABSTRACT_STMT(Stmt)
797#include "clang/AST/StmtNodes.inc"
799#define GEN_CLANG_CLAUSE_CLASS
800#define CLAUSE_CLASS(Enum, Str, Class) \
801 LLVM_ATTRIBUTE_NOINLINE \
802 OMPClause *Transform##Class(Class *S);
803#include "llvm/Frontend/OpenMP/OMP.inc"
881 const llvm::APInt *Size,
883 unsigned IndexTypeQuals,
893 const llvm::APInt &Size,
895 unsigned IndexTypeQuals,
905 unsigned IndexTypeQuals,
916 unsigned IndexTypeQuals,
927 unsigned IndexTypeQuals,
966 unsigned NumColumns);
1061 TypeConstraintConcept,
1062 TypeConstraintArgs);
1070 Template, Deduced,
false);
1116 bool AllowInjectedClassName) {
1120 SS.
Adopt(QualifierLoc);
1122 SS, TemplateKWLoc, *Name, NameLoc,
QualType(),
nullptr,
1123 AllowInjectedClassName);
1137 getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
1154 bool DeducedTSTContext) {
1156 SS.
Adopt(QualifierLoc);
1168 *
Id, IdLoc, DeducedTSTContext);
1186 switch (
Result.getResultKind()) {
1197 llvm_unreachable(
"Tag lookup cannot find non-tags");
1209 switch (
Result.getResultKind()) {
1215 SemaRef.
Diag(IdLoc, diag::err_tag_reference_non_tag) << SomeDecl
1230 SemaRef.
Diag(KeywordLoc, diag::err_use_with_wrong_tag) <<
Id;
1248 std::optional<unsigned> NumExpansions) {
1293 bool AllowInjectedClassName);
1306 bool AllowInjectedClassName);
1316 Decl *AssociatedDecl,
unsigned Index,
1319 ArgPack, AssociatedDecl, Index, Final);
1395 Then, ElseLoc, Else);
1449 Inc, RParenLoc, Body);
1494 bool IsVolatile,
unsigned NumOutputs,
1501 NumInputs, Names, Constraints, Exprs,
1502 AsmString, Clobbers, NumLabels, RParenLoc);
1511 StringRef AsmString,
1512 unsigned NumOutputs,
unsigned NumInputs,
1518 NumOutputs, NumInputs,
1519 Constraints, Clobbers, Exprs, EndLoc);
1548 CoawaitLoc, Operand, OpCoawaitLookup);
1552 Suspend.
get(),
true);
1654 Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
1668 LParenLoc, NameModifierLoc, ColonLoc,
1766 StartLoc, LParenLoc, EndLoc);
1779 StartLoc, LParenLoc, EndLoc);
1792 M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
1842 VarList, LPKind, LPKindLoc, ColonLoc, StartLoc, LParenLoc, EndLoc);
1869 VarList, Modifier, StartLoc, LParenLoc, ModifierLoc, ColonLoc, EndLoc,
1870 ReductionIdScopeSpec, ReductionId, UnresolvedReductions);
1884 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1885 ReductionId, UnresolvedReductions);
1900 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1901 ReductionId, UnresolvedReductions);
1916 Modifier, ModifierLoc, ColonLoc,
1930 LParenLoc, ColonLoc, EndLoc);
1990 StartLoc, LParenLoc, EndLoc);
2003 LParenLoc, ModifierLoc, EndLoc);
2018 IteratorModifier, MapTypeModifiers, MapTypeModifiersLoc,
2019 MapperIdScopeSpec, MapperId, MapType, IsMapTypeImplicit, MapLoc,
2020 ColonLoc, VarList, Locs,
2021 false, UnresolvedMappers);
2034 LParenLoc, ColonLoc, EndLoc);
2081 LParenLoc, ModifierLoc, EndLoc);
2094 LParenLoc, ModifierLoc, EndLoc);
2127 Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
2142 MapperIdScopeSpec, MapperId, ColonLoc,
2143 VarList, Locs, UnresolvedMappers);
2158 MotionModifiers, MotionModifiersLoc, MapperIdScopeSpec, MapperId,
2159 ColonLoc, VarList, Locs, UnresolvedMappers);
2210 MLoc, KindLoc, EndLoc);
2270 EndLoc, Modifier, Locators);
2282 ModifierKwLoc, KindKwLoc, EndLoc);
2295 LParenLoc, VarLoc, EndLoc);
2480 StartLoc, IdLoc,
Id);
2518 if (
DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) {
2519 if (RangeStmt->isSingleDecl()) {
2520 if (
VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
2521 if (RangeVar->isInvalidDecl())
2524 Expr *RangeExpr = RangeVar->getInit();
2531 diag::err_objc_for_range_init_stmt)
2532 << Init->getSourceRange();
2535 RangeExpr, RParenLoc);
2542 Range,
Begin, End, Cond, Inc, LoopVar,
2556 QualifierLoc, NameInfo, Nested);
2618 SS.
Adopt(QualifierLoc);
2730 ColonLocFirst, ColonLocSecond,
2731 Length, Stride, RBracketLoc);
2764 Expr *ExecConfig =
nullptr) {
2766 nullptr, Callee, LParenLoc, Args, RParenLoc, ExecConfig);
2773 nullptr, Callee, LParenLoc, Args, RParenLoc);
2791 if (!
Member->getDeclName()) {
2795 assert(
Member->getType()->isRecordType() &&
2796 "unnamed member not of record type?");
2808 Base, isArrow, OpLoc, EmptySS, cast<FieldDecl>(
Member),
2813 SS.
Adopt(QualifierLoc);
2827 if (
getSema().isUnevaluatedContext() &&
Base->isImplicitCXXThis() &&
2828 isa<FieldDecl, IndirectFieldDecl, MSPropertyDecl>(
Member)) {
2829 if (
auto *ThisClass = cast<CXXThisExpr>(
Base)
2832 ->getAsCXXRecordDecl()) {
2833 auto *Class = cast<CXXRecordDecl>(
Member->getDeclContext());
2836 if (!ThisClass->Equals(Class) && !ThisClass->isDerivedFrom(Class))
2844 FirstQualifierInScope,
2845 R, ExplicitTemplateArgs,
3023 Expr *ControllingExpr,
3027 ControllingExpr, Types, Exprs);
3059 case Stmt::CXXStaticCastExprClass:
3060 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
3061 RAngleLoc, LParenLoc,
3062 SubExpr, RParenLoc);
3064 case Stmt::CXXDynamicCastExprClass:
3065 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
3066 RAngleLoc, LParenLoc,
3067 SubExpr, RParenLoc);
3069 case Stmt::CXXReinterpretCastExprClass:
3070 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
3071 RAngleLoc, LParenLoc,
3075 case Stmt::CXXConstCastExprClass:
3076 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
3077 RAngleLoc, LParenLoc,
3078 SubExpr, RParenLoc);
3080 case Stmt::CXXAddrspaceCastExprClass:
3081 return getDerived().RebuildCXXAddrspaceCastExpr(
3082 OpLoc, LAngleLoc, TInfo, RAngleLoc, LParenLoc, SubExpr, RParenLoc);
3085 llvm_unreachable(
"Invalid C++ named cast");
3163 OpLoc, tok::kw_addrspace_cast, TInfo, SubExpr,
3175 bool ListInitialization) {
3178 ListInitialization);
3251 bool IsThrownVariableInScope) {
3261 Expr *RewrittenExpr) {
3263 RewrittenExpr,
getSema().CurContext);
3298 std::optional<Expr *> ArraySize,
3317 bool IsGlobalDelete,
3368 bool IsAddressOfOperand,
3371 SS.
Adopt(QualifierLoc);
3373 if (TemplateArgs || TemplateKWLoc.
isValid())
3378 SS, NameInfo, IsAddressOfOperand,
nullptr, RecoveryTSI);
3403 bool HadMultipleCandidates,
3404 bool ListInitialization,
3405 bool StdInitListInitialization,
3406 bool RequiresZeroInit,
3412 if (Constructor->isInheritingConstructor())
3413 FoundCtor = Constructor->getInheritedConstructor().getConstructor();
3416 if (
getSema().CompleteConstructorCall(FoundCtor, T, Args, Loc,
3423 HadMultipleCandidates,
3425 StdInitListInitialization,
3426 RequiresZeroInit, ConstructKind,
3434 bool ConstructsVBase,
3435 bool InheritedFromVBase) {
3437 Loc, T, Constructor, ConstructsVBase, InheritedFromVBase);
3448 bool ListInitialization) {
3450 TSInfo, LParenOrBraceLoc, Args, RParenOrBraceLoc, ListInitialization);
3461 bool ListInitialization) {
3463 RParenLoc, ListInitialization);
3480 SS.
Adopt(QualifierLoc);
3483 OperatorLoc, IsArrow,
3485 FirstQualifierInScope,
3487 TemplateArgs,
nullptr);
3503 SS.
Adopt(QualifierLoc);
3506 OperatorLoc, IsArrow,
3508 FirstQualifierInScope,
3509 R, TemplateArgs,
nullptr);
3524 std::optional<unsigned> Length,
3527 RParenLoc, Length, PartialArgs);
3556 NamedConcept, TALI);
3572 LocalParameters, Requirements, ClosingBraceLoc);
3625 Expr **Elements,
unsigned NumElements) {
3635 getterMethod, setterMethod);
3668 Sel, Method, LBracLoc, SelectorLocs,
3683 Sel, Method, LBracLoc, SelectorLocs,
3699 Sel, Method, LBracLoc, SelectorLocs,
3704 Sel, Method, LBracLoc, SelectorLocs,
3716 bool IsArrow,
bool IsFreeIvar) {
3725 if (IsFreeIvar &&
Result.isUsable())
3726 cast<ObjCIvarRefExpr>(
Result.get())->setIsFreeIvar(IsFreeIvar);
3762 PropertyLoc,
Base));
3794 assert(!Lookup.
empty() &&
"No __builtin_shufflevector?");
3803 CK_BuiltinFnToFnPtr).
get();
3820 BuiltinLoc, RParenLoc);
3830 std::optional<unsigned> NumExpansions) {
3835 EllipsisLoc, NumExpansions);
3856 llvm_unreachable(
"Pack expansion pattern has no parameter packs");
3877 std::optional<unsigned> NumExpansions) {
3890 std::optional<unsigned> NumExpansions) {
3892 EllipsisLoc, RHS, RParenLoc,
3906 unsigned NumUserSpecifiedExprs,
3911 NumUserSpecifiedExprs, InitLoc,
3912 LParenLoc, RParenLoc);
3951 bool DeducibleTSTContext);
3954template <
typename Derived>
3959 switch (S->getStmtClass()) {
3964#define STMT(Node, Parent) \
3965 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
3966#define VALUESTMT(Node, Parent) \
3967 case Stmt::Node##Class: \
3968 return getDerived().Transform##Node(cast<Node>(S), SDK);
3969#define ABSTRACT_STMT(Node)
3970#define EXPR(Node, Parent)
3971#include "clang/AST/StmtNodes.inc"
3974#define STMT(Node, Parent)
3975#define ABSTRACT_STMT(Stmt)
3976#define EXPR(Node, Parent) case Stmt::Node##Class:
3977#include "clang/AST/StmtNodes.inc"
3979 ExprResult E = getDerived().TransformExpr(cast<Expr>(S));
3981 if (SDK == SDK_StmtExprResult)
3982 E = getSema().ActOnStmtExprResult(E);
3983 return getSema().ActOnExprStmt(E, SDK == SDK_Discarded);
3990template<
typename Derived>
3995 switch (S->getClauseKind()) {
3998#define GEN_CLANG_CLAUSE_CLASS
3999#define CLAUSE_CLASS(Enum, Str, Class) \
4001 return getDerived().Transform##Class(cast<Class>(S));
4002#include "llvm/Frontend/OpenMP/OMP.inc"
4009template<
typename Derived>
4016#define STMT(Node, Parent) case Stmt::Node##Class: break;
4017#define ABSTRACT_STMT(Stmt)
4018#define EXPR(Node, Parent) \
4019 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
4020#include "clang/AST/StmtNodes.inc"
4026template<
typename Derived>
4034 if (
auto *FE = dyn_cast<FullExpr>(Init))
4035 Init = FE->getSubExpr();
4037 if (
auto *AIL = dyn_cast<ArrayInitLoopExpr>(Init)) {
4043 Init = MTE->getSubExpr();
4046 Init = Binder->getSubExpr();
4049 Init = ICE->getSubExprAsWritten();
4052 dyn_cast<CXXStdInitializerListExpr>(Init))
4053 return TransformInitializer(ILE->getSubExpr(), NotCopyInit);
4060 return getDerived().TransformExpr(Init);
4065 return getDerived().RebuildParenListExpr(Parens.getBegin(), std::nullopt,
4070 if (isa<ImplicitValueInitExpr>(Init))
4071 return getDerived().RebuildParenListExpr(
SourceLocation(), std::nullopt,
4076 if (!Construct || isa<CXXTemporaryObjectExpr>(Construct))
4077 return getDerived().TransformExpr(Init);
4082 return TransformInitializer(Construct->
getArg(0), NotCopyInit);
4090 bool ArgChanged =
false;
4092 true, NewArgs, &ArgChanged))
4097 return getDerived().RebuildInitList(Construct->
getBeginLoc(), NewArgs,
4102 if (Parens.isInvalid()) {
4105 assert(NewArgs.empty() &&
4106 "no parens or braces but have direct init with arguments?");
4109 return getDerived().RebuildParenListExpr(Parens.getBegin(), NewArgs,
4113template<
typename Derived>
4119 for (
unsigned I = 0; I != NumInputs; ++I) {
4121 if (IsCall && getDerived().DropCallArgument(Inputs[I])) {
4129 Expr *Pattern = Expansion->getPattern();
4132 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
4133 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
4138 bool RetainExpansion =
false;
4139 std::optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions();
4140 std::optional<unsigned> NumExpansions = OrigNumExpansions;
4141 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
4144 Expand, RetainExpansion,
4153 ExprResult OutPattern = getDerived().TransformExpr(Pattern);
4157 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.
get(),
4158 Expansion->getEllipsisLoc(),
4160 if (Out.isInvalid())
4165 Outputs.push_back(Out.get());
4171 if (ArgChanged) *ArgChanged =
true;
4175 for (
unsigned I = 0; I != *NumExpansions; ++I) {
4177 ExprResult Out = getDerived().TransformExpr(Pattern);
4178 if (Out.isInvalid())
4181 if (Out.get()->containsUnexpandedParameterPack()) {
4182 Out = getDerived().RebuildPackExpansion(
4183 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
4184 if (Out.isInvalid())
4188 Outputs.push_back(Out.get());
4193 if (RetainExpansion) {
4194 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4196 ExprResult Out = getDerived().TransformExpr(Pattern);
4197 if (Out.isInvalid())
4200 Out = getDerived().RebuildPackExpansion(
4201 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
4202 if (Out.isInvalid())
4205 Outputs.push_back(Out.get());
4212 IsCall ? getDerived().TransformInitializer(Inputs[I],
false)
4213 : getDerived().TransformExpr(Inputs[I]);
4217 if (
Result.get() != Inputs[I] && ArgChanged)
4220 Outputs.push_back(
Result.get());
4226template <
typename Derived>
4230 VarDecl *ConditionVar = cast_or_null<VarDecl>(
4231 getDerived().TransformDefinition(Var->
getLocation(), Var));
4236 return getSema().ActOnConditionVariable(ConditionVar, Loc, Kind);
4245 return getSema().ActOnCondition(
nullptr, Loc, CondExpr.
get(), Kind,
4252template <
typename Derived>
4260 Qualifier = Qualifier.getPrefix())
4276 SS, FirstQualifierInScope,
false))
4283 cast_or_null<NamespaceDecl>(getDerived().TransformDecl(
4291 cast_or_null<NamespaceAliasDecl>(getDerived().TransformDecl(
4306 cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
4315 FirstQualifierInScope, SS);
4325 diag::warn_cxx98_compat_enum_nested_name_spec);
4328 SS.
Adopt(ETL.getQualifierLoc());
4329 TL = ETL.getNamedTypeLoc();
4347 FirstQualifierInScope =
nullptr;
4353 !getDerived().AlwaysRebuild())
4366template<
typename Derived>
4374 switch (Name.getNameKind()) {
4385 TemplateDecl *OldTemplate = Name.getCXXDeductionGuideTemplate();
4386 TemplateDecl *NewTemplate = cast_or_null<TemplateDecl>(
4387 getDerived().TransformDecl(NameInfo.
getLoc(), OldTemplate));
4403 NewTInfo = getDerived().TransformType(OldTInfo);
4411 QualType NewT = getDerived().TransformType(Name.getCXXNameType());
4427 llvm_unreachable(
"Unknown name kind.");
4430template<
typename Derived>
4437 bool AllowInjectedClassName) {
4439 TemplateDecl *Template = QTN->getUnderlyingTemplate().getAsTemplateDecl();
4440 assert(Template &&
"qualified template name must refer to a template");
4443 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
4448 if (!getDerived().AlwaysRebuild() &&
4450 TransTemplate == Template)
4453 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
4461 FirstQualifierInScope =
nullptr;
4464 if (!getDerived().AlwaysRebuild() &&
4472 if (DTN->isIdentifier()) {
4473 return getDerived().RebuildTemplateName(SS,
4475 *DTN->getIdentifier(),
4478 FirstQualifierInScope,
4479 AllowInjectedClassName);
4482 return getDerived().RebuildTemplateName(SS, TemplateKWLoc,
4483 DTN->getOperator(), NameLoc,
4484 ObjectType, AllowInjectedClassName);
4487 if (
TemplateDecl *Template = Name.getAsTemplateDecl()) {
4489 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
4494 if (!getDerived().AlwaysRebuild() &&
4495 TransTemplate == Template)
4502 = Name.getAsSubstTemplateTemplateParmPack()) {
4503 return getDerived().RebuildTemplateName(
4504 SubstPack->getArgumentPack(), SubstPack->getAssociatedDecl(),
4505 SubstPack->getIndex(), SubstPack->getFinal());
4509 llvm_unreachable(
"overloaded function decl survived to here");
4512template<
typename Derived>
4516 Output = getSema().getTrivialTemplateArgumentLoc(
4517 Arg,
QualType(), getDerived().getBaseLocation());
4520template <
typename Derived>
4528 llvm_unreachable(
"Unexpected TemplateArgument");
4537 QualType NewT = getDerived().TransformType(T);
4544 ValueDecl *NewD = D ? cast_or_null<ValueDecl>(getDerived().TransformDecl(
4545 getDerived().getBaseLocation(), D))
4550 if (NewT == T && D == NewD)
4571 DI = getDerived().TransformType(DI);
4582 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
4588 SS.
Adopt(QualifierLoc);
4589 TemplateName Template = getDerived().TransformTemplateName(
4600 llvm_unreachable(
"Caller should expand pack expansions");
4615 ExprResult E = getDerived().TransformExpr(InputExpr);
4630template<
typename Derived,
typename InputIterator>
4638 typedef typename std::iterator_traits<InputIterator>::difference_type
4655 : Self(Self), Iter(Iter) { }
4678 return X.Iter == Y.Iter;
4683 return X.Iter != Y.Iter;
4687template<
typename Derived>
4688template<
typename InputIterator>
4705 if (TransformTemplateArguments(PackLocIterator(*
this,
4707 PackLocIterator(*
this,
4719 std::optional<unsigned> OrigNumExpansions;
4721 = getSema().getTemplateArgumentPackExpansionPattern(
4722 In, Ellipsis, OrigNumExpansions);
4725 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
4726 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
4731 bool RetainExpansion =
false;
4732 std::optional<unsigned> NumExpansions = OrigNumExpansions;
4733 if (getDerived().TryExpandParameterPacks(Ellipsis,
4747 if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))
4750 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,
4752 if (Out.getArgument().isNull())
4761 for (
unsigned I = 0; I != *NumExpansions; ++I) {
4764 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
4767 if (Out.getArgument().containsUnexpandedParameterPack()) {
4768 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
4770 if (Out.getArgument().isNull())