13 #ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
14 #define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
40 #include "llvm/ADT/ArrayRef.h"
41 #include "llvm/Support/ErrorHandling.h"
44 using namespace llvm::omp;
100 template<
typename Derived>
105 class ForgetPartiallySubstitutedPackRAII {
110 ForgetPartiallySubstitutedPackRAII(Derived &Self) : Self(Self) {
111 Old = Self.ForgetPartiallySubstitutedPack();
114 ~ForgetPartiallySubstitutedPackRAII() {
115 Self.RememberPartiallySubstitutedPack(Old);
132 Derived &
getDerived() {
return static_cast<Derived&
>(*this); }
136 return static_cast<const Derived&
>(*this);
201 OldLocation = Self.
getDerived().getBaseLocation();
202 OldEntity = Self.
getDerived().getBaseEntity();
209 Self.
getDerived().setBase(OldLocation, OldEntity);
283 bool &RetainExpansion,
285 ShouldExpand =
false;
363 StmtResult TransformStmt(
Stmt *S, StmtDiscardKind SDK = SDK_Discarded);
383 const Attr *TransformAttr(
const Attr *S);
392 #define PRAGMA_SPELLING_ATTR(X) \
393 const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; }
394 #include "clang/Basic/AttrList.inc"
413 ExprResult TransformInitializer(Expr *Init,
bool NotCopyInit);
438 bool TransformExprs(Expr *
const *Inputs,
unsigned NumInputs,
bool IsCall,
439 SmallVectorImpl<Expr *> &Outputs,
440 bool *ArgChanged =
nullptr);
449 llvm::DenseMap<Decl *, Decl *>::iterator Known
450 = TransformedLocalDecls.find(D);
451 if (Known != TransformedLocalDecls.end())
452 return Known->second;
480 assert(New.size() == 1 &&
481 "must override transformedLocalDecl if performing pack expansion");
482 TransformedLocalDecls[Old] = New.front();
490 return getDerived().TransformDecl(Loc, D);
503 return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D));
507 bool TransformOverloadExprDecls(
OverloadExpr *Old,
bool RequiresADL,
519 NamedDecl *FirstQualifierInScope =
nullptr);
563 NamedDecl *FirstQualifierInScope =
nullptr,
564 bool AllowInjectedClassName =
false);
576 bool Uneval =
false);
599 bool Uneval =
false) {
600 return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs,
618 template<
typename InputIterator>
619 bool TransformTemplateArguments(InputIterator First,
622 bool Uneval =
false);
631 getDerived().getBaseLocation());
634 #define ABSTRACT_TYPELOC(CLASS, PARENT)
635 #define TYPELOC(CLASS, PARENT) \
636 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
637 #include "clang/AST/TypeLocNodes.def"
639 template<
typename Fn>
640 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
641 FunctionProtoTypeLoc TL,
642 CXXRecordDecl *ThisContext,
643 Qualifiers ThisTypeQuals,
644 Fn TransformExceptionSpec);
646 bool TransformExceptionSpec(SourceLocation Loc,
647 FunctionProtoType::ExceptionSpecInfo &ESI,
648 SmallVectorImpl<QualType> &Exceptions,
651 StmtResult TransformSEHHandler(Stmt *Handler);
654 TransformTemplateSpecializationType(TypeLocBuilder &TLB,
655 TemplateSpecializationTypeLoc TL,
656 TemplateName Template);
659 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
660 DependentTemplateSpecializationTypeLoc TL,
661 TemplateName Template,
664 QualType TransformDependentTemplateSpecializationType(
665 TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
666 NestedNameSpecifierLoc QualifierLoc);
675 bool TransformFunctionTypeParams(
676 SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
677 const QualType *ParamTypes,
678 const FunctionProtoType::ExtParameterInfo *ParamInfos,
679 SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars,
680 Sema::ExtParameterInfoBuilder &PInfos);
687 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
690 bool ExpectParameterPack);
693 StmtResult TransformLambdaBody(LambdaExpr *E, Stmt *Body);
696 StmtResult SkipLambdaBody(LambdaExpr *E, Stmt *Body);
698 QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);
700 StmtResult TransformCompoundStmt(CompoundStmt *S,
bool IsStmtExpr);
701 ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *E);
711 bool IsAddressOfOperand,
714 ExprResult TransformParenDependentScopeDeclRefExpr(
722 #define STMT(Node, Parent) \
723 LLVM_ATTRIBUTE_NOINLINE \
724 StmtResult Transform##Node(Node *S);
725 #define VALUESTMT(Node, Parent) \
726 LLVM_ATTRIBUTE_NOINLINE \
727 StmtResult Transform##Node(Node *S, StmtDiscardKind SDK);
728 #define EXPR(Node, Parent) \
729 LLVM_ATTRIBUTE_NOINLINE \
730 ExprResult Transform##Node(Node *E);
731 #define ABSTRACT_STMT(Stmt)
732 #include "clang/AST/StmtNodes.inc"
734 #define GEN_CLANG_CLAUSE_CLASS
735 #define CLAUSE_CLASS(Enum, Str, Class) \
736 LLVM_ATTRIBUTE_NOINLINE \
737 OMPClause *Transform##Class(Class *S);
738 #include "llvm/Frontend/OpenMP/OMP.inc"
746 QualType RebuildQualifiedType(QualType T, QualifiedTypeLoc TL);
752 QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);
758 QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);
768 QualType RebuildReferenceType(QualType ReferentType,
770 SourceLocation Sigil);
777 QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
778 SourceLocation Sigil);
780 QualType RebuildObjCTypeParamType(
const ObjCTypeParamDecl *Decl,
781 SourceLocation ProtocolLAngleLoc,
782 ArrayRef<ObjCProtocolDecl *> Protocols,
783 ArrayRef<SourceLocation> ProtocolLocs,
784 SourceLocation ProtocolRAngleLoc);
790 QualType RebuildObjCObjectType(QualType BaseType,
792 SourceLocation TypeArgsLAngleLoc,
793 ArrayRef<TypeSourceInfo *> TypeArgs,
794 SourceLocation TypeArgsRAngleLoc,
795 SourceLocation ProtocolLAngleLoc,
796 ArrayRef<ObjCProtocolDecl *> Protocols,
797 ArrayRef<SourceLocation> ProtocolLocs,
798 SourceLocation ProtocolRAngleLoc);
804 QualType RebuildObjCObjectPointerType(QualType PointeeType,
805 SourceLocation Star);
814 QualType RebuildArrayType(QualType ElementType,
815 ArrayType::ArraySizeModifier SizeMod,
818 unsigned IndexTypeQuals,
819 SourceRange BracketsRange);
826 QualType RebuildConstantArrayType(QualType ElementType,
827 ArrayType::ArraySizeModifier SizeMod,
830 unsigned IndexTypeQuals,
831 SourceRange BracketsRange);
838 QualType RebuildIncompleteArrayType(QualType ElementType,
839 ArrayType::ArraySizeModifier SizeMod,
840 unsigned IndexTypeQuals,
841 SourceRange BracketsRange);
848 QualType RebuildVariableArrayType(QualType ElementType,
849 ArrayType::ArraySizeModifier SizeMod,
851 unsigned IndexTypeQuals,
852 SourceRange BracketsRange);
859 QualType RebuildDependentSizedArrayType(QualType ElementType,
860 ArrayType::ArraySizeModifier SizeMod,
862 unsigned IndexTypeQuals,
863 SourceRange BracketsRange);
870 QualType RebuildVectorType(QualType ElementType,
unsigned NumElements,
871 VectorType::VectorKind VecKind);
878 QualType RebuildDependentVectorType(QualType ElementType, Expr *SizeExpr,
879 SourceLocation AttributeLoc,
880 VectorType::VectorKind);
887 QualType RebuildExtVectorType(QualType ElementType,
unsigned NumElements,
888 SourceLocation AttributeLoc);
895 QualType RebuildDependentSizedExtVectorType(QualType ElementType,
897 SourceLocation AttributeLoc);
900 QualType RebuildConstantMatrixType(QualType ElementType,
unsigned NumRows,
901 unsigned NumColumns);
905 QualType RebuildDependentSizedMatrixType(QualType ElementType, Expr *RowExpr,
907 SourceLocation AttributeLoc);
917 QualType RebuildDependentAddressSpaceType(QualType PointeeType,
919 SourceLocation AttributeLoc);
925 QualType RebuildFunctionProtoType(QualType T,
926 MutableArrayRef<QualType> ParamTypes,
927 const FunctionProtoType::ExtProtoInfo &EPI);
930 QualType RebuildFunctionNoProtoType(QualType ResultType);
934 QualType RebuildUnresolvedUsingType(SourceLocation NameLoc, Decl *D);
995 TypeConstraintConcept,
1004 Template, Deduced,
false);
1050 bool AllowInjectedClassName) {
1054 SS.
Adopt(QualifierLoc);
1055 TemplateName InstName = getDerived().RebuildTemplateName(
1056 SS, TemplateKWLoc, *Name, NameLoc,
QualType(),
nullptr,
1057 AllowInjectedClassName);
1072 getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
1093 bool DeducedTSTContext) {
1095 SS.
Adopt(QualifierLoc);
1107 *
Id, IdLoc, DeducedTSTContext);
1110 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
1125 switch (Result.getResultKind()) {
1126 case LookupResult::NotFound:
1127 case LookupResult::NotFoundInCurrentInstantiation:
1130 case LookupResult::Found:
1131 Tag = Result.getAsSingle<
TagDecl>();
1134 case LookupResult::FoundOverloaded:
1135 case LookupResult::FoundUnresolvedValue:
1136 llvm_unreachable(
"Tag lookup cannot find non-tags");
1138 case LookupResult::Ambiguous:
1148 switch (Result.getResultKind()) {
1149 case LookupResult::Found:
1150 case LookupResult::FoundOverloaded:
1151 case LookupResult::FoundUnresolvedValue: {
1152 NamedDecl *SomeDecl = Result.getRepresentativeDecl();
1154 SemaRef.
Diag(IdLoc, diag::err_tag_reference_non_tag) << SomeDecl
1160 SemaRef.
Diag(IdLoc, diag::err_not_tag_in_scope)
1169 SemaRef.
Diag(KeywordLoc, diag::err_use_with_wrong_tag) <<
Id;
1189 return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc,
1204 QualType RebuildBitIntType(
bool IsUnsigned,
unsigned NumBits,
1208 QualType RebuildDependentBitIntType(
bool IsUnsigned,
Expr *NumBitsExpr,
1233 bool AllowInjectedClassName);
1246 bool AllowInjectedClassName);
1257 return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
1268 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements,
1281 return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS,
1290 getSema().ActOnCaseStmtBody(S, Body);
1301 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt,
1332 return getSema().ActOnIfStmt(IfLoc,
Kind, LParenLoc, Init, Cond, RParenLoc,
1333 Then, ElseLoc, Else);
1344 return getSema().ActOnStartOfSwitchStmt(SwitchLoc, LParenLoc, Init, Cond,
1354 return getSema().ActOnFinishSwitchStmt(SwitchLoc,
Switch, Body);
1364 return getSema().ActOnWhileStmt(WhileLoc, LParenLoc, Cond, RParenLoc, Body);
1374 return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
1386 return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
1387 Inc, RParenLoc, Body);
1396 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc,
Label);
1406 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc,
Target);
1414 return getSema().BuildReturnStmt(ReturnLoc, Result);
1424 return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc);
1432 bool IsVolatile,
unsigned NumOutputs,
1438 return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
1439 NumInputs, Names, Constraints, Exprs,
1440 AsmString, Clobbers, NumLabels, RParenLoc);
1449 StringRef AsmString,
1450 unsigned NumOutputs,
unsigned NumInputs,
1455 return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString,
1456 NumOutputs, NumInputs,
1457 Constraints, Clobbers, Exprs, EndLoc);
1466 return getSema().BuildCoreturnStmt(CoreturnLoc, Result, IsImplicit);
1485 ExprResult Suspend = getSema().BuildOperatorCoawaitCall(
1486 CoawaitLoc, Operand, OpCoawaitLookup);
1489 return getSema().BuildResolvedCoawaitExpr(CoawaitLoc, Operand,
1490 Suspend.
get(),
true);
1493 return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Operand,
1504 return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Result, Lookup);
1512 return getSema().BuildCoyieldExpr(CoyieldLoc, Result);
1516 return getSema().BuildCoroutineBodyStmt(Args);
1527 return getSema().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts,
1537 return getSema().BuildObjCExceptionDecl(TInfo, T,
1551 return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
1561 return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body);
1570 return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
1578 return getSema().ActOnOpenMPCanonicalLoop(LoopStmt);
1591 return getSema().ActOnOpenMPExecutableDirective(
1592 Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
1605 return getSema().ActOnOpenMPIfClause(NameModifier,
Condition, StartLoc,
1606 LParenLoc, NameModifierLoc, ColonLoc,
1617 return getSema().ActOnOpenMPFinalClause(
Condition, StartLoc, LParenLoc,
1629 return getSema().ActOnOpenMPNumThreadsClause(NumThreads, StartLoc,
1640 return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc);
1650 return getSema().ActOnOpenMPSimdlenClause(Len, StartLoc, LParenLoc, EndLoc);
1657 return getSema().ActOnOpenMPSizesClause(Sizes, StartLoc, LParenLoc, EndLoc);
1663 return getSema().ActOnOpenMPFullClause(StartLoc, EndLoc);
1670 return getSema().ActOnOpenMPPartialClause(Factor, StartLoc, LParenLoc,
1681 return getSema().ActOnOpenMPAllocatorClause(A, StartLoc, LParenLoc, EndLoc);
1691 return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc,
1703 return getSema().ActOnOpenMPDefaultClause(
Kind, KindKwLoc,
1704 StartLoc, LParenLoc, EndLoc);
1716 return getSema().ActOnOpenMPProcBindClause(
Kind, KindKwLoc,
1717 StartLoc, LParenLoc, EndLoc);
1729 return getSema().ActOnOpenMPScheduleClause(
1730 M1, M2,
Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
1741 return getSema().ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Num);
1752 return getSema().ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc,
1764 return getSema().ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc,
1779 return getSema().ActOnOpenMPLastprivateClause(
1780 VarList, LPKind, LPKindLoc, ColonLoc, StartLoc, LParenLoc, EndLoc);
1791 return getSema().ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc,
1806 return getSema().ActOnOpenMPReductionClause(
1807 VarList, Modifier, StartLoc, LParenLoc, ModifierLoc, ColonLoc, EndLoc,
1808 ReductionIdScopeSpec, ReductionId, UnresolvedReductions);
1821 return getSema().ActOnOpenMPTaskReductionClause(
1822 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1823 ReductionId, UnresolvedReductions);
1837 return getSema().ActOnOpenMPInReductionClause(
1838 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1839 ReductionId, UnresolvedReductions);
1853 return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc,
1854 Modifier, ModifierLoc, ColonLoc,
1867 return getSema().ActOnOpenMPAlignedClause(VarList, Alignment, StartLoc,
1868 LParenLoc, ColonLoc, EndLoc);
1879 return getSema().ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc,
1891 return getSema().ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc,
1903 return getSema().ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc,
1914 return getSema().ActOnOpenMPDepobjClause(Depobj, StartLoc, LParenLoc,
1927 return getSema().ActOnOpenMPDependClause(Data, DepModifier, VarList,
1928 StartLoc, LParenLoc, EndLoc);
1940 return getSema().ActOnOpenMPDeviceClause(Modifier, Device, StartLoc,
1941 LParenLoc, ModifierLoc, EndLoc);
1955 return getSema().ActOnOpenMPMapClause(
1956 MapTypeModifiers, MapTypeModifiersLoc, MapperIdScopeSpec, MapperId,
1957 MapType, IsMapTypeImplicit, MapLoc, ColonLoc, VarList, Locs,
1958 false, UnresolvedMappers);
1970 return getSema().ActOnOpenMPAllocateClause(Allocate, VarList, StartLoc,
1971 LParenLoc, ColonLoc, EndLoc);
1981 return getSema().ActOnOpenMPNumTeamsClause(NumTeams, StartLoc, LParenLoc,
1993 return getSema().ActOnOpenMPThreadLimitClause(ThreadLimit, StartLoc,
2004 return getSema().ActOnOpenMPPriorityClause(
Priority, StartLoc, LParenLoc,
2015 return getSema().ActOnOpenMPGrainsizeClause(Grainsize, StartLoc, LParenLoc,
2026 return getSema().ActOnOpenMPNumTasksClause(NumTasks, StartLoc, LParenLoc,
2037 return getSema().ActOnOpenMPHintClause(Hint, StartLoc, LParenLoc, EndLoc);
2047 return getSema().ActOnOpenMPDetachClause(Evt, StartLoc, LParenLoc, EndLoc);
2059 return getSema().ActOnOpenMPDistScheduleClause(
2060 Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
2074 return getSema().ActOnOpenMPToClause(MotionModifiers, MotionModifiersLoc,
2075 MapperIdScopeSpec, MapperId, ColonLoc,
2076 VarList, Locs, UnresolvedMappers);
2090 return getSema().ActOnOpenMPFromClause(
2091 MotionModifiers, MotionModifiersLoc, MapperIdScopeSpec, MapperId,
2092 ColonLoc, VarList, Locs, UnresolvedMappers);
2101 return getSema().ActOnOpenMPUseDevicePtrClause(VarList, Locs);
2110 return getSema().ActOnOpenMPUseDeviceAddrClause(VarList, Locs);
2119 return getSema().ActOnOpenMPIsDevicePtrClause(VarList, Locs);
2128 return getSema().ActOnOpenMPHasDeviceAddrClause(VarList, Locs);
2142 return getSema().ActOnOpenMPDefaultmapClause(M,
Kind, StartLoc, LParenLoc,
2143 MLoc, KindLoc, EndLoc);
2154 return getSema().ActOnOpenMPNontemporalClause(VarList, StartLoc, LParenLoc,
2166 return getSema().ActOnOpenMPInclusiveClause(VarList, StartLoc, LParenLoc,
2178 return getSema().ActOnOpenMPExclusiveClause(VarList, StartLoc, LParenLoc,
2189 return getSema().ActOnOpenMPUsesAllocatorClause(StartLoc, LParenLoc, EndLoc,
2202 return getSema().ActOnOpenMPAffinityClause(StartLoc, LParenLoc, ColonLoc,
2203 EndLoc, Modifier, Locators);
2215 return getSema().ActOnOpenMPOrderClause(
Kind, KindKwLoc, StartLoc,
2224 bool IsTarget,
bool IsTargetSync,
2229 return getSema().ActOnOpenMPInitClause(InteropVar, PrefExprs, IsTarget,
2230 IsTargetSync, StartLoc, LParenLoc,
2241 return getSema().ActOnOpenMPUseClause(InteropVar, StartLoc, LParenLoc,
2253 return getSema().ActOnOpenMPDestroyClause(InteropVar, StartLoc, LParenLoc,
2265 return getSema().ActOnOpenMPNovariantsClause(
Condition, StartLoc, LParenLoc,
2276 return getSema().ActOnOpenMPNocontextClause(
Condition, StartLoc, LParenLoc,
2287 return getSema().ActOnOpenMPFilterClause(ThreadID, StartLoc, LParenLoc,
2300 return getSema().ActOnOpenMPBindClause(
Kind, KindLoc, StartLoc, LParenLoc,
2311 return getSema().ActOnOpenMPAlignClause(A, StartLoc, LParenLoc, EndLoc);
2320 return getSema().ActOnObjCAtSynchronizedOperand(atLoc,
object);
2329 return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body);
2338 return getSema().ActOnObjCAutoreleasePoolStmt(AtLoc, Body);
2350 StmtResult ForEachStmt = getSema().ActOnObjCForCollectionStmt(ForLoc,
2357 return getSema().FinishObjCForCollectionStmt(ForEachStmt.
get(), Body);
2370 StartLoc, IdLoc,
Id);
2372 getSema().CurContext->addDecl(Var);
2383 return Owned(
new (getSema().Context)
CXXCatchStmt(CatchLoc, ExceptionDecl,
2393 return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers);
2408 if (
DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) {
2409 if (RangeStmt->isSingleDecl()) {
2410 if (
VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
2411 if (RangeVar->isInvalidDecl())
2414 Expr *RangeExpr = RangeVar->getInit();
2420 return SemaRef.
Diag(Init->getBeginLoc(),
2421 diag::err_objc_for_range_init_stmt)
2422 << Init->getSourceRange();
2424 return getSema().ActOnObjCForCollectionStmt(ForLoc, LoopVar,
2425 RangeExpr, RParenLoc);
2431 return getSema().BuildCXXForRangeStmt(ForLoc, CoawaitLoc, Init, ColonLoc,
2432 Range,
Begin,
End, Cond, Inc, LoopVar,
2433 RParenLoc, Sema::BFRK_Rebuild);
2445 return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
2446 QualifierLoc, NameInfo, Nested);
2454 return getSema().FinishCXXForRangeStmt(ForRange, Body);
2459 return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler);
2464 return getSema().ActOnSEHExceptBlock(Loc, FilterExpr,
Block);
2468 return SEHFinallyStmt::Create(getSema().getASTContext(), Loc,
Block);
2475 return getSema().BuildSYCLUniqueStableNameExpr(OpLoc, LParen, RParen, TSI);
2484 return getSema().BuildPredefinedExpr(Loc, IK);
2494 return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
2508 SS.
Adopt(QualifierLoc);
2509 return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD, Found,
2519 return getSema().ActOnParenExpr(LParen, RParen, SubExpr);
2542 return getSema().BuildUnaryOp(
nullptr, OpLoc, Opc, SubExpr);
2553 return getSema().BuildBuiltinOffsetOf(OperatorLoc,
Type, Components,
2566 return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R);
2578 = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind);
2579 if (Result.isInvalid())
2593 return getSema().ActOnArraySubscriptExpr(
nullptr, LHS,
2605 return getSema().CreateBuiltinMatrixSubscriptExpr(
Base, RowIdx, ColumnIdx,
2619 return getSema().ActOnOMPArraySectionExpr(
Base, LBracketLoc, LowerBound,
2620 ColonLocFirst, ColonLocSecond,
2621 Length, Stride, RBracketLoc);
2632 return getSema().ActOnOMPArrayShapingExpr(
Base, LParenLoc, RParenLoc, Dims,
2643 return getSema().ActOnOMPIteratorExpr(
nullptr, IteratorKwLoc,
2654 Expr *ExecConfig =
nullptr) {
2655 return getSema().ActOnCallExpr(
2656 nullptr, Callee, LParenLoc, Args, RParenLoc, ExecConfig);
2662 return getSema().ActOnArraySubscriptExpr(
2663 nullptr, Callee, LParenLoc, Args, RParenLoc);
2681 if (!
Member->getDeclName()) {
2685 assert(
Member->getType()->isRecordType() &&
2686 "unnamed member not of record type?");
2697 return getSema().BuildFieldReferenceExpr(
2698 Base, isArrow, OpLoc, EmptySS, cast<FieldDecl>(
Member),
2699 DeclAccessPair::make(FoundDecl, FoundDecl->getAccess()), MemberNameInfo);
2703 SS.
Adopt(QualifierLoc);
2713 LookupResult R(getSema(), MemberNameInfo, Sema::LookupMemberName);
2717 return getSema().BuildMemberReferenceExpr(
Base, BaseType, OpLoc, isArrow,
2719 FirstQualifierInScope,
2720 R, ExplicitTemplateArgs,
2731 return getSema().BuildBinOp(
nullptr, OpLoc, Opc, LHS, RHS);
2741 return getSema().CreateOverloadedBinOp(OpLoc,
Opcode, UnqualLookups, LHS,
2754 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond,
2766 return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
2778 return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
2793 return getSema().BuildMemberReferenceExpr(
Base,
Base->getType(),
2824 if (Result.isInvalid())
2846 return getSema().BuildVAArgExpr(BuiltinLoc,
2858 return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs);
2868 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc,
Label);
2877 return getSema().BuildStmtExpr(LParenLoc, SubStmt, RParenLoc,
2900 Expr *ControllingExpr,
2903 return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
2904 ControllingExpr, Types, Exprs);
2936 case Stmt::CXXStaticCastExprClass:
2937 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
2938 RAngleLoc, LParenLoc,
2939 SubExpr, RParenLoc);
2941 case Stmt::CXXDynamicCastExprClass:
2942 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
2943 RAngleLoc, LParenLoc,
2944 SubExpr, RParenLoc);
2946 case Stmt::CXXReinterpretCastExprClass:
2947 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
2948 RAngleLoc, LParenLoc,
2952 case Stmt::CXXConstCastExprClass:
2953 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
2954 RAngleLoc, LParenLoc,
2955 SubExpr, RParenLoc);
2957 case Stmt::CXXAddrspaceCastExprClass:
2958 return getDerived().RebuildCXXAddrspaceCastExpr(
2959 OpLoc, LAngleLoc, TInfo, RAngleLoc, LParenLoc, SubExpr, RParenLoc);
2962 llvm_unreachable(
"Invalid C++ named cast");
2977 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
2994 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
3011 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
3028 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
3039 return getSema().BuildCXXNamedCast(
3040 OpLoc, tok::kw_addrspace_cast, TInfo, SubExpr,
3052 bool ListInitialization) {
3053 return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc,
3055 ListInitialization);
3065 return getSema().BuildBuiltinBitCastExpr(KWLoc, TSI,
Sub, RParenLoc);
3076 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
3089 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
3100 return getSema().BuildCXXUuidof(
Type, TypeidLoc, Operand, RParenLoc);
3109 return getSema().BuildCXXUuidof(
Type, TypeidLoc, Operand, RParenLoc);
3120 return getSema().BuildCXXThisExpr(ThisLoc, ThisType, isImplicit);
3128 bool IsThrownVariableInScope) {
3129 return getSema().BuildCXXThrow(ThrowLoc,
Sub, IsThrownVariableInScope);
3138 return CXXDefaultArgExpr::Create(getSema().Context, Loc, Param,
3139 getSema().CurContext);
3149 return CXXDefaultInitExpr::Create(getSema().Context, Loc, Field,
3150 getSema().CurContext);
3160 return getSema().BuildCXXTypeConstructExpr(
3161 TSInfo, LParenLoc, None, RParenLoc,
false);
3178 Expr *Initializer) {
3179 return getSema().BuildCXXNew(StartLoc, UseGlobal,
3196 bool IsGlobalDelete,
3199 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
3211 return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc);
3223 return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc);
3234 return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc);
3247 bool IsAddressOfOperand,
3250 SS.
Adopt(QualifierLoc);
3252 if (TemplateArgs || TemplateKWLoc.
isValid())
3253 return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc, NameInfo,
3256 return getSema().BuildQualifiedDeclarationNameExpr(
3257 SS, NameInfo, IsAddressOfOperand,
nullptr, RecoveryTSI);
3269 return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL,
3282 bool HadMultipleCandidates,
3283 bool ListInitialization,
3284 bool StdInitListInitialization,
3285 bool RequiresZeroInit,
3291 if (Constructor->isInheritingConstructor())
3292 FoundCtor = Constructor->getInheritedConstructor().getConstructor();
3295 if (getSema().CompleteConstructorCall(FoundCtor, T, Args, Loc,
3299 return getSema().BuildCXXConstructExpr(Loc, T, Constructor,
3302 HadMultipleCandidates,
3304 StdInitListInitialization,
3305 RequiresZeroInit, ConstructKind,
3313 bool ConstructsVBase,
3314 bool InheritedFromVBase) {
3316 Loc, T, Constructor, ConstructsVBase, InheritedFromVBase);
3327 bool ListInitialization) {
3328 return getSema().BuildCXXTypeConstructExpr(
3329 TSInfo, LParenOrBraceLoc, Args, RParenOrBraceLoc, ListInitialization);
3340 bool ListInitialization) {
3341 return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, Args,
3342 RParenLoc, ListInitialization);
3359 SS.
Adopt(QualifierLoc);
3362 OperatorLoc, IsArrow,
3364 FirstQualifierInScope,
3366 TemplateArgs,
nullptr);
3382 SS.
Adopt(QualifierLoc);
3385 OperatorLoc, IsArrow,
3387 FirstQualifierInScope,
3388 R, TemplateArgs,
nullptr);
3406 return SizeOfPackExpr::Create(SemaRef.
Context, OperatorLoc, Pack, PackLoc,
3407 RParenLoc, Length, PartialArgs);
3419 return getSema().BuildSourceLocExpr(
Kind, ResultTy, BuiltinLoc, RPLoc,
3433 ExprResult Result = getSema().CheckConceptTemplateId(SS, TemplateKWLoc,
3436 NamedConcept, TALI);
3437 if (Result.isInvalid())
3451 return RequiresExpr::Create(SemaRef.
Context, RequiresKWLoc, Body,
3452 LocalParameters, Requirements, ClosingBraceLoc);
3496 return getSema().BuildObjCBoxedExpr(SR, ValueExpr);
3504 Expr **Elements,
unsigned NumElements) {
3505 return getSema().BuildObjCArrayLiteral(Range,
3513 return getSema().BuildObjCSubscriptExpression(RB,
Base, Key,
3514 getterMethod, setterMethod);
3523 return getSema().BuildObjCDictionaryLiteral(Range, Elements);
3547 Sel, Method, LBracLoc, SelectorLocs,
3562 Sel, Method, LBracLoc, SelectorLocs,
3578 Sel, Method, LBracLoc, SelectorLocs,
3583 Sel, Method, LBracLoc, SelectorLocs,
3595 bool IsArrow,
bool IsFreeIvar) {
3598 ExprResult Result = getSema().BuildMemberReferenceExpr(
3604 if (IsFreeIvar && Result.isUsable())
3605 cast<ObjCIvarRefExpr>(Result.get())->setIsFreeIvar(IsFreeIvar);
3618 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->
getType(),
3641 PropertyLoc,
Base));
3652 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->
getType(),
3673 assert(!Lookup.
empty() &&
"No __builtin_shufflevector?");
3682 CK_BuiltinFnToFnPtr).
get();
3687 Expr::getValueKindForType(Builtin->
getReturnType()), RParenLoc,
3699 BuiltinLoc, RParenLoc);
3711 case TemplateArgument::Expression: {
3714 EllipsisLoc, NumExpansions);
3715 if (Result.isInvalid())
3721 case TemplateArgument::Template:
3730 case TemplateArgument::Integral:
3731 case TemplateArgument::Declaration:
3732 case TemplateArgument::Pack:
3733 case TemplateArgument::TemplateExpansion:
3734 case TemplateArgument::NullPtr:
3735 llvm_unreachable(
"Pack expansion pattern has no parameter packs");
3757 return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions);
3770 return getSema().BuildCXXFoldExpr(ULE, LParenLoc, LHS, Operator,
3771 EllipsisLoc, RHS, RParenLoc,
3781 return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator);
3794 return getSema().BuildAtomicExpr(Range, Range, RParenLoc, SubExprs, Op,
3795 Sema::AtomicArgumentOrder::AST);
3800 return getSema().CreateRecoveryExpr(BeginLoc, EndLoc, SubExprs,
Type);
3820 bool DeducibleTSTContext);
3823 template <
typename Derived>
3828 switch (S->getStmtClass()) {
3829 case Stmt::NoStmtClass:
break;
3833 #define STMT(Node, Parent) \
3834 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
3835 #define VALUESTMT(Node, Parent) \
3836 case Stmt::Node##Class: \
3837 return getDerived().Transform##Node(cast<Node>(S), SDK);
3838 #define ABSTRACT_STMT(Node)
3839 #define EXPR(Node, Parent)
3840 #include "clang/AST/StmtNodes.inc"
3843 #define STMT(Node, Parent)
3844 #define ABSTRACT_STMT(Stmt)
3845 #define EXPR(Node, Parent) case Stmt::Node##Class:
3846 #include "clang/AST/StmtNodes.inc"
3848 ExprResult E = getDerived().TransformExpr(cast<Expr>(S));
3850 if (SDK == SDK_StmtExprResult)
3851 E = getSema().ActOnStmtExprResult(E);
3852 return getSema().ActOnExprStmt(E, SDK == SDK_Discarded);
3859 template<
typename Derived>
3864 switch (S->getClauseKind()) {
3867 #define GEN_CLANG_CLAUSE_CLASS
3868 #define CLAUSE_CLASS(Enum, Str, Class) \
3870 return getDerived().Transform##Class(cast<Class>(S));
3871 #include "llvm/Frontend/OpenMP/OMP.inc"
3878 template<
typename Derived>
3884 case Stmt::NoStmtClass:
break;
3885 #define STMT(Node, Parent) case Stmt::Node##Class: break;
3886 #define ABSTRACT_STMT(Stmt)
3887 #define EXPR(Node, Parent) \
3888 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
3889 #include "clang/AST/StmtNodes.inc"
3895 template<
typename Derived>
3903 if (
auto *FE = dyn_cast<FullExpr>(Init))
3904 Init = FE->getSubExpr();
3906 if (
auto *AIL = dyn_cast<ArrayInitLoopExpr>(Init)) {
3912 Init = MTE->getSubExpr();
3915 Init = Binder->getSubExpr();
3918 Init = ICE->getSubExprAsWritten();
3921 dyn_cast<CXXStdInitializerListExpr>(Init))
3922 return TransformInitializer(ILE->getSubExpr(), NotCopyInit);
3929 return getDerived().TransformExpr(Init);
3934 return getDerived().RebuildParenListExpr(Parens.getBegin(), None,
3939 if (isa<ImplicitValueInitExpr>(Init))
3945 if (!Construct || isa<CXXTemporaryObjectExpr>(Construct))
3946 return getDerived().TransformExpr(Init);
3951 return TransformInitializer(Construct->
getArg(0), NotCopyInit);
3955 getSema(), EnterExpressionEvaluationContext::InitList,
3959 bool ArgChanged =
false;
3961 true, NewArgs, &ArgChanged))
3966 return getDerived().RebuildInitList(Construct->
getBeginLoc(), NewArgs,
3971 if (Parens.isInvalid()) {
3974 assert(NewArgs.empty() &&
3975 "no parens or braces but have direct init with arguments?");
3978 return getDerived().RebuildParenListExpr(Parens.getBegin(), NewArgs,
3982 template<
typename Derived>
3988 for (
unsigned I = 0; I != NumInputs; ++I) {
3990 if (IsCall && getDerived().DropCallArgument(Inputs[I])) {
3998 Expr *Pattern = Expansion->getPattern();
4001 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
4002 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
4007 bool RetainExpansion =
false;
4010 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
4013 Expand, RetainExpansion,
4022 ExprResult OutPattern = getDerived().TransformExpr(Pattern);
4026 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.
get(),
4027 Expansion->getEllipsisLoc(),
4029 if (Out.isInvalid())
4034 Outputs.push_back(Out.get());
4040 if (ArgChanged) *ArgChanged =
true;
4044 for (
unsigned I = 0; I != *NumExpansions; ++I) {
4046 ExprResult Out = getDerived().TransformExpr(Pattern);
4047 if (Out.isInvalid())
4050 if (Out.get()->containsUnexpandedParameterPack()) {
4051 Out = getDerived().RebuildPackExpansion(
4052 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
4053 if (Out.isInvalid())
4057 Outputs.push_back(Out.get());
4062 if (RetainExpansion) {
4063 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4065 ExprResult Out = getDerived().TransformExpr(Pattern);
4066 if (Out.isInvalid())
4069 Out = getDerived().RebuildPackExpansion(
4070 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
4071 if (Out.isInvalid())
4074 Outputs.push_back(Out.get());
4081 IsCall ? getDerived().TransformInitializer(Inputs[I],
false)
4082 : getDerived().TransformExpr(Inputs[I]);
4083 if (Result.isInvalid())
4086 if (Result.get() != Inputs[I] && ArgChanged)
4089 Outputs.push_back(Result.get());
4095 template <
typename Derived>
4099 VarDecl *ConditionVar = cast_or_null<VarDecl>(
4100 getDerived().TransformDefinition(Var->
getLocation(), Var));
4103 return Sema::ConditionError();
4105 return getSema().ActOnConditionVariable(ConditionVar, Loc,
Kind);
4112 return Sema::ConditionError();
4114 return getSema().ActOnCondition(
nullptr, Loc, CondExpr.
get(),
Kind,
4121 template <
typename Derived>
4127 Qualifier = Qualifier.getPrefix())
4141 SS, FirstQualifierInScope,
false))
4146 case NestedNameSpecifier::Namespace: {
4148 cast_or_null<NamespaceDecl>(getDerived().TransformDecl(
4154 case NestedNameSpecifier::NamespaceAlias: {
4156 cast_or_null<NamespaceAliasDecl>(getDerived().TransformDecl(
4163 case NestedNameSpecifier::Global:
4169 case NestedNameSpecifier::Super: {
4171 cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
4177 case NestedNameSpecifier::TypeSpecWithTemplate:
4178 case NestedNameSpecifier::TypeSpec: {
4180 FirstQualifierInScope, SS);
4189 "Can't get cv-qualifiers here");
4192 diag::warn_cxx98_compat_enum_nested_name_spec);
4209 FirstQualifierInScope =
nullptr;
4215 !getDerived().AlwaysRebuild())
4228 template<
typename Derived>
4236 switch (Name.getNameKind()) {
4238 case DeclarationName::ObjCZeroArgSelector:
4239 case DeclarationName::ObjCOneArgSelector:
4240 case DeclarationName::ObjCMultiArgSelector:
4241 case DeclarationName::CXXOperatorName:
4242 case DeclarationName::CXXLiteralOperatorName:
4243 case DeclarationName::CXXUsingDirective:
4246 case DeclarationName::CXXDeductionGuideName: {
4247 TemplateDecl *OldTemplate = Name.getCXXDeductionGuideTemplate();
4248 TemplateDecl *NewTemplate = cast_or_null<TemplateDecl>(
4249 getDerived().TransformDecl(NameInfo.
getLoc(), OldTemplate));
4259 case DeclarationName::CXXConstructorName:
4260 case DeclarationName::CXXDestructorName:
4261 case DeclarationName::CXXConversionFunctionName: {
4265 NewTInfo = getDerived().TransformType(OldTInfo);
4273 QualType NewT = getDerived().TransformType(Name.getCXXNameType());
4289 llvm_unreachable(
"Unknown name kind.");
4292 template<
typename Derived>
4299 bool AllowInjectedClassName) {
4301 TemplateDecl *Template = QTN->getUnderlyingTemplate().getAsTemplateDecl();
4302 assert(Template &&
"qualified template name must refer to a template");
4305 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
4310 if (!getDerived().AlwaysRebuild() &&
4312 TransTemplate == Template)
4315 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
4323 FirstQualifierInScope =
nullptr;
4326 if (!getDerived().AlwaysRebuild() &&
4334 if (DTN->isIdentifier()) {
4335 return getDerived().RebuildTemplateName(SS,
4337 *DTN->getIdentifier(),
4340 FirstQualifierInScope,
4341 AllowInjectedClassName);
4344 return getDerived().RebuildTemplateName(SS, TemplateKWLoc,
4345 DTN->getOperator(), NameLoc,
4346 ObjectType, AllowInjectedClassName);
4349 if (
TemplateDecl *Template = Name.getAsTemplateDecl()) {
4351 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
4356 if (!getDerived().AlwaysRebuild() &&
4357 TransTemplate == Template)
4364 = Name.getAsSubstTemplateTemplateParmPack()) {
4366 = cast_or_null<TemplateTemplateParmDecl>(
4367 getDerived().TransformDecl(NameLoc, SubstPack->getParameterPack()));
4371 if (!getDerived().AlwaysRebuild() &&
4372 TransParam == SubstPack->getParameterPack())
4375 return getDerived().RebuildTemplateName(TransParam,
4376 SubstPack->getArgumentPack());
4380 llvm_unreachable(
"overloaded function decl survived to here");
4383 template<
typename Derived>
4387 Output = getSema().getTrivialTemplateArgumentLoc(
4388 Arg,
QualType(), getDerived().getBaseLocation());
4391 template <
typename Derived>
4398 case TemplateArgument::Pack:
4399 llvm_unreachable(
"Unexpected TemplateArgument");
4401 case TemplateArgument::Integral:
4402 case TemplateArgument::NullPtr:
4403 case TemplateArgument::Declaration: {
4408 QualType NewT = getDerived().TransformType(T);
4415 ValueDecl *NewD = D ? cast_or_null<ValueDecl>(getDerived().TransformDecl(
4416 getDerived().getBaseLocation(), D))
4421 if (NewT == T && D == NewD)
4423 else if (Arg.
getKind() == TemplateArgument::Integral)
4427 else if (Arg.
getKind() == TemplateArgument::NullPtr)
4442 DI = getDerived().TransformType(DI);
4450 case TemplateArgument::Template: {
4453 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
4459 SS.
Adopt(QualifierLoc);
4460 TemplateName Template = getDerived().TransformTemplateName(
4470 case TemplateArgument::TemplateExpansion:
4471 llvm_unreachable(
"Caller should expand pack expansions");
4473 case TemplateArgument::Expression: {
4477 Uneval ? Sema::ExpressionEvaluationContext::Unevaluated
4478 : Sema::ExpressionEvaluationContext::ConstantEvaluated,
4480 Sema::ExpressionEvaluationContextRecord::EK_TemplateArgument);
4486 ExprResult E = getDerived().TransformExpr(InputExpr);
4501 template<
typename Derived,
typename InputIterator>
4509 typedef typename std::iterator_traits<InputIterator>::difference_type
4526 : Self(Self), Iter(Iter) { }
4549 return X.Iter == Y.Iter;
4554 return X.Iter != Y.Iter;
4558 template<
typename Derived>
4559 template<
typename InputIterator>
4576 if (TransformTemplateArguments(PackLocIterator(*
this,
4578 PackLocIterator(*
this,
4592 = getSema().getTemplateArgumentPackExpansionPattern(
4593 In, Ellipsis, OrigNumExpansions);
4596 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
4597 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
4602 bool RetainExpansion =
false;
4604 if (getDerived().TryExpandParameterPacks(Ellipsis,
4618 if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))
4621 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,
4623 if (Out.getArgument().isNull())
4632 for (
unsigned I = 0; I != *NumExpansions; ++I) {
4635 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
4638 if (Out.getArgument().containsUnexpandedParameterPack()) {
4639 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
4641 if (Out.getArgument().isNull())
4650 if (RetainExpansion) {
4651 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4653 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
4656 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
4658 if (Out.getArgument().isNull())
4668 if (getDerived().TransformTemplateArgument(In, Out, Uneval))
4682 template<
typename Derived>
4684 if (getDerived().AlreadyTransformed(T))
4689 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
4690 getDerived().getBaseLocation());
4700 template<
typename Derived>
4704 getDerived().getBaseEntity());
4705 if (getDerived().AlreadyTransformed(DI->
getType()))
4713 QualType Result = getDerived().TransformType(TLB, TL);
4714 if (Result.isNull())
4720 template<
typename Derived>
4724 #define ABSTRACT_TYPELOC(CLASS, PARENT)
4725 #define TYPELOC(CLASS, PARENT) \
4726 case TypeLoc::CLASS: \
4727 return getDerived().Transform##CLASS##Type(TLB, \
4728 T.castAs<CLASS##TypeLoc>());
4729 #include "clang/AST/TypeLocNodes.def"
4732 llvm_unreachable(
"unhandled type loc!");
4735 template<
typename Derived>
4737 if (!isa<DependentNameType>(T))
4738 return TransformType(T);
4740 if (getDerived().AlreadyTransformed(T))
4742 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
4743 getDerived().getBaseLocation());
4744 TypeSourceInfo *NewDI = getDerived().TransformTypeWithDeducedTST(DI);
4748 template<
typename Derived>
4751 if (!isa<DependentNameType>(DI->
getType()))
4752 return TransformType(DI);
4756 getDerived().getBaseEntity());
4757 if (getDerived().AlreadyTransformed(DI->
getType()))
4771 QualType Result = getDerived().TransformDependentNameType(
4773 if (Result.isNull())
4777 Result = getDerived().RebuildQualifiedType(Result, QTL);
4778 if (Result.isNull())
4786 template<
typename Derived>
4791 if (Result.isNull())
4794 Result = getDerived().RebuildQualifiedType(Result, T);
4796 if (Result.isNull())
4807 template <
typename Derived>
4817 SemaRef.
Diag(Loc, diag::err_address_space_mismatch_templ_inst)
4840 Quals = Qualifiers::fromCVRMask(Qualifiers::Restrict);
4854 = dyn_cast<SubstTemplateTypeParmType>(T)) {
4855 QualType Replacement = SubstTypeParam->getReplacementType();
4861 SubstTypeParam->getReplacedParameter(), Replacement);
4862 }
else if ((AutoTy = dyn_cast<AutoType>(T)) && AutoTy->
isDeduced()) {
4878 SemaRef.
Diag(Loc, diag::err_attr_objc_ownership_redundant) << T;
4887 template<
typename Derived>
4893 if (getDerived().AlreadyTransformed(TL.
getType()))
4897 TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
4903 template<
typename Derived>
4905 TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
4906 QualType ObjectType,
4907 NamedDecl *UnqualLookup,
4909 if (getDerived().AlreadyTransformed(TSInfo->getType()))
4912 return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType,
4916 template <
typename Derived>
4917 TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope(
4918 TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup,
4921 assert(!getDerived().AlreadyTransformed(T));
4926 if (isa<TemplateSpecializationType>(T)) {
4927 TemplateSpecializationTypeLoc SpecTL =
4928 TL.castAs<TemplateSpecializationTypeLoc>();
4930 TemplateName Template = getDerived().TransformTemplateName(
4931 SS, SpecTL.getTypePtr()->getTemplateName(), SpecTL.getTemplateNameLoc(),
4932 ObjectType, UnqualLookup,
true);
4933 if (Template.isNull())
4936 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL,
4938 }
else if (isa<DependentTemplateSpecializationType>(T)) {
4939 DependentTemplateSpecializationTypeLoc SpecTL =
4940 TL.castAs<DependentTemplateSpecializationTypeLoc>();
4942 TemplateName Template
4943 = getDerived().RebuildTemplateName(SS,
4944 SpecTL.getTemplateKeywordLoc(),
4945 *SpecTL.getTypePtr()->getIdentifier(),
4946 SpecTL.getTemplateNameLoc(),
4947 ObjectType, UnqualLookup,
4949 if (Template.isNull())
4952 Result = getDerived().TransformDependentTemplateSpecializationType(TLB,
4958 Result = getDerived().TransformType(TLB, TL);
4961 if (Result.isNull())
4964 return TLB.getTypeSourceInfo(SemaRef.
Context, Result);
4967 template <
class TyLoc>
static inline
4969 TyLoc NewT = TLB.
push<TyLoc>(T.getType());
4970 NewT.setNameLoc(T.getNameLoc());
4974 template<
typename Derived>
4975 QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
4977 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType());
4978 NewT.setBuiltinLoc(T.getBuiltinLoc());
4979 if (T.needsExtraLocalData())
4980 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs();
4984 template<
typename Derived>
4985 QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
4991 template <
typename Derived>
4992 QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB,
4993 AdjustedTypeLoc TL) {
4995 return getDerived().TransformType(TLB, TL.getOriginalLoc());
4998 template<
typename Derived>
4999 QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB,
5000 DecayedTypeLoc TL) {
5001 QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc());
5002 if (OriginalType.isNull())
5005 QualType Result = TL.getType();
5006 if (getDerived().AlwaysRebuild() ||
5007 OriginalType != TL.getOriginalLoc().getType())
5009 TLB.push<DecayedTypeLoc>(Result);
5014 template<
typename Derived>
5015 QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
5016 PointerTypeLoc TL) {
5017 QualType PointeeType
5018 = getDerived().TransformType(TLB, TL.getPointeeLoc());
5019 if (PointeeType.isNull())
5022 QualType Result = TL.getType();
5023 if (PointeeType->getAs<ObjCObjectType>()) {
5030 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
5031 NewT.setStarLoc(TL.getStarLoc());
5035 if (getDerived().AlwaysRebuild() ||
5036 PointeeType != TL.getPointeeLoc().getType()) {
5037 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
5038 if (Result.isNull())
5044 TLB.TypeWasModifiedSafely(Result->getPointeeType());
5046 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result);
5047 NewT.setSigilLoc(TL.getSigilLoc());
5051 template<
typename Derived>
5053 TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
5054 BlockPointerTypeLoc TL) {
5055 QualType PointeeType
5056 = getDerived().TransformType(TLB, TL.getPointeeLoc());
5057 if (PointeeType.isNull())
5060 QualType Result = TL.getType();
5061 if (getDerived().AlwaysRebuild() ||
5062 PointeeType != TL.getPointeeLoc().getType()) {
5063 Result = getDerived().RebuildBlockPointerType(PointeeType,
5065 if (Result.isNull())
5069 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result);
5070 NewT.setSigilLoc(TL.getSigilLoc());
5078 template<
typename Derived>
5086 if (PointeeType.
isNull())
5090 if (getDerived().AlwaysRebuild() ||
5092 Result = getDerived().RebuildReferenceType(PointeeType,
5095 if (Result.isNull())
5106 if (isa<LValueReferenceType>(Result))
5115 template<
typename Derived>
5119 return TransformReferenceType(TLB, TL);
5122 template<
typename Derived>
5124 TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
5125 RValueReferenceTypeLoc TL) {
5126 return TransformReferenceType(TLB, TL);
5129 template<
typename Derived>
5131 TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
5132 MemberPointerTypeLoc TL) {
5133 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
5134 if (PointeeType.isNull())
5137 TypeSourceInfo* OldClsTInfo = TL.getClassTInfo();
5138 TypeSourceInfo *NewClsTInfo =
nullptr;
5140 NewClsTInfo = getDerived().TransformType(OldClsTInfo);
5145 const MemberPointerType *T = TL.getTypePtr();
5146 QualType OldClsType = QualType(T->getClass(), 0);
5147 QualType NewClsType;
5149 NewClsType = NewClsTInfo->getType();
5151 NewClsType = getDerived().TransformType(OldClsType);
5152 if (NewClsType.isNull())
5156 QualType Result = TL.getType();
5157 if (getDerived().AlwaysRebuild() ||
5158 PointeeType != T->getPointeeType() ||
5159 NewClsType != OldClsType) {
5160 Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType,
5162 if (Result.isNull())
5168 const MemberPointerType *MPT = Result->getAs<MemberPointerType>();
5169 if (MPT && PointeeType != MPT->getPointeeType()) {
5170 assert(isa<AdjustedType>(MPT->getPointeeType()));
5171 TLB.push<AdjustedTypeLoc>(MPT->getPointeeType());
5174 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
5175 NewTL.setSigilLoc(TL.getSigilLoc());
5176 NewTL.setClassTInfo(NewClsTInfo);
5181 template<
typename Derived>
5183 TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
5184 ConstantArrayTypeLoc TL) {
5185 const ConstantArrayType *T = TL.getTypePtr();
5186 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5187 if (ElementType.isNull())
5191 Expr *OldSize = TL.getSizeExpr();
5193 OldSize =
const_cast<Expr*
>(T->getSizeExpr());
5194 Expr *NewSize =
nullptr;
5196 EnterExpressionEvaluationContext Unevaluated(
5197 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
5198 NewSize = getDerived().TransformExpr(OldSize).template getAs<Expr>();
5202 QualType Result = TL.getType();
5203 if (getDerived().AlwaysRebuild() ||
5204 ElementType != T->getElementType() ||
5205 (T->getSizeExpr() && NewSize != OldSize)) {
5206 Result = getDerived().RebuildConstantArrayType(ElementType,
5207 T->getSizeModifier(),
5208 T->getSize(), NewSize,
5209 T->getIndexTypeCVRQualifiers(),
5210 TL.getBracketsRange());
5211 if (Result.isNull())
5219 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
5220 NewTL.setLBracketLoc(TL.getLBracketLoc());
5221 NewTL.setRBracketLoc(TL.getRBracketLoc());
5222 NewTL.setSizeExpr(NewSize);
5227 template<
typename Derived>
5228 QualType TreeTransform<Derived>::TransformIncompleteArrayType(
5229 TypeLocBuilder &TLB,
5230 IncompleteArrayTypeLoc TL) {
5231 const IncompleteArrayType *T = TL.getTypePtr();
5232 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5233 if (ElementType.isNull())
5236 QualType Result = TL.getType();
5237 if (getDerived().AlwaysRebuild() ||
5238 ElementType != T->getElementType()) {
5239 Result = getDerived().RebuildIncompleteArrayType(ElementType,
5240 T->getSizeModifier(),
5241 T->getIndexTypeCVRQualifiers(),
5242 TL.getBracketsRange());
5243 if (Result.isNull())
5247 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
5248 NewTL.setLBracketLoc(TL.getLBracketLoc());
5249 NewTL.setRBracketLoc(TL.getRBracketLoc());
5250 NewTL.setSizeExpr(
nullptr);
5255 template<
typename Derived>
5257 TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
5258 VariableArrayTypeLoc TL) {
5259 const VariableArrayType *T = TL.getTypePtr();
5260 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5261 if (ElementType.isNull())
5266 EnterExpressionEvaluationContext Context(
5267 SemaRef, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
5268 SizeResult = getDerived().TransformExpr(T->getSizeExpr());
5270 if (SizeResult.isInvalid())
5274 if (SizeResult.isInvalid())
5277 Expr *
Size = SizeResult.get();
5279 QualType Result = TL.getType();
5280 if (getDerived().AlwaysRebuild() ||
5281 ElementType != T->getElementType() ||
5282 Size != T->getSizeExpr()) {
5283 Result = getDerived().RebuildVariableArrayType(ElementType,
5284 T->getSizeModifier(),
5286 T->getIndexTypeCVRQualifiers(),
5287 TL.getBracketsRange());
5288 if (Result.isNull())
5294 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
5295 NewTL.setLBracketLoc(TL.getLBracketLoc());
5296 NewTL.setRBracketLoc(TL.getRBracketLoc());
5297 NewTL.setSizeExpr(Size);
5302 template<
typename Derived>
5304 TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
5305 DependentSizedArrayTypeLoc TL) {
5306 const DependentSizedArrayType *T = TL.getTypePtr();
5307 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5308 if (ElementType.isNull())
5312 EnterExpressionEvaluationContext Unevaluated(
5313 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
5316 Expr *origSize = TL.getSizeExpr();
5317 if (!origSize) origSize = T->getSizeExpr();
5320 = getDerived().TransformExpr(origSize);
5322 if (sizeResult.isInvalid())
5325 Expr *size = sizeResult.get();
5327 QualType Result = TL.getType();
5328 if (getDerived().AlwaysRebuild() ||
5329 ElementType != T->getElementType() ||
5331 Result = getDerived().RebuildDependentSizedArrayType(ElementType,
5332 T->getSizeModifier(),
5334 T->getIndexTypeCVRQualifiers(),
5335 TL.getBracketsRange());
5336 if (Result.isNull())
5342 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
5343 NewTL.setLBracketLoc(TL.getLBracketLoc());
5344 NewTL.setRBracketLoc(TL.getRBracketLoc());
5345 NewTL.setSizeExpr(size);
5350 template <
typename Derived>
5351 QualType TreeTransform<Derived>::TransformDependentVectorType(
5352 TypeLocBuilder &TLB, DependentVectorTypeLoc TL) {
5353 const DependentVectorType *T = TL.getTypePtr();
5354 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5355 if (ElementType.isNull())
5358 EnterExpressionEvaluationContext Unevaluated(
5359 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
5363 if (
Size.isInvalid())
5366 QualType Result = TL.getType();
5367 if (getDerived().AlwaysRebuild() || ElementType != T->getElementType() ||
5368 Size.get() != T->getSizeExpr()) {
5369 Result = getDerived().RebuildDependentVectorType(
5370 ElementType,
Size.get(), T->getAttributeLoc(), T->getVectorKind());
5371 if (Result.isNull())
5376 if (isa<DependentVectorType>(Result)) {
5377 DependentVectorTypeLoc NewTL =
5378 TLB.push<DependentVectorTypeLoc>(Result);
5379 NewTL.setNameLoc(TL.getNameLoc());
5381 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
5382 NewTL.setNameLoc(TL.getNameLoc());
5388 template<
typename Derived>
5389 QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
5390 TypeLocBuilder &TLB,
5391 DependentSizedExtVectorTypeLoc TL) {
5392 const DependentSizedExtVectorType *T = TL.getTypePtr();
5395 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5396 if (ElementType.isNull())
5400 EnterExpressionEvaluationContext Unevaluated(
5401 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
5405 if (
Size.isInvalid())
5408 QualType Result = TL.getType();
5409 if (getDerived().AlwaysRebuild() ||
5410 ElementType != T->getElementType() ||
5411 Size.get() != T->getSizeExpr()) {
5412 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
5414 T->getAttributeLoc());
5415 if (Result.isNull())
5420 if (isa<DependentSizedExtVectorType>(Result)) {
5421 DependentSizedExtVectorTypeLoc NewTL
5422 = TLB.push<DependentSizedExtVectorTypeLoc>(Result);
5423 NewTL.setNameLoc(TL.getNameLoc());
5425 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
5426 NewTL.setNameLoc(TL.getNameLoc());
5432 template <
typename Derived>
5434 TreeTransform<Derived>::TransformConstantMatrixType(TypeLocBuilder &TLB,
5435 ConstantMatrixTypeLoc TL) {
5436 const ConstantMatrixType *T = TL.getTypePtr();
5437 QualType ElementType = getDerived().TransformType(T->getElementType());
5438 if (ElementType.isNull())
5441 QualType Result = TL.getType();
5442 if (getDerived().AlwaysRebuild() || ElementType != T->getElementType()) {
5443 Result = getDerived().RebuildConstantMatrixType(
5444 ElementType, T->getNumRows(), T->getNumColumns());
5445 if (Result.isNull())
5449 ConstantMatrixTypeLoc NewTL = TLB.push<ConstantMatrixTypeLoc>(Result);
5450 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
5451 NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5452 NewTL.setAttrRowOperand(TL.getAttrRowOperand());
5453 NewTL.setAttrColumnOperand(TL.getAttrColumnOperand());
5458 template <
typename Derived>
5459 QualType TreeTransform<Derived>::TransformDependentSizedMatrixType(
5460 TypeLocBuilder &TLB, DependentSizedMatrixTypeLoc TL) {
5461 const DependentSizedMatrixType *T = TL.getTypePtr();
5463 QualType ElementType = getDerived().TransformType(T->getElementType());
5464 if (ElementType.isNull()) {
5469 EnterExpressionEvaluationContext Unevaluated(
5470 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
5472 Expr *origRows = TL.getAttrRowOperand();
5474 origRows = T->getRowExpr();
5475 Expr *origColumns = TL.getAttrColumnOperand();
5477 origColumns = T->getColumnExpr();
5479 ExprResult rowResult = getDerived().TransformExpr(origRows);
5481 if (rowResult.isInvalid())
5484 ExprResult columnResult = getDerived().TransformExpr(origColumns);
5486 if (columnResult.isInvalid())
5489 Expr *rows = rowResult.get();
5490 Expr *columns = columnResult.get();
5492 QualType Result = TL.getType();
5493 if (getDerived().AlwaysRebuild() || ElementType != T->getElementType() ||
5494 rows != origRows || columns != origColumns) {
5495 Result = getDerived().RebuildDependentSizedMatrixType(
5496 ElementType, rows, columns, T->getAttributeLoc());
5498 if (Result.isNull())
5504 MatrixTypeLoc NewTL = TLB.push<MatrixTypeLoc>(Result);
5505 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
5506 NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5507 NewTL.setAttrRowOperand(rows);
5508 NewTL.setAttrColumnOperand(columns);
5512 template <
typename Derived>
5513 QualType TreeTransform<Derived>::TransformDependentAddressSpaceType(
5514 TypeLocBuilder &TLB, DependentAddressSpaceTypeLoc TL) {
5515 const DependentAddressSpaceType *T = TL.getTypePtr();
5517 QualType pointeeType = getDerived().TransformType(T->getPointeeType());
5519 if (pointeeType.isNull())
5523 EnterExpressionEvaluationContext Unevaluated(
5524 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
5526 ExprResult AddrSpace = getDerived().TransformExpr(T->getAddrSpaceExpr());
5528 if (AddrSpace.isInvalid())
5531 QualType Result = TL.getType();
5532 if (getDerived().AlwaysRebuild() || pointeeType != T->getPointeeType() ||
5533 AddrSpace.get() != T->getAddrSpaceExpr()) {
5534 Result = getDerived().RebuildDependentAddressSpaceType(
5535 pointeeType, AddrSpace.get(), T->getAttributeLoc());
5536 if (Result.isNull())
5541 if (isa<DependentAddressSpaceType>(Result)) {
5542 DependentAddressSpaceTypeLoc NewTL =
5543 TLB.push<DependentAddressSpaceTypeLoc>(Result);
5545 NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5546 NewTL.setAttrExprOperand(TL.getAttrExprOperand());
5547 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
5550 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(
5551 Result, getDerived().getBaseLocation());
5552 TransformType(TLB, DI->getTypeLoc());
5558 template <
typename Derived>
5559 QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
5561 const VectorType *T = TL.getTypePtr();
5562 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5563 if (ElementType.isNull())
5566 QualType Result = TL.getType();
5567 if (getDerived().AlwaysRebuild() ||
5568 ElementType != T->getElementType()) {
5569 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(),
5570 T->getVectorKind());
5571 if (Result.isNull())
5575 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
5576 NewTL.setNameLoc(TL.getNameLoc());
5581 template<
typename Derived>
5582 QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
5583 ExtVectorTypeLoc TL) {
5584 const VectorType *T = TL.getTypePtr();
5585 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5586 if (ElementType.isNull())
5589 QualType Result = TL.getType();
5590 if (getDerived().AlwaysRebuild() ||
5591 ElementType != T->getElementType()) {
5592 Result = getDerived().RebuildExtVectorType(ElementType,
5593 T->getNumElements(),
5595 if (Result.isNull())
5599 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
5600 NewTL.setNameLoc(TL.getNameLoc());
5605 template <
typename Derived>
5608 bool ExpectParameterPack) {
5612 if (NumExpansions && isa<PackExpansionType>(OldDI->
getType())) {
5622 QualType Result = getDerived().TransformType(TLB,
5624 if (Result.isNull())
5627 Result = RebuildPackExpansionType(Result,
5631 if (Result.isNull())
5637 NewDI = TLB.getTypeSourceInfo(SemaRef.
Context, Result);
5639 NewDI = getDerived().TransformType(OldDI);
5643 if (NewDI == OldDI && indexAdjustment == 0)
5657 transformedLocalDecl(OldParm, {newParm});
5661 template <
typename Derived>
5669 int indexAdjustment = 0;
5671 unsigned NumParams = Params.size();
5672 for (
unsigned i = 0; i != NumParams; ++i) {
5674 assert(OldParm->getFunctionScopeIndex() == i);
5678 if (OldParm->isParameterPack()) {
5683 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc();
5689 bool ShouldExpand =
false;
5690 bool RetainExpansion =
false;
5692 if (Unexpanded.size() > 0) {