Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/TreeTransform_8h_source.html below:

clang: lib/Sema/TreeTransform.h Source File

llvm::omp;

<

Derived>

ForgetPartiallySubstitutedPackRAII {

ForgetPartiallySubstitutedPackRAII(Derived &Self)

: Self(Self), ResetPackSubstIndex(Self.getSema(), -1) {

Old = Self.ForgetPartiallySubstitutedPack();

~ForgetPartiallySubstitutedPackRAII() {

Self.RememberPartiallySubstitutedPack(Old);

Derived &

() {

Derived&

(*this); }

Derived&

(*this);

OldLocation = Self.getDerived().getBaseLocation();

OldEntity = Self.getDerived().getBaseEntity();

Self.getDerived().setBase(Location, Entity);

Self.getDerived().setBase(OldLocation, OldEntity);

->isDefaultArgument();

&ShouldExpand,

&RetainExpansion,

std::optional<unsigned> &NumExpansions) {

ShouldExpand =

;

*ArgChanged =

);

llvm::DenseMap<Decl *, Decl *>::iterator Known

Known->second;

assert(New.size() == 1 &&

);

*FirstQualifierInScope =

);

*FirstQualifierInScope =

,

AllowInjectedClassName =

);

Uneval =

);

Uneval =

) {

<

InputIterator>

Uneval =

);

SuppressObjCLifetime);

SuppressObjCLifetime);

<

Fn>

().TransformFunctionTypeParams(

, Params, ParamTypes, ParamInfos, PTypes, PVars, PInfos,

);

KWLoc, Params,

,

, PTypes, &TransParams, PInfos))

std::optional<unsigned> NumExpansions,

ExpectParameterPack);

IsAddressOfOperand,

IsAddressOfOperand);

llvm::APInt *Size,

*SizeExpr,

IndexTypeQuals,

BracketsRange);

llvm::APInt &Size,

*SizeExpr,

IndexTypeQuals,

IndexTypeQuals,

IndexTypeQuals,

IndexTypeQuals,

NumColumns);

*AddrSpaceExpr,

FullySubstituted,

TypeConstraintConcept,

TypeConstraintArgs);

Template, Deduced,

);

AllowInjectedClassName) {

SS.

(QualifierLoc);

SS, TemplateKWLoc, *Name, NameLoc,

(),

,

AllowInjectedClassName);

().RebuildTemplateSpecializationType(InstName, NameLoc, Args);

DeducedTSTContext) {

SS.

(QualifierLoc);

*

, IdLoc, DeducedTSTContext);

(

.getResultKind()) {

llvm_unreachable(

);

(

.getResultKind()) {

.

(IdLoc, diag::err_tag_reference_non_tag)

<< SomeDecl << NTK << llvm::to_underlying(Kind);

.

(IdLoc, diag::err_not_tag_in_scope)

<< llvm::to_underlying(Kind) <<

<< DC

.

(KeywordLoc, diag::err_use_with_wrong_tag) <<

;

.

(Tag->getLocation(), diag::note_previous_use);

std::optional<unsigned> NumExpansions) {

AllowInjectedClassName);

AllowInjectedClassName);

*AssociatedDecl,

Index,

ArgPack, AssociatedDecl, Index, Final);

Then, ElseLoc, Else);

Inc, RParenLoc, Body);

IsVolatile,

NumOutputs,

NumInputs, Names, Constraints, Exprs,

AsmString, Clobbers, NumLabels, RParenLoc);

StringRef AsmString,

NumOutputs,

NumInputs,

NumOutputs, NumInputs,

Constraints, Clobbers, Exprs, EndLoc);

CoawaitLoc, Operand, OpCoawaitLookup);

Suspend.

(),

);

Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);

Kind, DirName, Clauses, AStmt, StartLoc, EndLoc);

NameModifier,

, StartLoc, LParenLoc, NameModifierLoc, ColonLoc,

Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);

Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);

M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,

VarList, LPKind, LPKindLoc, ColonLoc, StartLoc, LParenLoc, EndLoc);

VarList, Modifier, StartLoc, LParenLoc, ModifierLoc, ColonLoc, EndLoc,

ReductionIdScopeSpec, ReductionId, UnresolvedReductions);

VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,

ReductionId, UnresolvedReductions);

VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,

ReductionId, UnresolvedReductions);

VarList, Step, StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc,

StepModifierLoc, EndLoc);

VarList, Alignment, StartLoc, LParenLoc, ColonLoc, EndLoc);

, DepModifier, VarList, StartLoc, LParenLoc, EndLoc);

Modifier,

, StartLoc, LParenLoc, ModifierLoc, EndLoc);

IteratorModifier, MapTypeModifiers, MapTypeModifiersLoc,

MapperIdScopeSpec, MapperId, MapType, IsMapTypeImplicit, MapLoc,

ColonLoc, VarList, Locs,

, UnresolvedMappers);

Allocate, Alignment, FirstModifier, FirstModifierLoc, SecondModifier,

SecondModifierLoc, VarList, StartLoc, LParenLoc, ColonLoc, EndLoc);

Modifier,

, StartLoc, LParenLoc, ModifierLoc, EndLoc);

Modifier, NumTasks, StartLoc, LParenLoc, ModifierLoc, EndLoc);

Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);

MotionModifiers, MotionModifiersLoc, MapperIdScopeSpec, MapperId,

ColonLoc, VarList, Locs, UnresolvedMappers);

MotionModifiers, MotionModifiersLoc, MapperIdScopeSpec, MapperId,

ColonLoc, VarList, Locs, UnresolvedMappers);

M, Kind, StartLoc, LParenLoc, MLoc, KindLoc, EndLoc);

StartLoc, LParenLoc, EndLoc,

);

StartLoc, LParenLoc, ColonLoc, EndLoc, Modifier, Locators);

Modifier, Kind, StartLoc, LParenLoc, ModifierKwLoc, KindKwLoc, EndLoc);

InteropVar, InteropInfo, StartLoc, LParenLoc, VarLoc, EndLoc);

LParenLoc, VarLoc, EndLoc);

InteropVar, StartLoc, LParenLoc, VarLoc, EndLoc);

DepType, DepLoc, ColonLoc, VarList, StartLoc, LParenLoc, EndLoc);

ForLoc, Element, Collection, RParenLoc);

StartLoc, IdLoc,

);

(RangeStmt->isSingleDecl()) {

(

*RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {

(RangeVar->isInvalidDecl())

*RangeExpr = RangeVar->getInit();

diag::err_objc_for_range_init_stmt)

<<

->getSourceRange();

ForLoc, LoopVar, RangeExpr, RParenLoc);

ForLoc, CoawaitLoc,

, ColonLoc,

,

, End, Cond, Inc,

QualifierLoc, NameInfo, Nested);

SS.

(QualifierLoc);

(

.isInvalid())

(IsOMPArraySection)

, LBracketLoc, LowerBound, ColonLocFirst, ColonLocSecond, Length,

Stride, RBracketLoc);

assert(Stride ==

&& !ColonLocSecond.

() &&

);

, LBracketLoc, LowerBound, ColonLocFirst, Length, RBracketLoc);

, LParenLoc, RParenLoc, Dims, BracketsRanges);

, IteratorKwLoc, LLoc, RLoc,

);

*ExecConfig =

) {

, Callee, LParenLoc, Args, RParenLoc, ExecConfig);

, Callee, LParenLoc, Args, RParenLoc);

(!

->getDeclName()) {

assert(

->getType()->isRecordType() &&

);

(!isArrow &&

->isPRValue()) {

, isArrow, OpLoc, EmptySS, cast<FieldDecl>(

),

SS.

(QualifierLoc);

(

->containsErrors())

(

().isUnevaluatedContext() &&

->isImplicitCXXThis() &&

isa<FieldDecl, IndirectFieldDecl, MSPropertyDecl>(

)) {

(

*ThisClass = cast<CXXThisExpr>(

)

->getAsCXXRecordDecl()) {

*

= cast<CXXRecordDecl>(

->getDeclContext());

(!ThisClass->Equals(

) && !ThisClass->isDerivedFrom(

))

FirstQualifierInScope,

R, ExplicitTemplateArgs,

(

.isInvalid())

*ControllingExpr,

ControllingExpr, Types, Exprs);

ControllingType, Types, Exprs);

Stmt::CXXStaticCastExprClass:

().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,

RAngleLoc, LParenLoc,

SubExpr, RParenLoc);

Stmt::CXXDynamicCastExprClass:

().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,

RAngleLoc, LParenLoc,

SubExpr, RParenLoc);

Stmt::CXXReinterpretCastExprClass:

().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,

RAngleLoc, LParenLoc,

Stmt::CXXConstCastExprClass:

().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,

RAngleLoc, LParenLoc,

SubExpr, RParenLoc);

Stmt::CXXAddrspaceCastExprClass:

().RebuildCXXAddrspaceCastExpr(

OpLoc, LAngleLoc, TInfo, RAngleLoc, LParenLoc, SubExpr, RParenLoc);

llvm_unreachable(

);

OpLoc, tok::kw_addrspace_cast, TInfo, SubExpr,

ListInitialization) {

(

*PLE = dyn_cast<ParenListExpr>(Sub))

TInfo, LParenLoc,

(PLE->getExprs(), PLE->getNumExprs()),

RParenLoc, ListInitialization);

ListInitialization);

(

().CheckCXXThisType(ThisLoc, ThisType))

IsThrownVariableInScope) {

*RewrittenExpr) {

RewrittenExpr,

().CurContext);

std::optional<Expr *> ArraySize,

IsGlobalDelete,

IsAddressOfOperand,

SS.

(QualifierLoc);

(TemplateArgs || TemplateKWLoc.

())

SS, TemplateKWLoc, NameInfo, TemplateArgs, IsAddressOfOperand);

SS, NameInfo, IsAddressOfOperand, RecoveryTSI);

IsElidable,

Args,

HadMultipleCandidates,

ListInitialization,

StdInitListInitialization,

(Constructor->isInheritingConstructor())

FoundCtor = Constructor->getInheritedConstructor().getConstructor();

(

().CompleteConstructorCall(FoundCtor,

, Args,

,

HadMultipleCandidates,

StdInitListInitialization,

RequiresZeroInit, ConstructKind,

ConstructsVBase,

InheritedFromVBase) {

,

, Constructor, ConstructsVBase, InheritedFromVBase);

ListInitialization) {

TSInfo, LParenOrBraceLoc, Args, RParenOrBraceLoc, ListInitialization);

ListInitialization) {

RParenLoc, ListInitialization);

SS.

(QualifierLoc);

OperatorLoc, IsArrow,

FirstQualifierInScope,

TemplateArgs,

);

SS.

(QualifierLoc);

OperatorLoc, IsArrow,

FirstQualifierInScope,

R, TemplateArgs,

);

std::optional<unsigned> Length,

RParenLoc, Length, PartialArgs);

*PackIdExpression,

*IndexExpr,

FullySubstituted =

) {

IndexExpr, RSquareLoc, ExpandedExprs,

NamedConcept, TALI);

(

.isInvalid())

LocalParameters, RParenLoc, Requirements,

**Elements,

NumElements) {

RB,

, Key, getterMethod, setterMethod);

ReceiverTypeInfo, ReceiverTypeInfo->

(),

Sel, Method, LBracLoc,

SelectorLocs, RBracLoc, Args);

, SuperType, SuperLoc, Sel, Method, LBracLoc,

SelectorLocs, RBracLoc, Args)

Sel, Method, LBracLoc,

SelectorLocs, RBracLoc, Args);

IsArrow,

IsFreeIvar) {

BaseArg, BaseArg->

(),

(IsFreeIvar &&

.isUsable())

cast<ObjCIvarRefExpr>(

.get())->setIsFreeIvar(IsFreeIvar);

PropertyLoc,

));

assert(!Lookup.

() &&

);

CK_BuiltinFnToFnPtr).

();

std::optional<unsigned> NumExpansions) {

EllipsisLoc, NumExpansions);

(

.isInvalid())

llvm_unreachable(

);

std::optional<unsigned> NumExpansions) {

std::optional<unsigned> NumExpansions) {

EllipsisLoc, RHS, RParenLoc,

->containsUnexpandedParameterPack();

(PVD->hasUninstantiatedDefaultArg())

PVD->getUninstantiatedDefaultArg()

->containsUnexpandedParameterPack();

Exprs.push_back(DevNumExpr);

Exprs.insert(Exprs.end(), QueueIdExprs.begin(), QueueIdExprs.end());

Exprs, RParenLoc, EndLoc, Clauses, {});

DeducibleTSTContext);

<

Derived>

(S->getStmtClass()) {

= getDerived().TransformExpr(cast<Expr>(S));

(SDK == SDK_StmtExprResult)

= getSema().ActOnStmtExprResult(

);

getSema().ActOnExprStmt(

, SDK == SDK_Discarded);

<

Derived>

(S->getClauseKind()) {

<

Derived>

<

Derived>

(

*FE = dyn_cast<FullExpr>(

))

= FE->getSubExpr();

(

*AIL = dyn_cast<ArrayInitLoopExpr>(

)) {

= MTE->getSubExpr();

= Binder->getSubExpr();

= ICE->getSubExprAsWritten();

dyn_cast<CXXStdInitializerListExpr>(

))

TransformInitializer(ILE->getSubExpr(), NotCopyInit);

getDerived().TransformExpr(

);

getDerived().RebuildParenListExpr(

.getBegin(), {},

(isa<ImplicitValueInitExpr>(

))

(!Construct || isa<CXXTemporaryObjectExpr>(Construct))

getDerived().TransformExpr(

);

TransformInitializer(Construct->

(0), NotCopyInit);

getSema().currentEvaluationContext().InLifetimeExtendingContext =

getSema().parentEvaluationContext().InLifetimeExtendingContext;

getSema().currentEvaluationContext().RebuildDefaultArgOrDefaultInit =

getSema().parentEvaluationContext().RebuildDefaultArgOrDefaultInit;

ArgChanged =

;

(getDerived().TransformExprs(Construct->

(), Construct->

(),

, NewArgs, &ArgChanged))

getDerived().RebuildInitList(Construct->

(), NewArgs,

(

.isInvalid()) {

assert(NewArgs.empty() &&

);

getDerived().RebuildParenListExpr(

.getBegin(), NewArgs,

<

Derived>

(

I = 0; I != NumInputs; ++I) {

(IsCall && getDerived().DropCallArgument(Inputs[I])) {

*ArgChanged =

;

*Pattern = Expansion->getPattern();

getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);

assert(!Unexpanded.empty() &&

);

Expand =

;

RetainExpansion =

;

std::optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions();

std::optional<unsigned> NumExpansions = OrigNumExpansions;

(getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),

Expand, RetainExpansion,

OutPattern = getDerived().TransformExpr(Pattern);

Out = getDerived().RebuildPackExpansion(OutPattern.

(),

Expansion->getEllipsisLoc(),

(Out.isInvalid())

*ArgChanged =

;

Outputs.push_back(Out.get());

(ArgChanged) *ArgChanged =

;

(

I = 0; I != *NumExpansions; ++I) {

Out = getDerived().TransformExpr(Pattern);

(Out.isInvalid())

(Out.get()->containsUnexpandedParameterPack()) {

Out = getDerived().RebuildPackExpansion(

Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);

(Out.isInvalid())

Outputs.push_back(Out.get());

(RetainExpansion) {

ForgetPartiallySubstitutedPackRAII Forget(getDerived());

Out = getDerived().TransformExpr(Pattern);

(Out.isInvalid())

Out = getDerived().RebuildPackExpansion(

Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);

(Out.isInvalid())

Outputs.push_back(Out.get());

IsCall ? getDerived().TransformInitializer(Inputs[I],

)

: getDerived().TransformExpr(Inputs[I]);

(

.isInvalid())

(

.get() != Inputs[I] && ArgChanged)

*ArgChanged =

;

Outputs.push_back(

.get());

<

Derived>

*ConditionVar = cast_or_null<VarDecl>(

getDerived().TransformDefinition(Var->

(), Var));

getSema().ActOnConditionVariable(ConditionVar,

, Kind);

getSema().ActOnCondition(

,

, CondExpr.

(), Kind,

<

Derived>

Qualifier = Qualifier.getPrefix())

SS, FirstQualifierInScope,

))

cast_or_null<NamespaceDecl>(getDerived().TransformDecl(

cast_or_null<NamespaceAliasDecl>(getDerived().TransformDecl(

cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(

FirstQualifierInScope, SS);

diag::warn_cxx98_compat_enum_nested_name_spec);

SS.

(ETL.getQualifierLoc());

TL = ETL.getNamedTypeLoc();

SemaRef.

(TL.

(), diag::err_nested_name_spec_non_tag)

FirstQualifierInScope =

;

!getDerived().AlwaysRebuild())

<

Derived>

(Name.getNameKind()) {

*OldTemplate = Name.getCXXDeductionGuideTemplate();

*NewTemplate = cast_or_null<TemplateDecl>(

getDerived().TransformDecl(NameInfo.

(), OldTemplate));

NewTInfo = getDerived().TransformType(OldTInfo);

NewTInfo =

;

NewT = getDerived().TransformType(Name.getCXXNameType());

NewNameInfo.

(NewName);

llvm_unreachable(

);

<

Derived>

AllowInjectedClassName) {

*Template = QTN->getUnderlyingTemplate().getAsTemplateDecl();

assert(Template &&

);

= cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,

(!getDerived().AlwaysRebuild() &&

TransTemplate == Template)

getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),

FirstQualifierInScope =

;

(!getDerived().AlwaysRebuild() &&

(DTN->isIdentifier()) {

getDerived().RebuildTemplateName(SS,

*DTN->getIdentifier(),

FirstQualifierInScope,

AllowInjectedClassName);

getDerived().RebuildTemplateName(SS, TemplateKWLoc,

DTN->getOperator(), NameLoc,

ObjectType, AllowInjectedClassName);

(

*Template = Name.getAsTemplateDecl()) {

= cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,

getDerived().RebuildTemplateName(SS,

,

= Name.getAsSubstTemplateTemplateParmPack()) {

getDerived().RebuildTemplateName(

SubstPack->getArgumentPack(), SubstPack->getAssociatedDecl(),

SubstPack->getIndex(), SubstPack->getFinal());

llvm_unreachable(

);

<

Derived>

Output = getSema().getTrivialTemplateArgumentLoc(

Arg,

(), getDerived().getBaseLocation());

<

Derived>

llvm_unreachable(

);

NewT = getDerived().TransformType(

);

*NewD =

? cast_or_null<ValueDecl>(getDerived().TransformDecl(

getDerived().getBaseLocation(),

))

(NewT ==

&&

== NewD)

llvm_unreachable(

);

DI = getDerived().TransformType(DI);

QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);

SS.

(QualifierLoc);

Template = getDerived().TransformTemplateName(

llvm_unreachable(

);

= getDerived().TransformExpr(InputExpr);

(

.isInvalid())

<

Derived,

InputIterator>

std::iterator_traits<InputIterator>::difference_type

Self.InventTemplateArgumentLoc(*

,

);

.Iter == Y.Iter;

.Iter != Y.Iter;

<

Derived>

<

InputIterator>

(TransformTemplateArguments(PackLocIterator(*

,

In.getArgument().pack_begin()),

PackLocIterator(*

,

In.getArgument().pack_end()),

(In.getArgument().isPackExpansion()) {

std::optional<unsigned> OrigNumExpansions;

= getSema().getTemplateArgumentPackExpansionPattern(

In, Ellipsis, OrigNumExpansions);

getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);

assert(!Unexpanded.empty() &&

);

Expand =

;

RetainExpansion =

;

std::optional<unsigned> NumExpansions = OrigNumExpansions;

(getDerived().TryExpandParameterPacks(Ellipsis,

(getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))

Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,

(Out.getArgument().isNull())

(

I = 0; I != *NumExpansions; ++I) {

(getDerived().TransformTemplateArgument(Pattern, Out, Uneval))

(Out.getArgument().containsUnexpandedParameterPack()) {

Out = getDerived().RebuildPackExpansion(Out, Ellipsis,

(Out.getArgument().isNull())

(RetainExpansion) {

ForgetPartiallySubstitutedPackRAII Forget(getDerived());

(getDerived().TransformTemplateArgument(Pattern, Out, Uneval))

Out = getDerived().RebuildPackExpansion(Out, Ellipsis,

(Out.getArgument().isNull())

(getDerived().TransformTemplateArgument(In, Out, Uneval))

<

Derived>

(getDerived().AlreadyTransformed(

))

getDerived().getBaseLocation());

<

Derived>

getDerived().getBaseEntity());

(getDerived().AlreadyTransformed(DI->

()))

<

Derived>

(

.getTypeLocClass()) {

llvm_unreachable(

);

<

Derived>

(!isa<DependentNameType>(

))

TransformType(

);

(getDerived().AlreadyTransformed(

))

getDerived().getBaseLocation());

*NewDI = getDerived().TransformTypeWithDeducedTST(DI);

<

Derived>

(!isa<DependentNameType>(DI->

()))

TransformType(DI);

getDerived().getBaseEntity());

(getDerived().AlreadyTransformed(DI->

()))

= getDerived().RebuildQualifiedType(

, QTL);

<

Derived>

UnqualTL =

.getUnqualifiedLoc();

SuppressObjCLifetime =

.getType().getLocalQualifiers().hasObjCLifetime();

= getDerived().TransformTemplateTypeParmType(TLB, TTP,

SuppressObjCLifetime);

}

(

STTP = UnqualTL.

<SubstTemplateTypeParmPackTypeLoc>()) {

= getDerived().TransformSubstTemplateTypeParmPackType(

TLB, STTP, SuppressObjCLifetime);

= getDerived().TransformType(TLB, UnqualTL);

<

Derived>

SemaRef.

(

, diag::err_address_space_mismatch_templ_inst)

(

.getObjCLifetime()) {

((AutoTy = dyn_cast<AutoType>(

)) && AutoTy->

()) {

SemaRef.

(

, diag::err_attr_objc_ownership_redundant) <<

;

<

Derived>

(getDerived().AlreadyTransformed(TL.

()))

TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);

<

Derived>

TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo,

QualType ObjectType,

NamedDecl *UnqualLookup,

(getDerived().AlreadyTransformed(TSInfo->getType()))

TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType,

<

Derived>

TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope(

TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup,

QualType

= TL.getType();

assert(!getDerived().AlreadyTransformed(

));

(isa<TemplateSpecializationType>(

)) {

TemplateSpecializationTypeLoc SpecTL =

TL.castAs<TemplateSpecializationTypeLoc>();

TemplateName Template = getDerived().TransformTemplateName(

SS, SpecTL.getTypePtr()->getTemplateName(), SpecTL.getTemplateNameLoc(),

ObjectType, UnqualLookup,

);

(Template.isNull())

= getDerived().TransformTemplateSpecializationType(TLB, SpecTL,

}

(isa<DependentTemplateSpecializationType>(

)) {

DependentTemplateSpecializationTypeLoc SpecTL =

TL.castAs<DependentTemplateSpecializationTypeLoc>();

TemplateName Template

= getDerived().RebuildTemplateName(SS,

SpecTL.getTemplateKeywordLoc(),

*SpecTL.getTypePtr()->getIdentifier(),

SpecTL.getTemplateNameLoc(),

ObjectType, UnqualLookup,

(Template.isNull())

= getDerived().TransformDependentTemplateSpecializationType(TLB,

= getDerived().TransformType(TLB, TL);

<

TyLoc>

TyLoc NewT = TLB.

<TyLoc>(

.getType());

NewT.setNameLoc(

.getNameLoc());

.getType();

<

Derived>

QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,

BuiltinTypeLoc

) {

BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(

.getType());

NewT.setBuiltinLoc(

.getBuiltinLoc());

(

.needsExtraLocalData())

NewT.getWrittenBuiltinSpecs() =

.getWrittenBuiltinSpecs();

.getType();

<

Derived>

QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,

ComplexTypeLoc

) {

<

Derived>

QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB,

AdjustedTypeLoc TL) {

getDerived().TransformType(TLB, TL.getOriginalLoc());

<

Derived>

QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB,

DecayedTypeLoc TL) {

QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc());

(OriginalType.isNull())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

OriginalType != TL.getOriginalLoc().getType())

TLB.push<DecayedTypeLoc>(

);

<

Derived>

TreeTransform<Derived>::TransformArrayParameterType(TypeLocBuilder &TLB,

ArrayParameterTypeLoc TL) {

QualType OriginalType = getDerived().TransformType(TLB, TL.getElementLoc());

(OriginalType.isNull())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

OriginalType != TL.getElementLoc().getType())

TLB.push<ArrayParameterTypeLoc>(

);

<

Derived>

QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,

PointerTypeLoc TL) {

QualType PointeeType

= getDerived().TransformType(TLB, TL.getPointeeLoc());

(PointeeType.isNull())

QualType

= TL.getType();

(PointeeType->getAs<ObjCObjectType>()) {

ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(

);

NewT.setStarLoc(TL.getStarLoc());

(getDerived().AlwaysRebuild() ||

PointeeType != TL.getPointeeLoc().getType()) {

= getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());

TLB.TypeWasModifiedSafely(

->getPointeeType());

PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(

);

NewT.setSigilLoc(TL.getSigilLoc());

<

Derived>

TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,

BlockPointerTypeLoc TL) {

QualType PointeeType

= getDerived().TransformType(TLB, TL.getPointeeLoc());

(PointeeType.isNull())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

PointeeType != TL.getPointeeLoc().getType()) {

= getDerived().RebuildBlockPointerType(PointeeType,

BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(

);

NewT.setSigilLoc(TL.getSigilLoc());

<

Derived>

(PointeeType.

())

(getDerived().AlwaysRebuild() ||

PointeeType !=

->getPointeeTypeAsWritten()) {

= getDerived().RebuildReferenceType(PointeeType,

->isSpelledAsLValue(),

(isa<LValueReferenceType>(

))

<

Derived>

TransformReferenceType(TLB, TL);

<

Derived>

TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,

RValueReferenceTypeLoc TL) {

TransformReferenceType(TLB, TL);

<

Derived>

TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,

MemberPointerTypeLoc TL) {

QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());

(PointeeType.isNull())

TypeSourceInfo* OldClsTInfo = TL.getClassTInfo();

TypeSourceInfo *NewClsTInfo =

;

NewClsTInfo = getDerived().TransformType(OldClsTInfo);

MemberPointerType *

= TL.getTypePtr();

QualType OldClsType = QualType(

->getClass(), 0);

QualType NewClsType;

NewClsType = NewClsTInfo->getType();

NewClsType = getDerived().TransformType(OldClsType);

(NewClsType.isNull())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

NewClsType != OldClsType) {

= getDerived().RebuildMemberPointerType(PointeeType, NewClsType,

MemberPointerType *MPT =

->getAs<MemberPointerType>();

(MPT && PointeeType != MPT->getPointeeType()) {

assert(isa<AdjustedType>(MPT->getPointeeType()));

TLB.push<AdjustedTypeLoc>(MPT->getPointeeType());

MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(

);

NewTL.setSigilLoc(TL.getSigilLoc());

NewTL.setClassTInfo(NewClsTInfo);

<

Derived>

TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,

ConstantArrayTypeLoc TL) {

ConstantArrayType *

= TL.getTypePtr();

QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());

(ElementType.isNull())

Expr *

= TL.getSizeExpr();

=

Expr*

(

->getSizeExpr());

Expr *NewSize =

;

NewSize = getDerived().TransformExpr(

).template getAs<Expr>();

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

ElementType !=

->getElementType() ||

(

->getSizeExpr() && NewSize !=

)) {

= getDerived().RebuildConstantArrayType(ElementType,

->getSizeModifier(),

->getSize(), NewSize,

->getIndexTypeCVRQualifiers(),

TL.getBracketsRange());

ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(

);

NewTL.setLBracketLoc(TL.getLBracketLoc());

NewTL.setRBracketLoc(TL.getRBracketLoc());

NewTL.setSizeExpr(NewSize);

<

Derived>

QualType TreeTransform<Derived>::TransformIncompleteArrayType(

TypeLocBuilder &TLB,

IncompleteArrayTypeLoc TL) {

IncompleteArrayType *

= TL.getTypePtr();

QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());

(ElementType.isNull())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

ElementType !=

->getElementType()) {

= getDerived().RebuildIncompleteArrayType(ElementType,

->getSizeModifier(),

->getIndexTypeCVRQualifiers(),

TL.getBracketsRange());

IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(

);

NewTL.setLBracketLoc(TL.getLBracketLoc());

NewTL.setRBracketLoc(TL.getRBracketLoc());

NewTL.setSizeExpr(

);

<

Derived>

TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,

VariableArrayTypeLoc TL) {

VariableArrayType *

= TL.getTypePtr();

QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());

(ElementType.isNull())

EnterExpressionEvaluationContext Context(

SizeResult = getDerived().TransformExpr(

->getSizeExpr());

(SizeResult.isInvalid())

(SizeResult.isInvalid())

Expr *

= SizeResult.get();

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

ElementType !=

->getElementType() ||

Size !=

->getSizeExpr()) {

= getDerived().RebuildVariableArrayType(ElementType,

->getSizeModifier(),

->getIndexTypeCVRQualifiers(),

TL.getBracketsRange());

ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(

);

NewTL.setLBracketLoc(TL.getLBracketLoc());

NewTL.setRBracketLoc(TL.getRBracketLoc());

NewTL.setSizeExpr(Size);

<

Derived>

TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,

DependentSizedArrayTypeLoc TL) {

DependentSizedArrayType *

= TL.getTypePtr();

QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());

(ElementType.isNull())

SemaRef.

.back().InConditionallyConstantEvaluateContext =

;

Expr *origSize = TL.getSizeExpr();

(!origSize) origSize =

->getSizeExpr();

= getDerived().TransformExpr(origSize);

(sizeResult.isInvalid())

Expr *size = sizeResult.get();

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

ElementType !=

->getElementType() ||

= getDerived().RebuildDependentSizedArrayType(ElementType,

->getSizeModifier(),

->getIndexTypeCVRQualifiers(),

TL.getBracketsRange());

ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(

);

NewTL.setLBracketLoc(TL.getLBracketLoc());

NewTL.setRBracketLoc(TL.getRBracketLoc());

NewTL.setSizeExpr(size);

<

Derived>

QualType TreeTransform<Derived>::TransformDependentVectorType(

TypeLocBuilder &TLB, DependentVectorTypeLoc TL) {

DependentVectorType *

= TL.getTypePtr();

QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());

(ElementType.isNull())

(

.isInvalid())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() || ElementType !=

->getElementType() ||

.get() !=

->getSizeExpr()) {

= getDerived().RebuildDependentVectorType(

ElementType,

.get(),

->getAttributeLoc(),

->getVectorKind());

(isa<DependentVectorType>(

)) {

DependentVectorTypeLoc NewTL =

TLB.push<DependentVectorTypeLoc>(

);

NewTL.setNameLoc(TL.getNameLoc());

VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(

);

NewTL.setNameLoc(TL.getNameLoc());

<

Derived>

QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(

TypeLocBuilder &TLB,

DependentSizedExtVectorTypeLoc TL) {

DependentSizedExtVectorType *

= TL.getTypePtr();

QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());

(ElementType.isNull())

(

.isInvalid())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

ElementType !=

->getElementType() ||

.get() !=

->getSizeExpr()) {

= getDerived().RebuildDependentSizedExtVectorType(ElementType,

->getAttributeLoc());

(isa<DependentSizedExtVectorType>(

)) {

DependentSizedExtVectorTypeLoc NewTL

= TLB.push<DependentSizedExtVectorTypeLoc>(

);

NewTL.setNameLoc(TL.getNameLoc());

ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(

);

NewTL.setNameLoc(TL.getNameLoc());

<

Derived>

TreeTransform<Derived>::TransformConstantMatrixType(TypeLocBuilder &TLB,

ConstantMatrixTypeLoc TL) {

ConstantMatrixType *

= TL.getTypePtr();

QualType ElementType = getDerived().TransformType(

->getElementType());

(ElementType.isNull())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() || ElementType !=

->getElementType()) {

= getDerived().RebuildConstantMatrixType(

ElementType,

->getNumRows(),

->getNumColumns());

ConstantMatrixTypeLoc NewTL = TLB.push<ConstantMatrixTypeLoc>(

);

NewTL.setAttrNameLoc(TL.getAttrNameLoc());

NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());

NewTL.setAttrRowOperand(TL.getAttrRowOperand());

NewTL.setAttrColumnOperand(TL.getAttrColumnOperand());

<

Derived>

QualType TreeTransform<Derived>::TransformDependentSizedMatrixType(

TypeLocBuilder &TLB, DependentSizedMatrixTypeLoc TL) {

DependentSizedMatrixType *

= TL.getTypePtr();

QualType ElementType = getDerived().TransformType(

->getElementType());

(ElementType.isNull()) {

Expr *origRows = TL.getAttrRowOperand();

origRows =

->getRowExpr();

Expr *origColumns = TL.getAttrColumnOperand();

origColumns =

->getColumnExpr();

rowResult = getDerived().TransformExpr(origRows);

(rowResult.isInvalid())

columnResult = getDerived().TransformExpr(origColumns);

(columnResult.isInvalid())

Expr *rows = rowResult.get();

Expr *columns = columnResult.get();

QualType

= TL.getType();

(getDerived().AlwaysRebuild() || ElementType !=

->getElementType() ||

rows != origRows || columns != origColumns) {

= getDerived().RebuildDependentSizedMatrixType(

ElementType, rows, columns,

->getAttributeLoc());

MatrixTypeLoc NewTL = TLB.push<MatrixTypeLoc>(

);

NewTL.setAttrNameLoc(TL.getAttrNameLoc());

NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());

NewTL.setAttrRowOperand(rows);

NewTL.setAttrColumnOperand(columns);

<

Derived>

QualType TreeTransform<Derived>::TransformDependentAddressSpaceType(

TypeLocBuilder &TLB, DependentAddressSpaceTypeLoc TL) {

DependentAddressSpaceType *

= TL.getTypePtr();

QualType pointeeType =

getDerived().TransformType(TLB, TL.getPointeeTypeLoc());

(pointeeType.isNull())

AddrSpace = getDerived().TransformExpr(

->getAddrSpaceExpr());

(AddrSpace.isInvalid())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() || pointeeType !=

->

() ||

AddrSpace.get() !=

->getAddrSpaceExpr()) {

= getDerived().RebuildDependentAddressSpaceType(

pointeeType, AddrSpace.get(),

->getAttributeLoc());

(isa<DependentAddressSpaceType>(

)) {

DependentAddressSpaceTypeLoc NewTL =

TLB.push<DependentAddressSpaceTypeLoc>(

);

NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());

NewTL.setAttrExprOperand(TL.getAttrExprOperand());

NewTL.setAttrNameLoc(TL.getAttrNameLoc());

TLB.TypeWasModifiedSafely(

);

<

Derived>

QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,

VectorType *

= TL.getTypePtr();

QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());

(ElementType.isNull())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

ElementType !=

->getElementType()) {

= getDerived().RebuildVectorType(ElementType,

->getNumElements(),

->getVectorKind());

VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(

);

NewTL.setNameLoc(TL.getNameLoc());

<

Derived>

QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,

ExtVectorTypeLoc TL) {

VectorType *

= TL.getTypePtr();

QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());

(ElementType.isNull())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

ElementType !=

->getElementType()) {

= getDerived().RebuildExtVectorType(ElementType,

->getNumElements(),

ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(

);

NewTL.setNameLoc(TL.getNameLoc());

<

Derived>

std::optional<unsigned> NumExpansions,

ExpectParameterPack) {

(NumExpansions && isa<PackExpansionType>(OldDI->

())) {

NewDI = getDerived().TransformType(OldDI);

(NewDI == OldDI && indexAdjustment == 0)

transformedLocalDecl(OldParm, {newParm});

<

Derived>

*LastParamTransformed) {

indexAdjustment = 0;

NumParams = Params.size();

(

i = 0; i != NumParams; ++i) {

(LastParamTransformed)

*LastParamTransformed = i;

assert(OldParm->getFunctionScopeIndex() == i);

std::optional<unsigned> NumExpansions;

(OldParm->isParameterPack()) {

TL = OldParm->getTypeSourceInfo()->getTypeLoc();

ShouldExpand =

;

RetainExpansion =

;

std::optional<unsigned> OrigNumExpansions;

(Unexpanded.size() > 0) {

NumExpansions = OrigNumExpansions;

(getDerived().TryExpandParameterPacks(ExpansionTL.

(),

Pattern.getSourceRange(),

);

getDerived().ExpandingFunctionParameterPack(OldParm);

(

I = 0; I != *NumExpansions; ++I) {

= getDerived().TransformFunctionTypeParam(OldParm,

PInfos.

(OutParamTypes.size(), ParamInfos[i]);

OutParamTypes.push_back(NewParm->

());

PVars->push_back(NewParm);

(RetainExpansion) {

ForgetPartiallySubstitutedPackRAII Forget(getDerived());

= getDerived().TransformFunctionTypeParam(OldParm,

PInfos.

(OutParamTypes.size(), ParamInfos[i]);

OutParamTypes.push_back(NewParm->

());

PVars->push_back(NewParm);

NewParm = getDerived().TransformFunctionTypeParam(OldParm,

);

NewParm = getDerived().TransformFunctionTypeParam(

OldParm, indexAdjustment, std::nullopt,

PInfos.

(OutParamTypes.size(), ParamInfos[i]);

OutParamTypes.push_back(NewParm->

());

PVars->push_back(NewParm);

IsPackExpansion =

;

std::optional<unsigned> NumExpansions;

= dyn_cast<PackExpansionType>(OldType)) {

Pattern = Expansion->getPattern();

getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);

ShouldExpand =

;

RetainExpansion =

;

(

I = 0; I != *NumExpansions; ++I) {

NewType = getDerived().TransformType(Pattern);

NewType = getSema().getASTContext().getPackExpansionType(

NewType, std::nullopt);

PInfos.

(OutParamTypes.size(), ParamInfos[i]);

OutParamTypes.push_back(NewType);

PVars->push_back(

);

(RetainExpansion) {

ForgetPartiallySubstitutedPackRAII Forget(getDerived());

NewType = getDerived().TransformType(Pattern);

PInfos.

(OutParamTypes.size(), ParamInfos[i]);

OutParamTypes.push_back(NewType);

PVars->push_back(

);

OldType = Expansion->getPattern();

IsPackExpansion =

;

NewType = getDerived().TransformType(OldType);

NewType = getDerived().TransformType(OldType);

(IsPackExpansion)

NewType = getSema().Context.getPackExpansionType(NewType,

PInfos.

(OutParamTypes.size(), ParamInfos[i]);

OutParamTypes.push_back(NewType);

PVars->push_back(

);

(

i = 0, e = PVars->size(); i != e; ++i)

assert(parm->getFunctionScopeIndex() == i);

<

Derived>

getDerived().TransformFunctionProtoType(

getDerived().TransformExceptionSpec(TL.

(), ESI,

ExceptionStorage, Changed);

<

Derived>

<

Fn>

ThisTypeQuals, Fn TransformExceptionSpec) {

(getDerived().TransformFunctionTypeParams(

ParamTypes, &ParamDecls, ExtParamInfos))

SemaRef, !ThisContext && RD ? RD : ThisContext, ThisTypeQuals);

ResultType = getDerived().TransformType(TLB, TL.

());

(ResultType.

())

ResultType = getDerived().TransformType(TLB, TL.

());

(ResultType.

())

(getDerived().TransformFunctionTypeParams(

ParamTypes, &ParamDecls, ExtParamInfos))

EPIChanged =

;

(TransformExceptionSpec(EPI.

, EPIChanged))

(

NewExtParamInfos =

std::optional<FunctionEffectSet> NewFX;

NewExpr = getDerived().TransformExpr(CondExpr);

std::optional<FunctionEffectMode> Mode =

);

NewFX->insert(NewEC, Errs);

assert(Errs.empty());

(getDerived().AlwaysRebuild() || ResultType !=

->

() ||

= getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI);

(

i = 0, e = NewTL.

(); i != e; ++i)

NewTL.

(i, ParamDecls[i]);

<

Derived>

*Method = dyn_cast_if_present<CXXMethodDecl>(ESI.

);

SemaRef, Method ? Method->getParent() :

,

Method ? Method->getMethodQualifiers() :

{},

Method !=

);

getSema().ActOnNoexceptSpec(NoexceptExpr.

(), EST);

assert(!Unexpanded.empty() &&

);

Expand =

;

RetainExpansion =

;

std::optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();

(getDerived().TryExpandParameterPacks(

RetainExpansion, NumExpansions))

= getDerived().TransformType(PackExpansion->getPattern());

Exceptions.push_back(

);

(

ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {

= getDerived().TransformType(PackExpansion->getPattern());

Exceptions.push_back(

);

= getDerived().TransformType(

);

Exceptions.push_back(

);

<

Derived>

(ResultType.

())

(getDerived().AlwaysRebuild() || ResultType !=

->

())

= getDerived().RebuildFunctionNoProtoType(ResultType);

<

Derived>

QualType TreeTransform<Derived>::TransformUnresolvedUsingType(

TypeLocBuilder &TLB, UnresolvedUsingTypeLoc TL) {

UnresolvedUsingType *

= TL.getTypePtr();

Decl *

= getDerived().TransformDecl(TL.getNameLoc(),

->getDecl());

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

!=

->getDecl()) {

= getDerived().RebuildUnresolvedUsingType(TL.getNameLoc(),

);

TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(

);

NewTL.setNameLoc(TL.getNameLoc());

<

Derived>

QualType TreeTransform<Derived>::TransformUsingType(TypeLocBuilder &TLB,

UsingType *

= TL.getTypePtr();

*

= cast_or_null<UsingShadowDecl>(getDerived().TransformDecl(

TL.getLocalSourceRange().getBegin(),

->getFoundDecl()));

QualType Underlying = getDerived().TransformType(

->

());

(Underlying.isNull())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

!=

->getFoundDecl() ||

Underlying !=

->getUnderlyingType()) {

= getDerived().RebuildUsingType(

, Underlying);

TLB.pushTypeSpec(

).setNameLoc(TL.getNameLoc());

<

Derived>

QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,

TypedefTypeLoc TL) {

TypedefType *

= TL.getTypePtr();

TypedefNameDecl *Typedef

= cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(),

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

Typedef !=

->getDecl()) {

= getDerived().RebuildTypedefType(Typedef);

TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(

);

NewTL.setNameLoc(TL.getNameLoc());

<

Derived>

QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,

TypeOfExprTypeLoc TL) {

= getDerived().TransformExpr(TL.getUnderlyingExpr());

(

.isInvalid())

(

.isInvalid())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

.get() != TL.getUnderlyingExpr()) {

getDerived().RebuildTypeOfExprType(

.get(), TL.getTypeofLoc(), Kind);

TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(

);

NewTL.setTypeofLoc(TL.getTypeofLoc());

NewTL.setLParenLoc(TL.getLParenLoc());

NewTL.setRParenLoc(TL.getRParenLoc());

<

Derived>

QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,

TypeSourceInfo* Old_Under_TI = TL.getUnmodifiedTInfo();

TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);

QualType

= TL.getType();

(getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {

= getDerived().RebuildTypeOfType(New_Under_TI->getType(), Kind);

TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(

);

NewTL.setTypeofLoc(TL.getTypeofLoc());

NewTL.setLParenLoc(TL.getLParenLoc());

NewTL.setRParenLoc(TL.getRParenLoc());

NewTL.setUnmodifiedTInfo(New_Under_TI);

<

Derived>

QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,

DecltypeTypeLoc TL) {

DecltypeType *

= TL.getTypePtr();

= getDerived().TransformExpr(

->getUnderlyingExpr());

(

.isInvalid())

= getSema().ActOnDecltypeExpression(

.get());

(

.isInvalid())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

.get() !=

->getUnderlyingExpr()) {

= getDerived().RebuildDecltypeType(

.get(), TL.getDecltypeLoc());

DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(

);

NewTL.setDecltypeLoc(TL.getDecltypeLoc());

NewTL.setRParenLoc(TL.getRParenLoc());

<

Derived>

TreeTransform<Derived>::TransformPackIndexingType(TypeLocBuilder &TLB,

PackIndexingTypeLoc TL) {

EnterExpressionEvaluationContext ConstantContext(

IndexExpr = getDerived().TransformExpr(TL.getIndexExpr());

(IndexExpr.isInvalid())

QualType Pattern = TL.getPattern();

PackIndexingType *PIT = TL.getTypePtr();

NotYetExpanded = Types.empty();

FullySubstituted =

;

(Types.empty() && !PIT->expandsToEmptyPack())

(QualType

: Types) {

QualType Transformed = getDerived().TransformType(

);

(Transformed.isNull())

SubtitutedTypes.push_back(Transformed);

getSema().collectUnexpandedParameterPacks(

, Unexpanded);

assert(!Unexpanded.empty() &&

);

ShouldExpand =

;

RetainExpansion =

;

std::optional<unsigned> OrigNumExpansions;

std::optional<unsigned> NumExpansions = OrigNumExpansions;

(getDerived().TryExpandParameterPacks(TL.getEllipsisLoc(), SourceRange(),

Unexpanded, ShouldExpand,

RetainExpansion, NumExpansions))

(!ShouldExpand) {

Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);

TypeSourceInfo *TI =

QualType Pack = getDerived().TransformType(TLB, TI->getTypeLoc());

(NotYetExpanded) {

FullySubstituted =

;

QualType Out = getDerived().RebuildPackIndexingType(

Pack, IndexExpr.get(), SourceLocation(), TL.getEllipsisLoc(),

PackIndexingTypeLoc

= TLB.push<PackIndexingTypeLoc>(Out);

.setEllipsisLoc(TL.getEllipsisLoc());

SubtitutedTypes.push_back(Pack);

(

I = 0; I != *NumExpansions; ++I) {

Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);

QualType Out = getDerived().TransformType(

);

SubtitutedTypes.push_back(Out);

FullySubstituted &= !Out->containsUnexpandedParameterPack();

(RetainExpansion) {

FullySubstituted =

;

ForgetPartiallySubstitutedPackRAII Forget(getDerived());

QualType Out = getDerived().TransformType(

);

SubtitutedTypes.push_back(Out);

Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);

QualType

= getDerived().TransformType(TLB, TL.getPatternLoc());

QualType Out = getDerived().RebuildPackIndexingType(

, IndexExpr.get(), SourceLocation(), TL.getEllipsisLoc(),

FullySubstituted, SubtitutedTypes);

PackIndexingTypeLoc

= TLB.push<PackIndexingTypeLoc>(Out);

.setEllipsisLoc(TL.getEllipsisLoc());

<

Derived>

QualType TreeTransform<Derived>::TransformUnaryTransformType(

TypeLocBuilder &TLB,

UnaryTransformTypeLoc TL) {

QualType

= TL.getType();

(

->isDependentType()) {

UnaryTransformType *

= TL.getTypePtr();

TypeSourceInfo *NewBaseTSI =

getDerived().TransformType(TL.getUnderlyingTInfo());

QualType NewBase = NewBaseTSI->getType();

= getDerived().RebuildUnaryTransformType(NewBase,

UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(

);

NewTL.setKWLoc(TL.getKWLoc());

NewTL.setParensRange(TL.getParensRange());

NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo());

<

Derived>

QualType TreeTransform<Derived>::TransformDeducedTemplateSpecializationType(

TypeLocBuilder &TLB, DeducedTemplateSpecializationTypeLoc TL) {

DeducedTemplateSpecializationType *

= TL.getTypePtr();

TemplateName TemplateName = getDerived().TransformTemplateName(

SS,

->getTemplateName(), TL.getTemplateNameLoc());

(TemplateName.isNull())

QualType OldDeduced =

->getDeducedType();

QualType NewDeduced;

(!OldDeduced.isNull()) {

NewDeduced = getDerived().TransformType(OldDeduced);

(NewDeduced.isNull())

QualType

= getDerived().RebuildDeducedTemplateSpecializationType(

TemplateName, NewDeduced);

DeducedTemplateSpecializationTypeLoc NewTL =

TLB.push<DeducedTemplateSpecializationTypeLoc>(

);

NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());

<

Derived>

QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,

RecordType *

= TL.getTypePtr();

= cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(),

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(

);

NewTL.setNameLoc(TL.getNameLoc());

<

Derived>

QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,

EnumType *

= TL.getTypePtr();

= cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(),

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

!=

->getDecl()) {

= getDerived().RebuildEnumType(

);

EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(

);

NewTL.setNameLoc(TL.getNameLoc());

<

Derived>

QualType TreeTransform<Derived>::TransformInjectedClassNameType(

TypeLocBuilder &TLB,

InjectedClassNameTypeLoc TL) {

*

= getDerived().TransformDecl(TL.getNameLoc(),

TL.getTypePtr()->getDecl());

(!

)

QualType();

TLB.pushTypeSpec(

).setNameLoc(TL.getNameLoc());

<

Derived>

getDerived().TransformTemplateTypeParmType(

<

Derived>

<

Derived>

QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(

TypeLocBuilder &TLB,

SubstTemplateTypeParmTypeLoc TL) {

SubstTemplateTypeParmType *

= TL.getTypePtr();

getDerived().TransformDecl(TL.getNameLoc(),

->getAssociatedDecl());

TemporaryBase Rebase(*

, TL.getNameLoc(), DeclarationName());

QualType Replacement = getDerived().TransformType(

->getReplacementType());

(Replacement.isNull())

Replacement, NewReplaced,

->getIndex(),

->getPackIndex());

SubstTemplateTypeParmTypeLoc NewTL

= TLB.push<SubstTemplateTypeParmTypeLoc>(

);

NewTL.setNameLoc(TL.getNameLoc());

<

Derived>

getDerived().TransformSubstTemplateTypeParmPackType(

<

Derived>

<

Derived>

= getDerived().TransformTemplateName(SS,

->getTemplateName(),

getDerived().TransformTemplateSpecializationType(TLB, TL, Template);

<

Derived>

(ValueType.

())

(getDerived().AlwaysRebuild() ||

= getDerived().RebuildAtomicType(ValueType, TL.

());

AtomicTypeLoc NewTL = TLB.

<AtomicTypeLoc>(

);

<

Derived>

QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB,

QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());

(ValueType.isNull())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() || ValueType != TL.getValueLoc().getType()) {

PipeType *PT =

->castAs<PipeType>();

isReadPipe = PT->isReadOnly();

= getDerived().RebuildPipeType(ValueType, TL.getKWLoc(), isReadPipe);

PipeTypeLoc NewTL = TLB.push<PipeTypeLoc>(

);

NewTL.setKWLoc(TL.getKWLoc());

<

Derived>

QualType TreeTransform<Derived>::TransformBitIntType(TypeLocBuilder &TLB,

BitIntType *EIT = TL.getTypePtr();

QualType

= TL.getType();

(getDerived().AlwaysRebuild()) {

= getDerived().RebuildBitIntType(EIT->isUnsigned(),

EIT->getNumBits(), TL.getNameLoc());

BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(

);

NewTL.setNameLoc(TL.getNameLoc());

<

Derived>

QualType TreeTransform<Derived>::TransformDependentBitIntType(

TypeLocBuilder &TLB, DependentBitIntTypeLoc TL) {

DependentBitIntType *EIT = TL.getTypePtr();

BitsExpr = getDerived().TransformExpr(EIT->getNumBitsExpr());

(BitsExpr.isInvalid())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() || BitsExpr.get() != EIT->getNumBitsExpr()) {

= getDerived().RebuildDependentBitIntType(

EIT->isUnsigned(), BitsExpr.get(), TL.getNameLoc());

(isa<DependentBitIntType>(

)) {

DependentBitIntTypeLoc NewTL = TLB.push<DependentBitIntTypeLoc>(

);

NewTL.setNameLoc(TL.getNameLoc());

BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(

);

NewTL.setNameLoc(TL.getNameLoc());

<

ArgLocContainer>

ArgLocContainer *Container;

: Container(&Container), Index(Index) { }

Container->getArgLoc(Index);

(Container->getArgLoc(Index));

.Container == Y.Container &&

.Index == Y.Index;

<

Derived>

QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,

AutoType *

= TL.getTypePtr();

QualType OldDeduced =

->getDeducedType();

QualType NewDeduced;

(!OldDeduced.isNull()) {

NewDeduced = getDerived().TransformType(OldDeduced);

(NewDeduced.isNull())

ConceptDecl *NewCD =

;

TemplateArgumentListInfo NewTemplateArgs;

NestedNameSpecifierLoc NewNestedNameSpec;

(

->isConstrained()) {

assert(TL.getConceptReference());

NewCD = cast_or_null<ConceptDecl>(getDerived().TransformDecl(

TL.getConceptNameLoc(),

->getTypeConstraintConcept()));

NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());

NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());

TemplateArgumentLocContainerIterator<AutoTypeLoc> ArgIterator;

(getDerived().TransformTemplateArguments(

ArgIterator(TL, 0), ArgIterator(TL, TL.getNumArgs()),

(TL.getNestedNameSpecifierLoc()) {

= getDerived().TransformNestedNameSpecifierLoc(

TL.getNestedNameSpecifierLoc());

(!NewNestedNameSpec)

QualType

= TL.getType();

(getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||

NewArgList.reserve(NewTemplateArgs.size());

(

&ArgLoc : NewTemplateArgs.arguments())

NewArgList.push_back(ArgLoc.getArgument());

= getDerived().RebuildAutoType(NewDeduced,

->getKeyword(), NewCD,

AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(

);

NewTL.setNameLoc(TL.getNameLoc());

NewTL.setRParenLoc(TL.getRParenLoc());

NewTL.setConceptReference(

);

(

->isConstrained()) {

DeclarationNameInfo DNI = DeclarationNameInfo(

TL.getTypePtr()->getTypeConstraintConcept()->getDeclName(),

TL.getConceptNameLoc(),

TL.getTypePtr()->getTypeConstraintConcept()->getDeclName());

SemaRef.

, NewNestedNameSpec, TL.getTemplateKWLoc(), DNI,

TL.getFoundDecl(), TL.getTypePtr()->getTypeConstraintConcept(),

NewTL.setConceptReference(CR);

<

Derived>

TypeLocBuilder &TLB,

TemplateSpecializationTypeLoc TL,

TemplateName Template) {

TemplateArgumentListInfo NewTemplateArgs;

NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());

NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());

TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>

(getDerived().TransformTemplateArguments(ArgIterator(TL, 0),

ArgIterator(TL, TL.getNumArgs()),

getDerived().RebuildTemplateSpecializationType(Template,

TL.getTemplateNameLoc(),

(!

.isNull()) {

(isa<DependentTemplateSpecializationType>(

)) {

DependentTemplateSpecializationTypeLoc NewTL

= TLB.push<DependentTemplateSpecializationTypeLoc>(

);

NewTL.setElaboratedKeywordLoc(SourceLocation());

NewTL.setQualifierLoc(NestedNameSpecifierLoc());

NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());

NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());

NewTL.setLAngleLoc(TL.getLAngleLoc());

NewTL.setRAngleLoc(TL.getRAngleLoc());

(

i = 0, e = NewTemplateArgs.size(); i != e; ++i)

NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());

TemplateSpecializationTypeLoc NewTL

= TLB.push<TemplateSpecializationTypeLoc>(

);

NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());

NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());

NewTL.setLAngleLoc(TL.getLAngleLoc());

NewTL.setRAngleLoc(TL.getRAngleLoc());

(

i = 0, e = NewTemplateArgs.size(); i != e; ++i)

NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());

<

Derived>

(getDerived().TransformTemplateArguments(ArgIterator(TL, 0),

= getSema().Context.getDependentTemplateSpecializationType(

DTN->getIdentifier(), NewTemplateArgs.

());

(

i = 0, e = NewTemplateArgs.

(); i != e; ++i)

= getDerived().RebuildTemplateSpecializationType(Template,

(!

.isNull()) {

(

i = 0, e = NewTemplateArgs.

(); i != e; ++i)

<

Derived>

= getDerived().TransformNestedNameSpecifierLoc(TL.

());

QualType NamedT = getDerived().TransformType(TLB, TL.

());

(NamedT.isNull())

(

TemplateSpecializationType *TST =

NamedT->getAs<TemplateSpecializationType>()) {

TemplateName Template = TST->getTemplateName();

(TypeAliasTemplateDecl *TAT = dyn_cast_or_null<TypeAliasTemplateDecl>(

Template.getAsTemplateDecl())) {

diag::err_tag_reference_non_tag)

<< llvm::to_underlying(

SemaRef.

(TAT->getLocation(), diag::note_declared_at);

(getDerived().AlwaysRebuild() ||

NamedT !=

->getNamedType()) {

QualifierLoc, NamedT);

ElaboratedTypeLoc NewTL = TLB.

<ElaboratedTypeLoc>(

);

NewTL.setQualifierLoc(QualifierLoc);

<

Derived>

QualType TreeTransform<Derived>::TransformAttributedType(TypeLocBuilder &TLB,

AttributedTypeLoc TL) {

QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc());

(modifiedType.isNull())

Attr *oldAttr = TL.getAttr();

Attr *newAttr = oldAttr ? getDerived().TransformAttr(oldAttr) :

;

(oldAttr && !newAttr)

QualType result = TL.getType();

(getDerived().AlwaysRebuild() ||

modifiedType != oldType->getModifiedType()) {

QualType equivalentType = modifiedType;

(TL.getModifiedLoc().getType() != TL.getEquivalentTypeLoc().getType()) {

TypeLocBuilder AuxiliaryTLB;

AuxiliaryTLB.reserve(TL.getFullDataSize());

getDerived().TransformType(AuxiliaryTLB, TL.getEquivalentTypeLoc());

(equivalentType.isNull())

(

nullability = oldType->getImmediateNullability()) {

(!modifiedType->canHaveNullability()) {

SemaRef.

((TL.getAttr() ? TL.getAttr()->getLocation()

: TL.getModifiedLoc().getBeginLoc()),

diag::err_nullability_nonpointer)

AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result);

newTL.setAttr(newAttr);

<

Derived>

QualType TreeTransform<Derived>::TransformCountAttributedType(

TypeLocBuilder &TLB, CountAttributedTypeLoc TL) {

CountAttributedType *OldTy = TL.

();

QualType InnerTy = getDerived().TransformType(TLB, TL.getInnerLoc());

(InnerTy.isNull())

Expr *OldCount = TL.getCountExpr();

Expr *NewCount =

;

CountResult = getDerived().TransformExpr(OldCount);

(CountResult.isInvalid())

NewCount = CountResult.get();

QualType

= TL.getType();

(getDerived().AlwaysRebuild() || InnerTy != OldTy->desugar() ||

OldCount != NewCount) {

InnerTy, NewCount, OldTy->isCountInBytes(), OldTy->isOrNull());

TLB.push<CountAttributedTypeLoc>(

);

<

Derived>

QualType TreeTransform<Derived>::TransformBTFTagAttributedType(

TypeLocBuilder &TLB, BTFTagAttributedTypeLoc TL) {

llvm_unreachable(

);

<

Derived>

QualType TreeTransform<Derived>::TransformHLSLAttributedResourceType(

TypeLocBuilder &TLB, HLSLAttributedResourceTypeLoc TL) {

HLSLAttributedResourceType *oldType = TL.getTypePtr();

QualType WrappedTy = getDerived().TransformType(TLB, TL.getWrappedLoc());

(WrappedTy.isNull())

QualType ContainedTy = QualType();

QualType OldContainedTy = oldType->getContainedType();

(!OldContainedTy.isNull()) {

TypeSourceInfo *oldContainedTSI = TL.getContainedTypeSourceInfo();

(!oldContainedTSI)

oldContainedTSI = getSema().getASTContext().getTrivialTypeSourceInfo(

OldContainedTy, SourceLocation());

TypeSourceInfo *ContainedTSI = getDerived().TransformType(oldContainedTSI);

ContainedTy = ContainedTSI->getType();

QualType

= TL.getType();

(getDerived().AlwaysRebuild() || WrappedTy != oldType->getWrappedType() ||

ContainedTy != oldType->getContainedType()) {

WrappedTy, ContainedTy, oldType->getAttrs());

TLB.push<HLSLAttributedResourceTypeLoc>(

);

<

Derived>

TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB,

QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

Inner != TL.getInnerLoc().getType()) {

= getDerived().RebuildParenType(Inner);

ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(

);

NewTL.setLParenLoc(TL.getLParenLoc());

NewTL.setRParenLoc(TL.getRParenLoc());

<

Derived>

TreeTransform<Derived>::TransformMacroQualifiedType(TypeLocBuilder &TLB,

MacroQualifiedTypeLoc TL) {

QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());

QualType

= TL.getType();

(getDerived().AlwaysRebuild() || Inner != TL.getInnerLoc().getType()) {

getDerived().RebuildMacroQualifiedType(Inner, TL.getMacroIdentifier());

MacroQualifiedTypeLoc NewTL = TLB.push<MacroQualifiedTypeLoc>(

);

NewTL.setExpansionLoc(TL.getExpansionLoc());

<

Derived>

QualType TreeTransform<Derived>::TransformDependentNameType(

TypeLocBuilder &TLB, DependentNameTypeLoc TL) {

TransformDependentNameType(TLB, TL,

);

<

Derived>

QualType TreeTransform<Derived>::TransformDependentNameType(

TypeLocBuilder &TLB, DependentNameTypeLoc TL,

DeducedTSTContext) {

DependentNameType *

= TL.getTypePtr();

NestedNameSpecifierLoc QualifierLoc

= getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());

= getDerived().RebuildDependentNameType(

->getKeyword(),

TL.getElaboratedKeywordLoc(),

->getIdentifier(),

(

ElaboratedType* ElabT =

->getAs<ElaboratedType>()) {

QualType NamedT = ElabT->getNamedType();

TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc());

ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(

);

NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());

NewTL.setQualifierLoc(QualifierLoc);

DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(

);

NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());

NewTL.setQualifierLoc(QualifierLoc);

NewTL.setNameLoc(TL.getNameLoc());

<

Derived>

DependentTemplateSpecializationTypeLoc TL) {

NestedNameSpecifierLoc QualifierLoc;

(TL.getQualifierLoc()) {

= getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());

.TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc);

<

Derived>

(getDerived().TransformTemplateArguments(ArgIterator(TL, 0),

= getDerived().RebuildDependentTemplateSpecializationType(

NamedT = ElabT->getNamedType();

(

I = 0,

= NewTemplateArgs.

(); I !=

; ++I)

NamedTL.

(I, NewTemplateArgs[I].getLocInfo());

}

(isa<DependentTemplateSpecializationType>(

)) {

(

I = 0,

= NewTemplateArgs.

(); I !=

; ++I)

(

I = 0,

= NewTemplateArgs.

(); I !=

; ++I)

<

Derived>

(getDerived().AlwaysRebuild() ||

= getDerived().RebuildPackExpansionType(Pattern,

PackExpansionTypeLoc NewT = TLB.

<PackExpansionTypeLoc>(

);

<

Derived>

TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,

ObjCInterfaceTypeLoc TL) {

TLB.pushFullCopy(TL);

TL.getType();

<

Derived>

TreeTransform<Derived>::TransformObjCTypeParamType(TypeLocBuilder &TLB,

ObjCTypeParamTypeLoc TL) {

ObjCTypeParamType *

= TL.getTypePtr();

ObjCTypeParamDecl *OTP = cast_or_null<ObjCTypeParamDecl>(

getDerived().TransformDecl(

->getDecl()->getLocation(),

->getDecl()));

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

OTP !=

->getDecl()) {

= getDerived().RebuildObjCTypeParamType(

OTP, TL.getProtocolLAngleLoc(),

(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),

TL.getProtocolLocs(), TL.getProtocolRAngleLoc());

ObjCTypeParamTypeLoc NewTL = TLB.push<ObjCTypeParamTypeLoc>(

);

(TL.getNumProtocols()) {

NewTL.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());

(

i = 0, n = TL.getNumProtocols(); i != n; ++i)

NewTL.setProtocolLoc(i, TL.getProtocolLoc(i));

NewTL.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());

<

Derived>

TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,

ObjCObjectTypeLoc TL) {

QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc());

(BaseType.isNull())

AnyChanged = BaseType != TL.getBaseLoc().getType();

(

i = 0, n = TL.getNumTypeArgs(); i != n; ++i) {

TypeSourceInfo *TypeArgInfo = TL.getTypeArgTInfo(i);

TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc();

QualType TypeArg = TypeArgInfo->getType();

(

PackExpansionLoc = TypeArgLoc.getAs<PackExpansionTypeLoc>()) {

*PackExpansion = PackExpansionLoc.getType()

->castAs<PackExpansionType>();

assert(!Unexpanded.empty() &&

);

TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc();

Expand =

;

RetainExpansion =

;

std::optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();

(getDerived().TryExpandParameterPacks(

PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(),

Unexpanded, Expand, RetainExpansion, NumExpansions))

Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);

TypeLocBuilder TypeArgBuilder;

TypeArgBuilder.reserve(PatternLoc.getFullDataSize());

QualType NewPatternType = getDerived().TransformType(TypeArgBuilder,

(NewPatternType.isNull())

NewPatternType, NumExpansions);

NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(NewExpansionType);

NewExpansionLoc.setEllipsisLoc(PackExpansionLoc.getEllipsisLoc());

NewTypeArgInfos.push_back(

TypeArgBuilder.getTypeSourceInfo(SemaRef.

, NewExpansionType));

(

ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {

Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);

TypeLocBuilder TypeArgBuilder;

TypeArgBuilder.reserve(PatternLoc.getFullDataSize());

QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder,

(NewTypeArg.isNull())

NewTypeArgInfos.push_back(

TypeArgBuilder.getTypeSourceInfo(SemaRef.

, NewTypeArg));

TypeLocBuilder TypeArgBuilder;

TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize());

QualType NewTypeArg =

getDerived().TransformType(TypeArgBuilder, TypeArgLoc);

(NewTypeArg.isNull())

(NewTypeArg == TypeArg) {

NewTypeArgInfos.push_back(TypeArgInfo);

NewTypeArgInfos.push_back(

TypeArgBuilder.getTypeSourceInfo(SemaRef.

, NewTypeArg));

QualType

= TL.getType();

(getDerived().AlwaysRebuild() || AnyChanged) {

= getDerived().RebuildObjCObjectType(

BaseType, TL.getBeginLoc(), TL.getTypeArgsLAngleLoc(), NewTypeArgInfos,

TL.getTypeArgsRAngleLoc(), TL.getProtocolLAngleLoc(),

(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),

TL.getProtocolLocs(), TL.getProtocolRAngleLoc());

ObjCObjectTypeLoc NewT = TLB.push<ObjCObjectTypeLoc>(

);

NewT.setHasBaseTypeAsWritten(

);

NewT.setTypeArgsLAngleLoc(TL.getTypeArgsLAngleLoc());

(

i = 0, n = TL.getNumTypeArgs(); i != n; ++i)

NewT.setTypeArgTInfo(i, NewTypeArgInfos[i]);

NewT.setTypeArgsRAngleLoc(TL.getTypeArgsRAngleLoc());

NewT.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());

(

i = 0, n = TL.getNumProtocols(); i != n; ++i)

NewT.setProtocolLoc(i, TL.getProtocolLoc(i));

NewT.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());

<

Derived>

TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,

ObjCObjectPointerTypeLoc TL) {

QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());

(PointeeType.isNull())

QualType

= TL.getType();

(getDerived().AlwaysRebuild() ||

PointeeType != TL.getPointeeLoc().getType()) {

= getDerived().RebuildObjCObjectPointerType(PointeeType,

ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(

);

NewT.setStarLoc(TL.getStarLoc());

<

Derived>

TreeTransform<Derived>::TransformNullStmt(NullStmt *S) {

<

Derived>

getDerived().TransformCompoundStmt(S,

);

<

Derived>

(S->hasStoredFPFeatures())

getSema().resetFPOptions(

S->getStoredFPFeatures().applyOverrides(getSema().getLangOpts()));

SubStmtInvalid =

;

SubStmtChanged =

;

(

*B : S->body()) {

B, IsStmtExpr && B ==

? SDK_StmtExprResult : SDK_Discarded);

(

.isInvalid()) {

(isa<DeclStmt>(B))

SubStmtInvalid =

;

SubStmtChanged = SubStmtChanged ||

.get() != B;

Statements.push_back(

.getAs<Stmt>());

(!getDerived().AlwaysRebuild() &&

getDerived().RebuildCompoundStmt(S->getLBracLoc(),

<

Derived>

TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {

LHS = getDerived().TransformExpr(S->getLHS());

(LHS.isInvalid())

RHS = getDerived().TransformExpr(S->getRHS());

(RHS.isInvalid())

Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),

S->getEllipsisLoc(),

(Case.isInvalid())

getDerived().TransformStmt(S->getSubStmt());

(SubStmt.isInvalid())

getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get());

<

Derived>

TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {

getDerived().TransformStmt(S->getSubStmt());

(SubStmt.isInvalid())

getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),

<

Derived>

TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S, StmtDiscardKind SDK) {

SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);

(SubStmt.isInvalid())

*LD = getDerived().TransformDecl(S->getDecl()->getLocation(),

(LD == S->getDecl())

S->getDecl()->setStmt(

);

getDerived().RebuildLabelStmt(S->getIdentLoc(),

cast<LabelDecl>(LD), SourceLocation(),

<

Derived>

<

Derived>

TransformAttr(R);

<

Derived>

StmtDiscardKind SDK) {

SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);

AttrsChanged =

;

(

*I : S->getAttrs()) {

getDerived().TransformStmtAttr(S->getSubStmt(), SubStmt.

(), I);

AttrsChanged |= (I != R);

(SubStmt.

() == S->getSubStmt() && !AttrsChanged)

getDerived().RebuildAttributedStmt(S->

(), Attrs,

<

Derived>

TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {

(

.isInvalid())

Sema::ConditionResult Cond;

(!S->isConsteval()) {

Cond = getDerived().TransformCondition(

S->getIfLoc(), S->getConditionVariable(), S->getCond(),

(Cond.isInvalid())

std::optional<bool> ConstexprConditionValue;

(S->isConstexpr())

ConstexprConditionValue = Cond.getKnownValue();

(!ConstexprConditionValue || *ConstexprConditionValue) {

EnterExpressionEvaluationContext Ctx(

S->isNonNegatedConsteval());

Then = getDerived().TransformStmt(S->getThen());

(Then.isInvalid())

Then =

(getSema().Context)

CompoundStmt(S->getThen()->getBeginLoc(), S->getThen()->getEndLoc());

(!ConstexprConditionValue || !*ConstexprConditionValue) {

EnterExpressionEvaluationContext Ctx(

S->isNegatedConsteval());

Else = getDerived().TransformStmt(S->getElse());

(Else.isInvalid())

}

(S->getElse() && ConstexprConditionValue &&

*ConstexprConditionValue) {

Else =

(getSema().Context)

CompoundStmt(S->getElse()->getBeginLoc(), S->getElse()->getEndLoc());

(!getDerived().AlwaysRebuild() &&

.get() == S->getInit() &&

Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&

Then.get() == S->getThen() &&

Else.get() == S->getElse())

getDerived().RebuildIfStmt(

S->getIfLoc(), S->getStatementKind(), S->getLParenLoc(), Cond,

S->getRParenLoc(),

.get(), Then.get(), S->getElseLoc(), Else.get());

<

Derived>

TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {

(

.isInvalid())

Sema::ConditionResult Cond = getDerived().TransformCondition(

S->getSwitchLoc(), S->getConditionVariable(), S->getCond(),

(Cond.isInvalid())

getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), S->getLParenLoc(),

.get(), Cond, S->getRParenLoc());

(

.isInvalid())

Body = getDerived().TransformStmt(S->getBody());

(Body.isInvalid())

getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(),

.get(),

<

Derived>

TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {

Sema::ConditionResult Cond = getDerived().TransformCondition(

S->getWhileLoc(), S->getConditionVariable(), S->getCond(),

(Cond.isInvalid())

SemaOpenACC::LoopInConstructRAII LCR{SemaRef.

()};

Body = getDerived().TransformStmt(S->getBody());

(Body.isInvalid())

(!getDerived().AlwaysRebuild() &&

Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&

Body.get() == S->getBody())

getDerived().RebuildWhileStmt(S->getWhileLoc(), S->getLParenLoc(),

Cond, S->getRParenLoc(), Body.get());

<

Derived>

TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {

SemaOpenACC::LoopInConstructRAII LCR{SemaRef.

()};

Body = getDerived().TransformStmt(S->getBody());

(Body.isInvalid())

Cond = getDerived().TransformExpr(S->getCond());

(Cond.isInvalid())

(!getDerived().AlwaysRebuild() &&

Cond.get() == S->getCond() &&

Body.get() == S->getBody())

getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(),

S->getWhileLoc(), Cond.get(),

<

Derived>

TreeTransform<Derived>::TransformForStmt(ForStmt *S) {

(getSema().getLangOpts().OpenMP)

getSema().OpenMP().startOpenMPLoop();

(

.isInvalid())

(getSema().getLangOpts().OpenMP &&

.isUsable())

getSema().OpenMP().ActOnOpenMPLoopInitialization(S->getForLoc(),

Sema::ConditionResult Cond = getDerived().TransformCondition(

S->getForLoc(), S->getConditionVariable(), S->getCond(),

(Cond.isInvalid())

(

.isInvalid())

Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(

.get()));

(S->getInc() && !FullInc.get())

SemaOpenACC::LoopInConstructRAII LCR{SemaRef.

()};

S->getBeginLoc(), S->getInit(),

.get(), S->getCond(),

Cond.get().second, S->getInc(),

.get());

Body = getDerived().TransformStmt(S->getBody());

(Body.isInvalid())

(!getDerived().AlwaysRebuild() &&

.get() == S->getInit() &&

Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&

.get() == S->getInc() &&

Body.get() == S->getBody())

getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),

.get(), Cond, FullInc,

S->getRParenLoc(), Body.get());

<

Derived>

TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {

*LD = getDerived().TransformDecl(S->getLabel()->getLocation(),

getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),

cast<LabelDecl>(LD));

<

Derived>

TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {

(

.isInvalid())

(!getDerived().AlwaysRebuild() &&

.get() == S->getTarget())

getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),

<

Derived>

TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {

<

Derived>

TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {

<

Derived>

TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {

(

.isInvalid())

getDerived().RebuildReturnStmt(S->getReturnLoc(),

.get());

<

Derived>

TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {

DeclChanged =

;

LambdaScopeInfo *LSI = getSema().getCurLambda();

(

*

: S->decls()) {

(Transformed !=

)

DeclChanged =

;

(

*TD = dyn_cast<TypeDecl>(Transformed))

LSI->ContainsUnexpandedParameterPack |=

.getTypeDeclType(TD)

.getSingleStepDesugaredType(getSema().getASTContext())

->containsUnexpandedParameterPack();

(

*VD = dyn_cast<VarDecl>(Transformed))

LSI->ContainsUnexpandedParameterPack |=

VD->getType()->containsUnexpandedParameterPack();

Decls.push_back(Transformed);

(!getDerived().AlwaysRebuild() && !DeclChanged)

getDerived().RebuildDeclStmt(Decls, S->getBeginLoc(), S->getEndLoc());

<

Derived>

TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) {

ExprsChanged =

;

(

I = 0,

= S->getNumOutputs(); I !=

; ++I) {

Names.push_back(S->getOutputIdentifier(I));

Constraints.push_back(S->getOutputConstraintLiteral(I));

Expr *OutputExpr = S->getOutputExpr(I);

(

.isInvalid())

ExprsChanged |=

.get() != OutputExpr;

Exprs.push_back(

.get());

(

I = 0,

= S->getNumInputs(); I !=

; ++I) {

Names.push_back(S->getInputIdentifier(I));

Constraints.push_back(S->getInputConstraintLiteral(I));

Expr *InputExpr = S->getInputExpr(I);

(

.isInvalid())

ExprsChanged |=

.get() != InputExpr;

Exprs.push_back(

.get());

(

I = 0,

= S->getNumLabels(); I !=

; ++I) {

Names.push_back(S->getLabelIdentifier(I));

(

.isInvalid())

ExprsChanged |=

.get() != S->getLabelExpr(I);

Exprs.push_back(

.get());

(!getDerived().AlwaysRebuild() && !ExprsChanged)

(

I = 0,

= S->getNumClobbers(); I !=

; ++I)

Clobbers.push_back(S->getClobberStringLiteral(I));

AsmString = S->getAsmString();

getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(),

S->isVolatile(), S->getNumOutputs(),

S->getNumInputs(), Names.data(),

Constraints, Exprs, AsmString.get(),

Clobbers, S->getNumLabels(),

<

Derived>

TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {

HadError =

, HadChange =

;

TransformedExprs.reserve(SrcExprs.size());

(

i = 0, e = SrcExprs.size(); i != e; ++i) {

(!

.isUsable()) {

HadChange |= (

.get() != SrcExprs[i]);

TransformedExprs.push_back(

.get());

(!HadChange && !getDerived().AlwaysRebuild())

getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(),

AsmToks, S->getAsmString(),

S->getNumOutputs(), S->getNumInputs(),

S->getAllConstraints(), S->getClobbers(),

TransformedExprs, S->getEndLoc());

<

Derived>

TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) {

*FD = cast<FunctionDecl>(SemaRef.

);

assert(FD && ScopeInfo && !ScopeInfo->CoroutinePromise &&

ScopeInfo->NeedsCoroutineSuspends &&

ScopeInfo->CoroutineSuspends.first ==

&&

ScopeInfo->CoroutineSuspends.second ==

&&

);

ScopeInfo->setNeedsCoroutineSuspends(

);

getDerived().transformedLocalDecl(S->getPromiseDecl(), {Promise});

ScopeInfo->CoroutinePromise = Promise;

InitSuspend = getDerived().TransformStmt(S->getInitSuspendStmt());

(InitSuspend.isInvalid())

getDerived().TransformStmt(S->getFinalSuspendStmt());

(FinalSuspend.isInvalid() ||

ScopeInfo->setCoroutineSuspends(InitSuspend.get(), FinalSuspend.get());

assert(isa<Expr>(InitSuspend.get()) && isa<Expr>(FinalSuspend.get()));

BodyRes = getDerived().TransformStmt(S->getBody());

(BodyRes.isInvalid())

CoroutineStmtBuilder Builder(SemaRef, *FD, *ScopeInfo, BodyRes.get());

(Builder.isInvalid())

Expr *ReturnObject = S->getReturnValueInit();

assert(ReturnObject &&

);

Res = getDerived().TransformInitializer(ReturnObject,

(Res.isInvalid())

Builder.ReturnValue = Res.get();

(S->hasDependentPromiseType()) {

(!Promise->getType()->isDependentType()) {

assert(!S->getFallthroughHandler() && !S->getExceptionHandler() &&

!S->getReturnStmtOnAllocFailure() && !S->getDeallocate() &&

);

(!Builder.buildDependentStatements())

(

*OnFallthrough = S->getFallthroughHandler()) {

Res = getDerived().TransformStmt(OnFallthrough);