13#ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
14#define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
48#include "llvm/ADT/ArrayRef.h"
49#include "llvm/Support/ErrorHandling.h"
53using namespace llvm::omp;
109template<
typename Derived>
114 class ForgetPartiallySubstitutedPackRAII {
122 ForgetPartiallySubstitutedPackRAII(Derived &Self)
123 : Self(Self), ResetPackSubstIndex(Self.getSema(), -1) {
124 Old = Self.ForgetPartiallySubstitutedPack();
127 ~ForgetPartiallySubstitutedPackRAII() {
128 Self.RememberPartiallySubstitutedPack(Old);
145 Derived &
getDerived() {
return static_cast<Derived&
>(*this); }
149 return static_cast<const Derived&
>(*this);
214 OldLocation = Self.getDerived().getBaseLocation();
215 OldEntity = Self.getDerived().getBaseEntity();
218 Self.getDerived().setBase(Location, Entity);
222 Self.getDerived().setBase(OldLocation, OldEntity);
252 return E->isDefaultArgument();
295 bool &ShouldExpand,
bool &RetainExpansion,
296 std::optional<unsigned> &NumExpansions) {
297 ShouldExpand =
false;
412 const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; }
413#include "clang/Basic/AttrList.inc"
423 const X##Attr *TransformStmt##X##Attr(const Stmt *, const Stmt *, \
424 const X##Attr *A) { \
425 return getDerived().Transform##X##Attr(A); \
427#include "clang/Basic/AttrList.inc"
473 bool *ArgChanged =
nullptr);
482 llvm::DenseMap<Decl *, Decl *>::iterator Known
485 return Known->second;
513 assert(New.size() == 1 &&
514 "must override transformedLocalDecl if performing pack expansion");
552 NamedDecl *FirstQualifierInScope =
nullptr);
597 NamedDecl *FirstQualifierInScope =
nullptr,
598 bool AllowInjectedClassName =
false);
610 bool Uneval =
false);
633 bool Uneval =
false) {
652 template<
typename InputIterator>
656 bool Uneval =
false);
668#define ABSTRACT_TYPELOC(CLASS, PARENT)
669#define TYPELOC(CLASS, PARENT) \
670 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
671#include "clang/AST/TypeLocNodes.def"
675 bool SuppressObjCLifetime);
679 bool SuppressObjCLifetime);
681 template<
typename Fn>
734 return getDerived().TransformFunctionTypeParams(
735 Loc, Params, ParamTypes, ParamInfos, PTypes, PVars, PInfos,
nullptr);
753 KWLoc, Params,
nullptr,
754 nullptr, PTypes, &TransParams, PInfos))
767 std::optional<unsigned> NumExpansions,
768 bool ExpectParameterPack);
795 bool IsAddressOfOperand,
803 bool IsAddressOfOperand);
811#define STMT(Node, Parent) \
812 LLVM_ATTRIBUTE_NOINLINE \
813 StmtResult Transform##Node(Node *S);
814#define VALUESTMT(Node, Parent) \
815 LLVM_ATTRIBUTE_NOINLINE \
816 StmtResult Transform##Node(Node *S, StmtDiscardKind SDK);
817#define EXPR(Node, Parent) \
818 LLVM_ATTRIBUTE_NOINLINE \
819 ExprResult Transform##Node(Node *E);
820#define ABSTRACT_STMT(Stmt)
821#include "clang/AST/StmtNodes.inc"
823#define GEN_CLANG_CLAUSE_CLASS
824#define CLAUSE_CLASS(Enum, Str, Class) \
825 LLVM_ATTRIBUTE_NOINLINE \
826 OMPClause *Transform##Class(Class *S);
827#include "llvm/Frontend/OpenMP/OMP.inc"
904 const llvm::APInt *Size,
Expr *SizeExpr,
905 unsigned IndexTypeQuals,
SourceRange BracketsRange);
914 const llvm::APInt &Size,
Expr *SizeExpr,
915 unsigned IndexTypeQuals,
925 unsigned IndexTypeQuals,
935 unsigned IndexTypeQuals,
946 unsigned IndexTypeQuals,
984 unsigned NumColumns);
1001 Expr *AddrSpaceExpr,
1071 bool FullySubstituted,
1085 TypeConstraintConcept,
1086 TypeConstraintArgs);
1094 Template, Deduced,
false);
1140 bool AllowInjectedClassName) {
1144 SS.
Adopt(QualifierLoc);
1146 SS, TemplateKWLoc, *Name, NameLoc,
QualType(),
nullptr,
1147 AllowInjectedClassName);
1161 getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
1178 bool DeducedTSTContext) {
1180 SS.
Adopt(QualifierLoc);
1193 *
Id, IdLoc, DeducedTSTContext);
1211 switch (
Result.getResultKind()) {
1222 llvm_unreachable(
"Tag lookup cannot find non-tags");
1234 switch (
Result.getResultKind()) {
1240 SemaRef.
Diag(IdLoc, diag::err_tag_reference_non_tag)
1241 << SomeDecl << NTK << llvm::to_underlying(Kind);
1247 << llvm::to_underlying(Kind) <<
Id << DC
1256 SemaRef.
Diag(KeywordLoc, diag::err_use_with_wrong_tag) <<
Id;
1257 SemaRef.
Diag(Tag->getLocation(), diag::note_previous_use);
1274 std::optional<unsigned> NumExpansions) {
1319 bool AllowInjectedClassName);
1332 bool AllowInjectedClassName);
1342 Decl *AssociatedDecl,
unsigned Index,
1345 ArgPack, AssociatedDecl, Index, Final);
1423 Then, ElseLoc, Else);
1477 Inc, RParenLoc, Body);
1522 bool IsVolatile,
unsigned NumOutputs,
1529 NumInputs, Names, Constraints, Exprs,
1530 AsmString, Clobbers, NumLabels, RParenLoc);
1539 StringRef AsmString,
1540 unsigned NumOutputs,
unsigned NumInputs,
1546 NumOutputs, NumInputs,
1547 Constraints, Clobbers, Exprs, EndLoc);
1576 CoawaitLoc, Operand, OpCoawaitLookup);
1580 Suspend.
get(),
true);
1681 Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
1693 Kind, DirName, Clauses, AStmt, StartLoc, EndLoc);
1707 NameModifier,
Condition, StartLoc, LParenLoc, NameModifierLoc, ColonLoc,
1818 Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);
1831 Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);
1844 M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
1895 VarList, LPKind, LPKindLoc, ColonLoc, StartLoc, LParenLoc, EndLoc);
1922 VarList, Modifier, StartLoc, LParenLoc, ModifierLoc, ColonLoc, EndLoc,
1923 ReductionIdScopeSpec, ReductionId, UnresolvedReductions);
1937 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1938 ReductionId, UnresolvedReductions);
1953 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1954 ReductionId, UnresolvedReductions);
1967 VarList, Step, StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc,
1968 StepModifierLoc, EndLoc);
1981 VarList, Alignment, StartLoc, LParenLoc, ColonLoc, EndLoc);
2041 Data, DepModifier, VarList, StartLoc, LParenLoc, EndLoc);
2054 Modifier,
Device, StartLoc, LParenLoc, ModifierLoc, EndLoc);
2069 IteratorModifier, MapTypeModifiers, MapTypeModifiersLoc,
2070 MapperIdScopeSpec, MapperId, MapType, IsMapTypeImplicit, MapLoc,
2071 ColonLoc, VarList, Locs,
2072 false, UnresolvedMappers);
2089 Allocate, Alignment, FirstModifier, FirstModifierLoc, SecondModifier,
2090 SecondModifierLoc, VarList, StartLoc, LParenLoc, ColonLoc, EndLoc);
2138 Modifier,
Device, StartLoc, LParenLoc, ModifierLoc, EndLoc);
2151 Modifier, NumTasks, StartLoc, LParenLoc, ModifierLoc, EndLoc);
2186 Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
2201 MotionModifiers, MotionModifiersLoc, MapperIdScopeSpec, MapperId,
2202 ColonLoc, VarList, Locs, UnresolvedMappers);
2217 MotionModifiers, MotionModifiersLoc, MapperIdScopeSpec, MapperId,
2218 ColonLoc, VarList, Locs, UnresolvedMappers);
2269 M, Kind, StartLoc, LParenLoc, MLoc, KindLoc, EndLoc);
2316 StartLoc, LParenLoc, EndLoc,
Data);
2329 StartLoc, LParenLoc, ColonLoc, EndLoc, Modifier, Locators);
2341 Modifier, Kind, StartLoc, LParenLoc, ModifierKwLoc, KindKwLoc, EndLoc);
2354 InteropVar, InteropInfo, StartLoc, LParenLoc, VarLoc, EndLoc);
2365 LParenLoc, VarLoc, EndLoc);
2377 InteropVar, StartLoc, LParenLoc, VarLoc, EndLoc);
2516 DepType, DepLoc, ColonLoc, VarList, StartLoc, LParenLoc, EndLoc);
2564 ForLoc, Element, Collection, RParenLoc);
2582 StartLoc, IdLoc,
Id);
2620 if (RangeStmt->isSingleDecl()) {
2621 if (
VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
2622 if (RangeVar->isInvalidDecl())
2625 Expr *RangeExpr = RangeVar->getInit();
2632 diag::err_objc_for_range_init_stmt)
2633 <<
Init->getSourceRange();
2636 ForLoc, LoopVar, RangeExpr, RParenLoc);
2643 ForLoc, CoawaitLoc,
Init, ColonLoc,
Range,
Begin, End, Cond, Inc,
2657 QualifierLoc, NameInfo, Nested);
2719 SS.
Adopt(QualifierLoc);
2831 if (IsOMPArraySection)
2833 Base, LBracketLoc, LowerBound, ColonLocFirst, ColonLocSecond, Length,
2834 Stride, RBracketLoc);
2836 assert(Stride ==
nullptr && !ColonLocSecond.
isValid() &&
2837 "Stride/second colon not allowed for OpenACC");
2840 Base, LBracketLoc, LowerBound, ColonLocFirst, Length, RBracketLoc);
2852 Base, LParenLoc, RParenLoc, Dims, BracketsRanges);
2864 nullptr, IteratorKwLoc, LLoc, RLoc,
Data);
2874 Expr *ExecConfig =
nullptr) {
2876 nullptr, Callee, LParenLoc, Args, RParenLoc, ExecConfig);
2883 nullptr, Callee, LParenLoc, Args, RParenLoc);
2901 if (!
Member->getDeclName()) {
2905 assert(
Member->getType()->isRecordType() &&
2906 "unnamed member not of record type?");
2919 if (!isArrow &&
Base->isPRValue()) {
2928 Base, isArrow, OpLoc, EmptySS, cast<FieldDecl>(
Member),
2934 SS.
Adopt(QualifierLoc);
2937 if (
Base->containsErrors())
2951 if (
getSema().isUnevaluatedContext() &&
Base->isImplicitCXXThis() &&
2952 isa<FieldDecl, IndirectFieldDecl, MSPropertyDecl>(
Member)) {
2953 if (
auto *ThisClass = cast<CXXThisExpr>(
Base)
2956 ->getAsCXXRecordDecl()) {
2957 auto *
Class = cast<CXXRecordDecl>(
Member->getDeclContext());
2960 if (!ThisClass->Equals(
Class) && !ThisClass->isDerivedFrom(
Class))
2968 FirstQualifierInScope,
2969 R, ExplicitTemplateArgs,
3147 Expr *ControllingExpr,
3152 ControllingExpr, Types, Exprs);
3167 ControllingType, Types, Exprs);
3200 case Stmt::CXXStaticCastExprClass:
3201 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
3202 RAngleLoc, LParenLoc,
3203 SubExpr, RParenLoc);
3205 case Stmt::CXXDynamicCastExprClass:
3206 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
3207 RAngleLoc, LParenLoc,
3208 SubExpr, RParenLoc);
3210 case Stmt::CXXReinterpretCastExprClass:
3211 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
3212 RAngleLoc, LParenLoc,
3216 case Stmt::CXXConstCastExprClass:
3217 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
3218 RAngleLoc, LParenLoc,
3219 SubExpr, RParenLoc);
3221 case Stmt::CXXAddrspaceCastExprClass:
3222 return getDerived().RebuildCXXAddrspaceCastExpr(
3223 OpLoc, LAngleLoc, TInfo, RAngleLoc, LParenLoc, SubExpr, RParenLoc);
3226 llvm_unreachable(
"Invalid C++ named cast");
3304 OpLoc, tok::kw_addrspace_cast, TInfo, SubExpr,
3316 bool ListInitialization) {
3320 if (
auto *PLE = dyn_cast<ParenListExpr>(Sub))
3322 TInfo, LParenLoc,
MultiExprArg(PLE->getExprs(), PLE->getNumExprs()),
3323 RParenLoc, ListInitialization);
3326 ListInitialization);
3390 if (
getSema().CheckCXXThisType(ThisLoc, ThisType))
3400 bool IsThrownVariableInScope) {
3410 Expr *RewrittenExpr) {
3412 RewrittenExpr,
getSema().CurContext);
3446 std::optional<Expr *> ArraySize,
3465 bool IsGlobalDelete,
3516 bool IsAddressOfOperand,
3519 SS.
Adopt(QualifierLoc);
3521 if (TemplateArgs || TemplateKWLoc.
isValid())
3523 SS, TemplateKWLoc, NameInfo, TemplateArgs, IsAddressOfOperand);
3526 SS, NameInfo, IsAddressOfOperand, RecoveryTSI);
3548 bool IsElidable,
MultiExprArg Args,
bool HadMultipleCandidates,
3549 bool ListInitialization,
bool StdInitListInitialization,
3555 if (Constructor->isInheritingConstructor())
3556 FoundCtor = Constructor->getInheritedConstructor().getConstructor();
3559 if (
getSema().CompleteConstructorCall(FoundCtor,
T, Args,
Loc,
3566 HadMultipleCandidates,
3568 StdInitListInitialization,
3569 RequiresZeroInit, ConstructKind,
3577 bool ConstructsVBase,
3578 bool InheritedFromVBase) {
3580 Loc,
T, Constructor, ConstructsVBase, InheritedFromVBase);
3591 bool ListInitialization) {
3593 TSInfo, LParenOrBraceLoc, Args, RParenOrBraceLoc, ListInitialization);
3604 bool ListInitialization) {
3606 RParenLoc, ListInitialization);
3623 SS.
Adopt(QualifierLoc);
3626 OperatorLoc, IsArrow,
3628 FirstQualifierInScope,
3630 TemplateArgs,
nullptr);
3646 SS.
Adopt(QualifierLoc);
3649 OperatorLoc, IsArrow,
3651 FirstQualifierInScope,
3652 R, TemplateArgs,
nullptr);
3667 std::optional<unsigned> Length,
3670 RParenLoc, Length, PartialArgs);
3675 Expr *PackIdExpression,
Expr *IndexExpr,
3677 bool FullySubstituted =
false) {
3679 IndexExpr, RSquareLoc, ExpandedExprs,
3709 NamedConcept, TALI);
3727 LocalParameters, RParenLoc, Requirements,
3781 Expr **Elements,
unsigned NumElements) {
3791 RB,
Base, Key, getterMethod, setterMethod);
3823 ReceiverTypeInfo, ReceiverTypeInfo->
getType(),
3838 Sel, Method, LBracLoc,
3839 SelectorLocs, RBracLoc, Args);
3853 nullptr, SuperType, SuperLoc, Sel, Method, LBracLoc,
3854 SelectorLocs, RBracLoc, Args)
3856 Sel, Method, LBracLoc,
3857 SelectorLocs, RBracLoc, Args);
3866 bool IsArrow,
bool IsFreeIvar) {
3875 if (IsFreeIvar &&
Result.isUsable())
3876 cast<ObjCIvarRefExpr>(
Result.get())->setIsFreeIvar(IsFreeIvar);
3912 PropertyLoc,
Base));
3944 assert(!Lookup.
empty() &&
"No __builtin_shufflevector?");
3953 CK_BuiltinFnToFnPtr).
get();
3979 std::optional<unsigned> NumExpansions) {
3984 EllipsisLoc, NumExpansions);
4006 llvm_unreachable(
"Pack expansion pattern has no parameter packs");
4027 std::optional<unsigned> NumExpansions) {
4040 std::optional<unsigned> NumExpansions) {
4042 EllipsisLoc, RHS, RParenLoc,
4051 Init->containsUnexpandedParameterPack();
4052 else if (PVD->hasUninstantiatedDefaultArg())
4054 PVD->getUninstantiatedDefaultArg()
4055 ->containsUnexpandedParameterPack();
4200 Exprs.push_back(DevNumExpr);
4201 Exprs.insert(Exprs.end(), QueueIdExprs.begin(), QueueIdExprs.end());
4204 Exprs, RParenLoc, EndLoc, Clauses, {});
4228 bool DeducibleTSTContext);
4240template <
typename Derived>
4245 switch (S->getStmtClass()) {
4250#define STMT(Node, Parent) \
4251 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
4252#define VALUESTMT(Node, Parent) \
4253 case Stmt::Node##Class: \
4254 return getDerived().Transform##Node(cast<Node>(S), SDK);
4255#define ABSTRACT_STMT(Node)
4256#define EXPR(Node, Parent)
4257#include "clang/AST/StmtNodes.inc"
4260#define STMT(Node, Parent)
4261#define ABSTRACT_STMT(Stmt)
4262#define EXPR(Node, Parent) case Stmt::Node##Class:
4263#include "clang/AST/StmtNodes.inc"
4265 ExprResult E = getDerived().TransformExpr(cast<Expr>(S));
4267 if (SDK == SDK_StmtExprResult)
4268 E = getSema().ActOnStmtExprResult(
E);
4269 return getSema().ActOnExprStmt(
E, SDK == SDK_Discarded);
4276template<
typename Derived>
4281 switch (S->getClauseKind()) {
4284#define GEN_CLANG_CLAUSE_CLASS
4285#define CLAUSE_CLASS(Enum, Str, Class) \
4287 return getDerived().Transform##Class(cast<Class>(S));
4288#include "llvm/Frontend/OpenMP/OMP.inc"
4295template<
typename Derived>
4302#define STMT(Node, Parent) case Stmt::Node##Class: break;
4303#define ABSTRACT_STMT(Stmt)
4304#define EXPR(Node, Parent) \
4305 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
4306#include "clang/AST/StmtNodes.inc"
4312template<
typename Derived>
4320 if (
auto *FE = dyn_cast<FullExpr>(
Init))
4321 Init = FE->getSubExpr();
4323 if (
auto *AIL = dyn_cast<ArrayInitLoopExpr>(
Init)) {
4329 Init = MTE->getSubExpr();
4332 Init = Binder->getSubExpr();
4335 Init = ICE->getSubExprAsWritten();
4338 dyn_cast<CXXStdInitializerListExpr>(
Init))
4339 return TransformInitializer(ILE->getSubExpr(), NotCopyInit);
4346 return getDerived().TransformExpr(
Init);
4351 return getDerived().RebuildParenListExpr(
Parens.getBegin(), {},
4356 if (isa<ImplicitValueInitExpr>(
Init))
4362 if (!Construct || isa<CXXTemporaryObjectExpr>(Construct))
4363 return getDerived().TransformExpr(
Init);
4368 return TransformInitializer(Construct->
getArg(0), NotCopyInit);
4375 getSema().currentEvaluationContext().InLifetimeExtendingContext =
4376 getSema().parentEvaluationContext().InLifetimeExtendingContext;
4377 getSema().currentEvaluationContext().RebuildDefaultArgOrDefaultInit =
4378 getSema().parentEvaluationContext().RebuildDefaultArgOrDefaultInit;
4380 bool ArgChanged =
false;
4382 true, NewArgs, &ArgChanged))
4387 return getDerived().RebuildInitList(Construct->
getBeginLoc(), NewArgs,
4392 if (
Parens.isInvalid()) {
4395 assert(NewArgs.empty() &&
4396 "no parens or braces but have direct init with arguments?");
4399 return getDerived().RebuildParenListExpr(
Parens.getBegin(), NewArgs,
4403template<
typename Derived>
4409 for (
unsigned I = 0; I != NumInputs; ++I) {
4411 if (IsCall && getDerived().DropCallArgument(Inputs[I])) {
4419 Expr *Pattern = Expansion->getPattern();
4422 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
4423 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
4428 bool RetainExpansion =
false;
4429 std::optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions();
4430 std::optional<unsigned> NumExpansions = OrigNumExpansions;
4431 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
4434 Expand, RetainExpansion,
4443 ExprResult OutPattern = getDerived().TransformExpr(Pattern);
4447 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.
get(),
4448 Expansion->getEllipsisLoc(),
4450 if (Out.isInvalid())
4455 Outputs.push_back(Out.get());
4461 if (ArgChanged) *ArgChanged =
true;
4465 for (
unsigned I = 0; I != *NumExpansions; ++I) {
4467 ExprResult Out = getDerived().TransformExpr(Pattern);
4468 if (Out.isInvalid())
4471 if (Out.get()->containsUnexpandedParameterPack()) {
4472 Out = getDerived().RebuildPackExpansion(
4473 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
4474 if (Out.isInvalid())
4478 Outputs.push_back(Out.get());
4483 if (RetainExpansion) {
4484 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4486 ExprResult Out = getDerived().TransformExpr(Pattern);
4487 if (Out.isInvalid())
4490 Out = getDerived().RebuildPackExpansion(
4491 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
4492 if (Out.isInvalid())
4495 Outputs.push_back(Out.get());
4502 IsCall ? getDerived().TransformInitializer(Inputs[I],
false)
4503 : getDerived().TransformExpr(Inputs[I]);
4507 if (
Result.get() != Inputs[I] && ArgChanged)
4510 Outputs.push_back(
Result.get());
4516template <
typename Derived>
4520 VarDecl *ConditionVar = cast_or_null<VarDecl>(
4521 getDerived().TransformDefinition(Var->
getLocation(), Var));
4526 return getSema().ActOnConditionVariable(ConditionVar,
Loc, Kind);
4535 return getSema().ActOnCondition(
nullptr,
Loc, CondExpr.
get(), Kind,
4542template <
typename Derived>
4550 Qualifier = Qualifier.getPrefix())
4566 SS, FirstQualifierInScope,
false))
4573 cast_or_null<NamespaceDecl>(getDerived().TransformDecl(
4581 cast_or_null<NamespaceAliasDecl>(getDerived().TransformDecl(
4596 cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
4605 FirstQualifierInScope, SS);
4615 diag::warn_cxx98_compat_enum_nested_name_spec);
4618 SS.
Adopt(ETL.getQualifierLoc());
4619 TL = ETL.getNamedTypeLoc();
4638 FirstQualifierInScope =
nullptr;
4644 !getDerived().AlwaysRebuild())
4657template<
typename Derived>
4665 switch (Name.getNameKind()) {
4676 TemplateDecl *OldTemplate = Name.getCXXDeductionGuideTemplate();
4677 TemplateDecl *NewTemplate = cast_or_null<TemplateDecl>(
4678 getDerived().TransformDecl(NameInfo.
getLoc(), OldTemplate));
4694 NewTInfo = getDerived().TransformType(OldTInfo);
4702 QualType NewT = getDerived().TransformType(Name.getCXXNameType());
4718 llvm_unreachable(
"Unknown name kind.");
4721template<
typename Derived>
4728 bool AllowInjectedClassName) {
4730 TemplateDecl *Template = QTN->getUnderlyingTemplate().getAsTemplateDecl();
4731 assert(Template &&
"qualified template name must refer to a template");
4734 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
4739 if (!getDerived().AlwaysRebuild() &&
4741 TransTemplate == Template)
4744 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
4752 FirstQualifierInScope =
nullptr;
4755 if (!getDerived().AlwaysRebuild() &&
4763 if (DTN->isIdentifier()) {
4764 return getDerived().RebuildTemplateName(SS,
4766 *DTN->getIdentifier(),
4769 FirstQualifierInScope,
4770 AllowInjectedClassName);
4773 return getDerived().RebuildTemplateName(SS, TemplateKWLoc,
4774 DTN->getOperator(), NameLoc,
4775 ObjectType, AllowInjectedClassName);
4779 if (
TemplateDecl *Template = Name.getAsTemplateDecl()) {
4781 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
4786 return getDerived().RebuildTemplateName(SS,
false,
4791 = Name.getAsSubstTemplateTemplateParmPack()) {
4792 return getDerived().RebuildTemplateName(
4793 SubstPack->getArgumentPack(), SubstPack->getAssociatedDecl(),
4794 SubstPack->getIndex(), SubstPack->getFinal());
4798 llvm_unreachable(
"overloaded function decl survived to here");
4801template<
typename Derived>
4805 Output = getSema().getTrivialTemplateArgumentLoc(
4806 Arg,
QualType(), getDerived().getBaseLocation());
4809template <
typename Derived>
4817 llvm_unreachable(
"Unexpected TemplateArgument");
4827 QualType NewT = getDerived().TransformType(
T);
4834 ValueDecl *NewD =
D ? cast_or_null<ValueDecl>(getDerived().TransformDecl(
4835 getDerived().getBaseLocation(),
D))
4840 if (NewT ==
T &&
D == NewD)
4857 llvm_unreachable(
"unexpected template argument kind");
4867 DI = getDerived().TransformType(DI);
4878 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
4884 SS.
Adopt(QualifierLoc);
4885 TemplateName Template = getDerived().TransformTemplateName(
4896 llvm_unreachable(
"Caller should expand pack expansions");
4911 ExprResult E = getDerived().TransformExpr(InputExpr);
4926template<
typename Derived,
typename InputIterator>
4934 typedef typename std::iterator_traits<InputIterator>::difference_type
4964 Self.InventTemplateArgumentLoc(*
Iter,
Result);
4972 return X.Iter == Y.Iter;
4977 return X.Iter != Y.Iter;
4981template<
typename Derived>
4982template<
typename InputIterator>
4999 if (TransformTemplateArguments(PackLocIterator(*
this,
5000 In.getArgument().pack_begin()),
5001 PackLocIterator(*
this,
5002 In.getArgument().pack_end()),
5009 if (In.getArgument().isPackExpansion()) {
5013 std::optional<unsigned> OrigNumExpansions;
5015 = getSema().getTemplateArgumentPackExpansionPattern(
5016 In, Ellipsis, OrigNumExpansions);
5019 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
5020 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
5025 bool RetainExpansion =
false;
5026 std::optional<unsigned> NumExpansions = OrigNumExpansions;
5027 if (getDerived().TryExpandParameterPacks(Ellipsis,
5041 if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))
5044 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,
5046 if (Out.getArgument().isNull())
5055 for (
unsigned I = 0; I != *NumExpansions; ++I) {
5058 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
5061 if (Out.getArgument().containsUnexpandedParameterPack()) {
5062 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
5064 if (Out.getArgument().isNull())
5073 if (RetainExpansion) {
5074 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
5076 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
5079 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
5081 if (Out.getArgument().isNull())
5091 if (getDerived().TransformTemplateArgument(In, Out, Uneval))