13#ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
14#define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
41#include "llvm/ADT/ArrayRef.h"
42#include "llvm/Support/ErrorHandling.h"
46using namespace llvm::omp;
102template<
typename Derived>
107 class ForgetPartiallySubstitutedPackRAII {
112 ForgetPartiallySubstitutedPackRAII(Derived &Self) : Self(Self) {
113 Old = Self.ForgetPartiallySubstitutedPack();
116 ~ForgetPartiallySubstitutedPackRAII() {
117 Self.RememberPartiallySubstitutedPack(Old);
134 Derived &
getDerived() {
return static_cast<Derived&
>(*this); }
138 return static_cast<const Derived&
>(*this);
203 OldLocation = Self.
getDerived().getBaseLocation();
204 OldEntity = Self.
getDerived().getBaseEntity();
211 Self.
getDerived().setBase(OldLocation, OldEntity);
284 bool &ShouldExpand,
bool &RetainExpansion,
285 std::optional<unsigned> &NumExpansions) {
286 ShouldExpand =
false;
401 const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; }
402#include "clang/Basic/AttrList.inc"
412 const X##Attr *TransformStmt##X##Attr(const Stmt *, const Stmt *, \
413 const X##Attr *A) { \
414 return getDerived().Transform##X##Attr(A); \
416#include "clang/Basic/AttrList.inc"
462 bool *ArgChanged =
nullptr);
471 llvm::DenseMap<Decl *, Decl *>::iterator Known
474 return Known->second;
502 assert(New.size() == 1 &&
503 "must override transformedLocalDecl if performing pack expansion");
541 NamedDecl *FirstQualifierInScope =
nullptr);
586 NamedDecl *FirstQualifierInScope =
nullptr,
587 bool AllowInjectedClassName =
false);
599 bool Uneval =
false);
622 bool Uneval =
false) {
641 template<
typename InputIterator>
645 bool Uneval =
false);
657#define ABSTRACT_TYPELOC(CLASS, PARENT)
658#define TYPELOC(CLASS, PARENT) \
659 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
660#include "clang/AST/TypeLocNodes.def"
664 bool SuppressObjCLifetime);
668 bool SuppressObjCLifetime);
670 template<
typename Fn>
723 return getDerived().TransformFunctionTypeParams(
724 Loc, Params, ParamTypes, ParamInfos, PTypes, PVars, PInfos,
nullptr);
742 KWLoc, Params,
nullptr,
743 nullptr, PTypes, &TransParams, PInfos))
756 std::optional<unsigned> NumExpansions,
757 bool ExpectParameterPack);
778 bool IsAddressOfOperand,
789#define STMT(Node, Parent) \
790 LLVM_ATTRIBUTE_NOINLINE \
791 StmtResult Transform##Node(Node *S);
792#define VALUESTMT(Node, Parent) \
793 LLVM_ATTRIBUTE_NOINLINE \
794 StmtResult Transform##Node(Node *S, StmtDiscardKind SDK);
795#define EXPR(Node, Parent) \
796 LLVM_ATTRIBUTE_NOINLINE \
797 ExprResult Transform##Node(Node *E);
798#define ABSTRACT_STMT(Stmt)
799#include "clang/AST/StmtNodes.inc"
801#define GEN_CLANG_CLAUSE_CLASS
802#define CLAUSE_CLASS(Enum, Str, Class) \
803 LLVM_ATTRIBUTE_NOINLINE \
804 OMPClause *Transform##Class(Class *S);
805#include "llvm/Frontend/OpenMP/OMP.inc"
882 const llvm::APInt *Size,
Expr *SizeExpr,
883 unsigned IndexTypeQuals,
SourceRange BracketsRange);
892 const llvm::APInt &Size,
Expr *SizeExpr,
893 unsigned IndexTypeQuals,
903 unsigned IndexTypeQuals,
913 unsigned IndexTypeQuals,
924 unsigned IndexTypeQuals,
962 unsigned NumColumns);
1057 TypeConstraintConcept,
1058 TypeConstraintArgs);
1066 Template, Deduced,
false);
1112 bool AllowInjectedClassName) {
1116 SS.
Adopt(QualifierLoc);
1118 SS, TemplateKWLoc, *Name, NameLoc,
QualType(),
nullptr,
1119 AllowInjectedClassName);
1133 getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
1150 bool DeducedTSTContext) {
1152 SS.
Adopt(QualifierLoc);
1165 *
Id, IdLoc, DeducedTSTContext);
1183 switch (
Result.getResultKind()) {
1194 llvm_unreachable(
"Tag lookup cannot find non-tags");
1206 switch (
Result.getResultKind()) {
1212 SemaRef.
Diag(IdLoc, diag::err_tag_reference_non_tag)
1213 << SomeDecl << NTK << llvm::to_underlying(Kind);
1219 << llvm::to_underlying(Kind) <<
Id << DC
1228 SemaRef.
Diag(KeywordLoc, diag::err_use_with_wrong_tag) <<
Id;
1246 std::optional<unsigned> NumExpansions) {
1291 bool AllowInjectedClassName);
1304 bool AllowInjectedClassName);
1314 Decl *AssociatedDecl,
unsigned Index,
1317 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,
1655 PrevMappedDirective);
1669 LParenLoc, NameModifierLoc, ColonLoc,
1767 StartLoc, LParenLoc, EndLoc);
1780 StartLoc, LParenLoc, EndLoc);
1793 M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
1843 VarList, LPKind, LPKindLoc, ColonLoc, StartLoc, LParenLoc, EndLoc);
1870 VarList, Modifier, StartLoc, LParenLoc, ModifierLoc, ColonLoc, EndLoc,
1871 ReductionIdScopeSpec, ReductionId, UnresolvedReductions);
1885 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1886 ReductionId, UnresolvedReductions);
1901 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1902 ReductionId, UnresolvedReductions);
1915 Modifier, ModifierLoc, ColonLoc,
1916 StepModifierLoc, EndLoc);
1929 LParenLoc, ColonLoc, EndLoc);
1989 StartLoc, LParenLoc, EndLoc);
2002 LParenLoc, ModifierLoc, EndLoc);
2017 IteratorModifier, MapTypeModifiers, MapTypeModifiersLoc,
2018 MapperIdScopeSpec, MapperId, MapType, IsMapTypeImplicit, MapLoc,
2019 ColonLoc, VarList, Locs,
2020 false, UnresolvedMappers);
2033 LParenLoc, ColonLoc, EndLoc);
2080 LParenLoc, ModifierLoc, EndLoc);
2093 LParenLoc, ModifierLoc, EndLoc);
2126 Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
2141 MapperIdScopeSpec, MapperId, ColonLoc,
2142 VarList, Locs, UnresolvedMappers);
2157 MotionModifiers, MotionModifiersLoc, MapperIdScopeSpec, MapperId,
2158 ColonLoc, VarList, Locs, UnresolvedMappers);
2209 MLoc, KindLoc, EndLoc);
2269 EndLoc, Modifier, Locators);
2281 ModifierKwLoc, KindKwLoc, EndLoc);
2294 LParenLoc, VarLoc, EndLoc);
2454 DepType, DepLoc, ColonLoc, VarList, StartLoc, LParenLoc, EndLoc);
2513 StartLoc, IdLoc,
Id);
2551 if (
DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) {
2552 if (RangeStmt->isSingleDecl()) {
2553 if (
VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
2554 if (RangeVar->isInvalidDecl())
2557 Expr *RangeExpr = RangeVar->getInit();
2564 diag::err_objc_for_range_init_stmt)
2565 <<
Init->getSourceRange();
2568 RangeExpr, RParenLoc);
2575 Range,
Begin, End, Cond, Inc, LoopVar,
2589 QualifierLoc, NameInfo, Nested);
2650 SS.
Adopt(QualifierLoc);
2762 ColonLocFirst, ColonLocSecond,
2763 Length, Stride, RBracketLoc);
2796 Expr *ExecConfig =
nullptr) {
2798 nullptr, Callee, LParenLoc, Args, RParenLoc, ExecConfig);
2805 nullptr, Callee, LParenLoc, Args, RParenLoc);
2823 if (!
Member->getDeclName()) {
2827 assert(
Member->getType()->isRecordType() &&
2828 "unnamed member not of record type?");
2840 Base, isArrow, OpLoc, EmptySS, cast<FieldDecl>(
Member),
2845 SS.
Adopt(QualifierLoc);
2859 if (
getSema().isUnevaluatedContext() &&
Base->isImplicitCXXThis() &&
2860 isa<FieldDecl, IndirectFieldDecl, MSPropertyDecl>(
Member)) {
2861 if (
auto *ThisClass = cast<CXXThisExpr>(
Base)
2864 ->getAsCXXRecordDecl()) {
2865 auto *
Class = cast<CXXRecordDecl>(
Member->getDeclContext());
2868 if (!ThisClass->Equals(
Class) && !ThisClass->isDerivedFrom(
Class))
2876 FirstQualifierInScope,
2877 R, ExplicitTemplateArgs,
3055 Expr *ControllingExpr,
3060 ControllingExpr, Types, Exprs);
3075 ControllingType, Types, Exprs);
3108 case Stmt::CXXStaticCastExprClass:
3109 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
3110 RAngleLoc, LParenLoc,
3111 SubExpr, RParenLoc);
3113 case Stmt::CXXDynamicCastExprClass:
3114 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
3115 RAngleLoc, LParenLoc,
3116 SubExpr, RParenLoc);
3118 case Stmt::CXXReinterpretCastExprClass:
3119 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
3120 RAngleLoc, LParenLoc,
3124 case Stmt::CXXConstCastExprClass:
3125 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
3126 RAngleLoc, LParenLoc,
3127 SubExpr, RParenLoc);
3129 case Stmt::CXXAddrspaceCastExprClass:
3130 return getDerived().RebuildCXXAddrspaceCastExpr(
3131 OpLoc, LAngleLoc, TInfo, RAngleLoc, LParenLoc, SubExpr, RParenLoc);
3134 llvm_unreachable(
"Invalid C++ named cast");
3212 OpLoc, tok::kw_addrspace_cast, TInfo, SubExpr,
3224 bool ListInitialization) {
3228 if (
auto *PLE = dyn_cast<ParenListExpr>(Sub))
3230 TInfo, LParenLoc,
MultiExprArg(PLE->getExprs(), PLE->getNumExprs()),
3231 RParenLoc, ListInitialization);
3234 ListInitialization);
3307 bool IsThrownVariableInScope) {
3317 Expr *RewrittenExpr) {
3319 RewrittenExpr,
getSema().CurContext);
3354 std::optional<Expr *> ArraySize,
3373 bool IsGlobalDelete,
3424 bool IsAddressOfOperand,
3427 SS.
Adopt(QualifierLoc);
3429 if (TemplateArgs || TemplateKWLoc.
isValid())
3434 SS, NameInfo, IsAddressOfOperand,
nullptr, RecoveryTSI);
3456 bool IsElidable,
MultiExprArg Args,
bool HadMultipleCandidates,
3457 bool ListInitialization,
bool StdInitListInitialization,
3463 if (Constructor->isInheritingConstructor())
3464 FoundCtor = Constructor->getInheritedConstructor().getConstructor();
3467 if (
getSema().CompleteConstructorCall(FoundCtor, T, Args, Loc,
3474 HadMultipleCandidates,
3476 StdInitListInitialization,
3477 RequiresZeroInit, ConstructKind,
3485 bool ConstructsVBase,
3486 bool InheritedFromVBase) {
3488 Loc, T, Constructor, ConstructsVBase, InheritedFromVBase);
3499 bool ListInitialization) {
3501 TSInfo, LParenOrBraceLoc, Args, RParenOrBraceLoc, ListInitialization);
3512 bool ListInitialization) {
3514 RParenLoc, ListInitialization);
3531 SS.
Adopt(QualifierLoc);
3534 OperatorLoc, IsArrow,
3536 FirstQualifierInScope,
3538 TemplateArgs,
nullptr);
3554 SS.
Adopt(QualifierLoc);
3557 OperatorLoc, IsArrow,
3559 FirstQualifierInScope,
3560 R, TemplateArgs,
nullptr);
3575 std::optional<unsigned> Length,
3578 RParenLoc, Length, PartialArgs);
3607 NamedConcept, TALI);
3625 LocalParameters, RParenLoc, Requirements,
3679 Expr **Elements,
unsigned NumElements) {
3689 getterMethod, setterMethod);
3722 Sel, Method, LBracLoc, SelectorLocs,
3737 Sel, Method, LBracLoc, SelectorLocs,
3753 Sel, Method, LBracLoc, SelectorLocs,
3758 Sel, Method, LBracLoc, SelectorLocs,
3770 bool IsArrow,
bool IsFreeIvar) {
3779 if (IsFreeIvar &&
Result.isUsable())
3780 cast<ObjCIvarRefExpr>(
Result.get())->setIsFreeIvar(IsFreeIvar);
3816 PropertyLoc,
Base));
3848 assert(!Lookup.
empty() &&
"No __builtin_shufflevector?");
3857 CK_BuiltinFnToFnPtr).
get();
3874 BuiltinLoc, RParenLoc);
3884 std::optional<unsigned> NumExpansions) {
3889 EllipsisLoc, NumExpansions);
3910 llvm_unreachable(
"Pack expansion pattern has no parameter packs");
3931 std::optional<unsigned> NumExpansions) {
3944 std::optional<unsigned> NumExpansions) {
3946 EllipsisLoc, RHS, RParenLoc,
3995 bool DeducibleTSTContext);
3998template <
typename Derived>
4003 switch (S->getStmtClass()) {
4008#define STMT(Node, Parent) \
4009 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
4010#define VALUESTMT(Node, Parent) \
4011 case Stmt::Node##Class: \
4012 return getDerived().Transform##Node(cast<Node>(S), SDK);
4013#define ABSTRACT_STMT(Node)
4014#define EXPR(Node, Parent)
4015#include "clang/AST/StmtNodes.inc"
4018#define STMT(Node, Parent)
4019#define ABSTRACT_STMT(Stmt)
4020#define EXPR(Node, Parent) case Stmt::Node##Class:
4021#include "clang/AST/StmtNodes.inc"
4023 ExprResult E = getDerived().TransformExpr(cast<Expr>(S));
4025 if (SDK == SDK_StmtExprResult)
4026 E = getSema().ActOnStmtExprResult(E);
4027 return getSema().ActOnExprStmt(E, SDK == SDK_Discarded);
4034template<
typename Derived>
4039 switch (S->getClauseKind()) {
4042#define GEN_CLANG_CLAUSE_CLASS
4043#define CLAUSE_CLASS(Enum, Str, Class) \
4045 return getDerived().Transform##Class(cast<Class>(S));
4046#include "llvm/Frontend/OpenMP/OMP.inc"
4053template<
typename Derived>
4060#define STMT(Node, Parent) case Stmt::Node##Class: break;
4061#define ABSTRACT_STMT(Stmt)
4062#define EXPR(Node, Parent) \
4063 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
4064#include "clang/AST/StmtNodes.inc"
4070template<
typename Derived>
4078 if (
auto *FE = dyn_cast<FullExpr>(
Init))
4079 Init = FE->getSubExpr();
4081 if (
auto *AIL = dyn_cast<ArrayInitLoopExpr>(
Init)) {
4087 Init = MTE->getSubExpr();
4090 Init = Binder->getSubExpr();
4093 Init = ICE->getSubExprAsWritten();
4096 dyn_cast<CXXStdInitializerListExpr>(
Init))
4097 return TransformInitializer(ILE->getSubExpr(), NotCopyInit);
4104 return getDerived().TransformExpr(
Init);
4109 return getDerived().RebuildParenListExpr(Parens.getBegin(), std::nullopt,
4114 if (isa<ImplicitValueInitExpr>(
Init))
4115 return getDerived().RebuildParenListExpr(
SourceLocation(), std::nullopt,
4120 if (!Construct || isa<CXXTemporaryObjectExpr>(Construct))
4121 return getDerived().TransformExpr(
Init);
4126 return TransformInitializer(Construct->
getArg(0), NotCopyInit);
4134 bool ArgChanged =
false;
4136 true, NewArgs, &ArgChanged))
4141 return getDerived().RebuildInitList(Construct->
getBeginLoc(), NewArgs,
4146 if (Parens.isInvalid()) {
4149 assert(NewArgs.empty() &&
4150 "no parens or braces but have direct init with arguments?");
4153 return getDerived().RebuildParenListExpr(Parens.getBegin(), NewArgs,
4157template<
typename Derived>
4163 for (
unsigned I = 0; I != NumInputs; ++I) {
4165 if (IsCall && getDerived().DropCallArgument(Inputs[I])) {
4173 Expr *Pattern = Expansion->getPattern();
4176 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
4177 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
4182 bool RetainExpansion =
false;
4183 std::optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions();
4184 std::optional<unsigned> NumExpansions = OrigNumExpansions;
4185 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
4188 Expand, RetainExpansion,
4197 ExprResult OutPattern = getDerived().TransformExpr(Pattern);
4201 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.
get(),
4202 Expansion->getEllipsisLoc(),
4204 if (Out.isInvalid())
4209 Outputs.push_back(Out.get());
4215 if (ArgChanged) *ArgChanged =
true;
4219 for (
unsigned I = 0; I != *NumExpansions; ++I) {
4221 ExprResult Out = getDerived().TransformExpr(Pattern);
4222 if (Out.isInvalid())
4225 if (Out.get()->containsUnexpandedParameterPack()) {
4226 Out = getDerived().RebuildPackExpansion(
4227 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
4228 if (Out.isInvalid())
4232 Outputs.push_back(Out.get());
4237 if (RetainExpansion) {
4238 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4240 ExprResult Out = getDerived().TransformExpr(Pattern);
4241 if (Out.isInvalid())
4244 Out = getDerived().RebuildPackExpansion(
4245 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
4246 if (Out.isInvalid())
4249 Outputs.push_back(Out.get());
4256 IsCall ? getDerived().TransformInitializer(Inputs[I],
false)
4257 : getDerived().TransformExpr(Inputs[I]);
4261 if (
Result.get() != Inputs[I] && ArgChanged)
4264 Outputs.push_back(
Result.get());
4270template <
typename Derived>
4274 VarDecl *ConditionVar = cast_or_null<VarDecl>(
4275 getDerived().TransformDefinition(Var->
getLocation(), Var));
4280 return getSema().ActOnConditionVariable(ConditionVar, Loc, Kind);
4289 return getSema().ActOnCondition(
nullptr, Loc, CondExpr.
get(), Kind,
4296template <
typename Derived>
4304 Qualifier = Qualifier.getPrefix())
4320 SS, FirstQualifierInScope,
false))
4327 cast_or_null<NamespaceDecl>(getDerived().TransformDecl(
4335 cast_or_null<NamespaceAliasDecl>(getDerived().TransformDecl(
4350 cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
4359 FirstQualifierInScope, SS);
4369 diag::warn_cxx98_compat_enum_nested_name_spec);
4372 SS.
Adopt(ETL.getQualifierLoc());
4373 TL = ETL.getNamedTypeLoc();
4391 FirstQualifierInScope =
nullptr;
4397 !getDerived().AlwaysRebuild())
4410template<
typename Derived>
4418 switch (Name.getNameKind()) {
4429 TemplateDecl *OldTemplate = Name.getCXXDeductionGuideTemplate();
4430 TemplateDecl *NewTemplate = cast_or_null<TemplateDecl>(
4431 getDerived().TransformDecl(NameInfo.
getLoc(), OldTemplate));
4447 NewTInfo = getDerived().TransformType(OldTInfo);
4455 QualType NewT = getDerived().TransformType(Name.getCXXNameType());
4471 llvm_unreachable(
"Unknown name kind.");
4474template<
typename Derived>
4481 bool AllowInjectedClassName) {
4483 TemplateDecl *Template = QTN->getUnderlyingTemplate().getAsTemplateDecl();
4484 assert(Template &&
"qualified template name must refer to a template");
4487 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
4492 if (!getDerived().AlwaysRebuild() &&
4494 TransTemplate == Template)
4497 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
4505 FirstQualifierInScope =
nullptr;
4508 if (!getDerived().AlwaysRebuild() &&
4516 if (DTN->isIdentifier()) {
4517 return getDerived().RebuildTemplateName(SS,
4519 *DTN->getIdentifier(),
4522 FirstQualifierInScope,
4523 AllowInjectedClassName);
4526 return getDerived().RebuildTemplateName(SS, TemplateKWLoc,
4527 DTN->getOperator(), NameLoc,
4528 ObjectType, AllowInjectedClassName);
4531 if (
TemplateDecl *Template = Name.getAsTemplateDecl()) {
4533 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
4538 if (!getDerived().AlwaysRebuild() &&
4539 TransTemplate == Template)
4546 = Name.getAsSubstTemplateTemplateParmPack()) {
4547 return getDerived().RebuildTemplateName(
4548 SubstPack->getArgumentPack(), SubstPack->getAssociatedDecl(),
4549 SubstPack->getIndex(), SubstPack->getFinal());
4553 llvm_unreachable(
"overloaded function decl survived to here");
4556template<
typename Derived>
4560 Output = getSema().getTrivialTemplateArgumentLoc(
4561 Arg,
QualType(), getDerived().getBaseLocation());
4564template <
typename Derived>
4572 llvm_unreachable(
"Unexpected TemplateArgument");
4581 QualType NewT = getDerived().TransformType(T);
4588 ValueDecl *NewD = D ? cast_or_null<ValueDecl>(getDerived().TransformDecl(
4589 getDerived().getBaseLocation(), D))
4594 if (NewT == T && D == NewD)
4615 DI = getDerived().TransformType(DI);
4626 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
4632 SS.
Adopt(QualifierLoc);
4633 TemplateName Template = getDerived().TransformTemplateName(
4644 llvm_unreachable(
"Caller should expand pack expansions");
4659 ExprResult E = getDerived().TransformExpr(InputExpr);
4674template<
typename Derived,
typename InputIterator>
4682 typedef typename std::iterator_traits<InputIterator>::difference_type
4722 return X.Iter == Y.Iter;
4727 return X.Iter != Y.Iter;