14 #ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
15 #define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
37 #include "llvm/ADT/ArrayRef.h"
38 #include "llvm/Support/ErrorHandling.h"
95 template<
typename Derived>
100 class ForgetPartiallySubstitutedPackRAII {
105 ForgetPartiallySubstitutedPackRAII(Derived &Self) : Self(Self) {
106 Old = Self.ForgetPartiallySubstitutedPack();
109 ~ForgetPartiallySubstitutedPackRAII() {
110 Self.RememberPartiallySubstitutedPack(Old);
127 Derived &
getDerived() {
return static_cast<Derived&
>(*this); }
131 return static_cast<const Derived&
>(*this);
150 bool AlwaysRebuild() {
return SemaRef.ArgumentPackSubstitutionIndex != -1; }
184 OldLocation = Self.
getDerived().getBaseLocation();
185 OldEntity = Self.
getDerived().getBaseEntity();
192 Self.getDerived().setBase(OldLocation, OldEntity);
258 bool &RetainExpansion,
260 ShouldExpand =
false;
351 const Attr *TransformAttr(
const Attr *
S);
360 #define PRAGMA_SPELLING_ATTR(X) \
361 const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; }
362 #include "clang/Basic/AttrList.inc"
381 ExprResult TransformInitializer(Expr *Init,
bool NotCopyInit);
406 bool TransformExprs(Expr *
const *Inputs,
unsigned NumInputs,
bool IsCall,
407 SmallVectorImpl<Expr *> &Outputs,
408 bool *ArgChanged =
nullptr);
417 llvm::DenseMap<Decl *, Decl *>::iterator Known
418 = TransformedLocalDecls.find(D);
419 if (Known != TransformedLocalDecls.end())
420 return Known->second;
448 TransformedLocalDecls[Old] = New;
456 return getDerived().TransformDecl(Loc, D);
469 return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D));
473 bool TransformOverloadExprDecls(
OverloadExpr *Old,
bool RequiresADL,
485 NamedDecl *FirstQualifierInScope =
nullptr);
520 NamedDecl *FirstQualifierInScope =
nullptr,
521 bool AllowInjectedClassName =
false);
533 bool Uneval =
false);
556 bool Uneval =
false) {
557 return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs,
575 template<
typename InputIterator>
576 bool TransformTemplateArguments(InputIterator First,
579 bool Uneval =
false);
587 return SemaRef.Context.getTrivialTypeSourceInfo(T,
588 getDerived().getBaseLocation());
591 #define ABSTRACT_TYPELOC(CLASS, PARENT)
592 #define TYPELOC(CLASS, PARENT) \
593 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
594 #include "clang/AST/TypeLocNodes.def"
596 template<
typename Fn>
597 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
598 FunctionProtoTypeLoc TL,
599 CXXRecordDecl *ThisContext,
600 unsigned ThisTypeQuals,
601 Fn TransformExceptionSpec);
603 bool TransformExceptionSpec(SourceLocation Loc,
604 FunctionProtoType::ExceptionSpecInfo &ESI,
605 SmallVectorImpl<QualType> &Exceptions,
608 StmtResult TransformSEHHandler(Stmt *Handler);
611 TransformTemplateSpecializationType(TypeLocBuilder &TLB,
612 TemplateSpecializationTypeLoc TL,
613 TemplateName Template);
616 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
617 DependentTemplateSpecializationTypeLoc TL,
618 TemplateName Template,
621 QualType TransformDependentTemplateSpecializationType(
622 TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
623 NestedNameSpecifierLoc QualifierLoc);
632 bool TransformFunctionTypeParams(
633 SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
634 const QualType *ParamTypes,
635 const FunctionProtoType::ExtParameterInfo *ParamInfos,
636 SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars,
637 Sema::ExtParameterInfoBuilder &PInfos);
644 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
646 Optional<unsigned> NumExpansions,
647 bool ExpectParameterPack);
649 QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);
651 StmtResult TransformCompoundStmt(CompoundStmt *
S,
bool IsStmtExpr);
652 ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *
E);
662 bool IsAddressOfOperand,
665 ExprResult TransformParenDependentScopeDeclRefExpr(
673 #define STMT(Node, Parent) \
674 LLVM_ATTRIBUTE_NOINLINE \
675 StmtResult Transform##Node(Node *S);
676 #define EXPR(Node, Parent) \
677 LLVM_ATTRIBUTE_NOINLINE \
678 ExprResult Transform##Node(Node *E);
679 #define ABSTRACT_STMT(Stmt)
680 #include "clang/AST/StmtNodes.inc"
682 #define OPENMP_CLAUSE(Name, Class) \
683 LLVM_ATTRIBUTE_NOINLINE \
684 OMPClause *Transform ## Class(Class *S);
685 #include "clang/Basic/OpenMPKinds.def"
694 QualType RebuildQualifiedType(QualType T, SourceLocation Loc,
701 QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);
707 QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);
717 QualType RebuildReferenceType(QualType ReferentType,
719 SourceLocation Sigil);
726 QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
727 SourceLocation Sigil);
729 QualType RebuildObjCTypeParamType(
const ObjCTypeParamDecl *Decl,
730 SourceLocation ProtocolLAngleLoc,
731 ArrayRef<ObjCProtocolDecl *> Protocols,
732 ArrayRef<SourceLocation> ProtocolLocs,
733 SourceLocation ProtocolRAngleLoc);
739 QualType RebuildObjCObjectType(QualType BaseType,
741 SourceLocation TypeArgsLAngleLoc,
742 ArrayRef<TypeSourceInfo *> TypeArgs,
743 SourceLocation TypeArgsRAngleLoc,
744 SourceLocation ProtocolLAngleLoc,
745 ArrayRef<ObjCProtocolDecl *> Protocols,
746 ArrayRef<SourceLocation> ProtocolLocs,
747 SourceLocation ProtocolRAngleLoc);
753 QualType RebuildObjCObjectPointerType(QualType PointeeType,
754 SourceLocation Star);
763 QualType RebuildArrayType(QualType ElementType,
765 const llvm::APInt *Size,
767 unsigned IndexTypeQuals,
768 SourceRange BracketsRange);
775 QualType RebuildConstantArrayType(QualType ElementType,
777 const llvm::APInt &Size,
778 unsigned IndexTypeQuals,
779 SourceRange BracketsRange);
786 QualType RebuildIncompleteArrayType(QualType ElementType,
788 unsigned IndexTypeQuals,
789 SourceRange BracketsRange);
796 QualType RebuildVariableArrayType(QualType ElementType,
799 unsigned IndexTypeQuals,
800 SourceRange BracketsRange);
807 QualType RebuildDependentSizedArrayType(QualType ElementType,
810 unsigned IndexTypeQuals,
811 SourceRange BracketsRange);
818 QualType RebuildVectorType(QualType ElementType,
unsigned NumElements,
826 QualType RebuildExtVectorType(QualType ElementType,
unsigned NumElements,
827 SourceLocation AttributeLoc);
834 QualType RebuildDependentSizedExtVectorType(QualType ElementType,
836 SourceLocation AttributeLoc);
842 QualType RebuildFunctionProtoType(QualType T,
843 MutableArrayRef<QualType> ParamTypes,
844 const FunctionProtoType::ExtProtoInfo &EPI);
847 QualType RebuildFunctionNoProtoType(QualType ResultType);
851 QualType RebuildUnresolvedUsingType(SourceLocation NameLoc, Decl *D);
855 return SemaRef.Context.getTypeDeclType(Typedef);
860 return SemaRef.Context.getTypeDeclType(Record);
865 return SemaRef.Context.getTypeDeclType(Enum);
897 return SemaRef.Context.getAutoType(Deduced, Keyword,
905 return SemaRef.Context.getDeducedTemplateSpecializationType(
906 Template, Deduced,
false);
923 return SemaRef.BuildParenType(InnerType);
935 return SemaRef.Context.getElaboratedType(Keyword,
951 bool AllowInjectedClassName) {
955 SS.
Adopt(QualifierLoc);
957 = getDerived().RebuildTemplateName(SS, *Name, NameLoc,
QualType(),
958 nullptr, AllowInjectedClassName);
965 return SemaRef.Context.getDependentTemplateSpecializationType(Keyword,
973 getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
979 return SemaRef.Context.getElaboratedType(Keyword,
994 bool DeducedTSTContext) {
996 SS.
Adopt(QualifierLoc);
1000 if (!SemaRef.computeDeclContext(SS))
1001 return SemaRef.Context.getDependentNameType(Keyword,
1007 QualType T = SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc,
1011 if (!DeducedTSTContext) {
1012 if (
auto *Deduced = dyn_cast_or_null<DeducedTemplateSpecializationType>(
1014 SemaRef.Diag(IdLoc, diag::err_dependent_deduced_tst)
1015 << (int)SemaRef.getTemplateNameKindForDiagnostics(
1016 Deduced->getTemplateName())
1018 if (
auto *TD = Deduced->getTemplateName().getAsTemplateDecl())
1019 SemaRef.Diag(TD->getLocation(), diag::note_template_decl_here);
1032 DeclContext *DC = SemaRef.computeDeclContext(SS,
false);
1036 if (SemaRef.RequireCompleteDeclContext(SS, DC))
1040 SemaRef.LookupQualifiedName(Result, DC);
1052 llvm_unreachable(
"Tag lookup cannot find non-tags");
1063 SemaRef.LookupQualifiedName(Result, DC);
1070 SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) << SomeDecl
1072 SemaRef.Diag(SomeDecl->
getLocation(), diag::note_declared_at);
1076 SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope)
1083 if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind,
false,
1085 SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id;
1086 SemaRef.Diag(Tag->
getLocation(), diag::note_previous_use);
1091 QualType T = SemaRef.Context.getTypeDeclType(Tag);
1092 return SemaRef.Context.getElaboratedType(Keyword,
1105 return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc,
1141 bool AllowInjectedClassName);
1154 bool AllowInjectedClassName);
1165 return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
1176 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements,
1189 return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS,
1198 getSema().ActOnCaseStmtBody(S, Body);
1209 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt,
1219 return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt);
1229 return SemaRef.ActOnAttributedStmt(AttrLoc, Attrs, SubStmt);
1239 return getSema().ActOnIfStmt(IfLoc, IsConstexpr, Init, Cond, Then,
1249 return getSema().ActOnStartOfSwitchStmt(SwitchLoc, Init, Cond);
1258 return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body);
1267 return getSema().ActOnWhileStmt(WhileLoc, Cond, Body);
1277 return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
1289 return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
1290 Inc, RParenLoc, Body);
1299 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label);
1309 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target);
1317 return getSema().BuildReturnStmt(ReturnLoc, Result);
1327 return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc);
1335 bool IsVolatile,
unsigned NumOutputs,
1340 return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
1341 NumInputs, Names, Constraints, Exprs,
1342 AsmString, Clobbers, RParenLoc);
1351 StringRef AsmString,
1352 unsigned NumOutputs,
unsigned NumInputs,
1357 return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString,
1358 NumOutputs, NumInputs,
1359 Constraints, Clobbers, Exprs, EndLoc);
1368 return getSema().BuildCoreturnStmt(CoreturnLoc, Result, IsImplicit);
1377 return getSema().BuildResolvedCoawaitExpr(CoawaitLoc, Result, IsImplicit);
1387 return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Result, Lookup);
1395 return getSema().BuildCoyieldExpr(CoyieldLoc, Result);
1399 return getSema().BuildCoroutineBodyStmt(Args);
1410 return getSema().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts,
1420 return getSema().BuildObjCExceptionDecl(TInfo, T,
1434 return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
1444 return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body);
1453 return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
1466 return getSema().ActOnOpenMPExecutableDirective(
1467 Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
1480 return getSema().ActOnOpenMPIfClause(NameModifier, Condition, StartLoc,
1481 LParenLoc, NameModifierLoc, ColonLoc,
1492 return getSema().ActOnOpenMPFinalClause(Condition, StartLoc, LParenLoc,
1504 return getSema().ActOnOpenMPNumThreadsClause(NumThreads, StartLoc,
1515 return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc);
1525 return getSema().ActOnOpenMPSimdlenClause(Len, StartLoc, LParenLoc, EndLoc);
1535 return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc,
1548 return getSema().ActOnOpenMPDefaultClause(Kind, KindKwLoc,
1549 StartLoc, LParenLoc, EndLoc);
1561 return getSema().ActOnOpenMPProcBindClause(Kind, KindKwLoc,
1562 StartLoc, LParenLoc, EndLoc);
1574 return getSema().ActOnOpenMPScheduleClause(
1575 M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
1586 return getSema().ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Num);
1597 return getSema().ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc,
1609 return getSema().ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc,
1621 return getSema().ActOnOpenMPLastprivateClause(VarList, StartLoc, LParenLoc,
1633 return getSema().ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc,
1649 return getSema().ActOnOpenMPReductionClause(
1650 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1651 ReductionId, UnresolvedReductions);
1664 return getSema().ActOnOpenMPTaskReductionClause(
1665 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1666 ReductionId, UnresolvedReductions);
1680 return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc,
1681 Modifier, ModifierLoc, ColonLoc,
1694 return getSema().ActOnOpenMPAlignedClause(VarList, Alignment, StartLoc,
1695 LParenLoc, ColonLoc, EndLoc);
1706 return getSema().ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc,
1718 return getSema().ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc,
1730 return getSema().ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc,
1743 return getSema().ActOnOpenMPDependClause(DepKind, DepLoc, ColonLoc, VarList,
1744 StartLoc, LParenLoc, EndLoc);
1754 return getSema().ActOnOpenMPDeviceClause(Device, StartLoc, LParenLoc,
1768 return getSema().ActOnOpenMPMapClause(MapTypeModifier, MapType,
1769 IsMapTypeImplicit, MapLoc, ColonLoc,
1770 VarList, StartLoc, LParenLoc, EndLoc);
1780 return getSema().ActOnOpenMPNumTeamsClause(NumTeams, StartLoc, LParenLoc,
1792 return getSema().ActOnOpenMPThreadLimitClause(ThreadLimit, StartLoc,
1803 return getSema().ActOnOpenMPPriorityClause(Priority, StartLoc, LParenLoc,
1814 return getSema().ActOnOpenMPGrainsizeClause(Grainsize, StartLoc, LParenLoc,
1825 return getSema().ActOnOpenMPNumTasksClause(NumTasks, StartLoc, LParenLoc,
1836 return getSema().ActOnOpenMPHintClause(Hint, StartLoc, LParenLoc, EndLoc);
1848 return getSema().ActOnOpenMPDistScheduleClause(
1849 Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
1860 return getSema().ActOnOpenMPToClause(VarList, StartLoc, LParenLoc, EndLoc);
1871 return getSema().ActOnOpenMPFromClause(VarList, StartLoc, LParenLoc,
1883 return getSema().ActOnOpenMPUseDevicePtrClause(VarList, StartLoc, LParenLoc,
1895 return getSema().ActOnOpenMPIsDevicePtrClause(VarList, StartLoc, LParenLoc,
1905 return getSema().ActOnObjCAtSynchronizedOperand(atLoc,
object);
1914 return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body);
1923 return getSema().ActOnObjCAutoreleasePoolStmt(AtLoc, Body);
1935 StmtResult ForEachStmt = getSema().ActOnObjCForCollectionStmt(ForLoc,
1942 return getSema().FinishObjCForCollectionStmt(ForEachStmt.
get(), Body);
1954 VarDecl *Var = getSema().BuildExceptionDeclaration(
nullptr, Declarator,
1955 StartLoc, IdLoc, Id);
1957 getSema().CurContext->addDecl(Var);
1978 return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers);
1994 if (
DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) {
1995 if (RangeStmt->isSingleDecl()) {
1996 if (
VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
1997 if (RangeVar->isInvalidDecl())
2000 Expr *RangeExpr = RangeVar->getInit();
2003 return getSema().ActOnObjCForCollectionStmt(ForLoc, LoopVar, RangeExpr,
2009 return getSema().BuildCXXForRangeStmt(ForLoc, CoawaitLoc, ColonLoc,
2011 Cond, Inc, LoopVar, RParenLoc,
2024 return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
2025 QualifierLoc, NameInfo, Nested);
2033 return getSema().FinishCXXForRangeStmt(ForRange, Body);
2038 return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler);
2043 return getSema().ActOnSEHExceptBlock(Loc, FilterExpr, Block);
2056 return getSema().BuildPredefinedExpr(Loc, IT);
2066 return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
2079 SS.
Adopt(QualifierLoc);
2083 return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD);
2092 return getSema().ActOnParenExpr(LParen, RParen, SubExpr);
2115 return getSema().BuildUnaryOp(
nullptr, OpLoc, Opc, SubExpr);
2126 return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
2139 return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R);
2151 = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind);
2166 return getSema().ActOnArraySubscriptExpr(
nullptr, LHS,
2179 return getSema().ActOnOMPArraySectionExpr(Base, LBracketLoc, LowerBound,
2180 ColonLoc, Length, RBracketLoc);
2190 Expr *ExecConfig =
nullptr) {
2191 return getSema().ActOnCallExpr(
nullptr, Callee, LParenLoc,
2192 Args, RParenLoc, ExecConfig);
2214 assert(!QualifierLoc &&
"Can't have an unnamed field with a qualifier!");
2216 "unnamed member not of record type?");
2219 getSema().PerformObjectMemberConversion(BaseResult.get(),
2222 if (BaseResult.isInvalid())
2224 Base = BaseResult.get();
2227 MemberExpr(Base, isArrow, OpLoc, Member, MemberNameInfo,
2228 cast<FieldDecl>(Member)->getType(), VK,
OK_Ordinary);
2233 SS.
Adopt(QualifierLoc);
2235 Base = BaseResult.
get();
2247 return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow,
2249 FirstQualifierInScope,
2250 R, ExplicitTemplateArgs,
2261 return getSema().BuildBinOp(
nullptr, OpLoc, Opc, LHS, RHS);
2273 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond,
2285 return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
2297 return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
2312 return getSema().BuildMemberReferenceExpr(Base, Base->
getType(),
2330 = SemaRef.ActOnInitList(LBraceLoc, Inits, RBraceLoc);
2351 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
2375 return getSema().BuildVAArgExpr(BuiltinLoc,
2387 return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs);
2397 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label);
2407 return getSema().ActOnStmtExpr(LParenLoc, SubStmt, RParenLoc);
2417 return SemaRef.ActOnChooseExpr(BuiltinLoc,
2429 Expr *ControllingExpr,
2432 return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
2433 ControllingExpr, Types, Exprs);
2465 case Stmt::CXXStaticCastExprClass:
2466 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
2467 RAngleLoc, LParenLoc,
2468 SubExpr, RParenLoc);
2470 case Stmt::CXXDynamicCastExprClass:
2471 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
2472 RAngleLoc, LParenLoc,
2473 SubExpr, RParenLoc);
2475 case Stmt::CXXReinterpretCastExprClass:
2476 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
2477 RAngleLoc, LParenLoc,
2481 case Stmt::CXXConstCastExprClass:
2482 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
2483 RAngleLoc, LParenLoc,
2484 SubExpr, RParenLoc);
2487 llvm_unreachable(
"Invalid C++ named cast");
2502 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
2519 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
2536 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
2553 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
2567 return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc,
2580 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2593 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2605 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
2617 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
2629 getSema().CheckCXXThisCapture(ThisLoc);
2630 return new (getSema().Context)
CXXThisExpr(ThisLoc, ThisType, isImplicit);
2638 bool IsThrownVariableInScope) {
2639 return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope);
2669 return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc,
2687 Expr *Initializer) {
2688 return getSema().BuildCXXNew(StartLoc, UseGlobal,
2705 bool IsGlobalDelete,
2708 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
2720 return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc);
2732 return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc);
2743 return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc);
2756 bool IsAddressOfOperand,
2759 SS.
Adopt(QualifierLoc);
2761 if (TemplateArgs || TemplateKWLoc.
isValid())
2762 return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc, NameInfo,
2765 return getSema().BuildQualifiedDeclarationNameExpr(
2766 SS, NameInfo, IsAddressOfOperand,
nullptr, RecoveryTSI);
2778 return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL,
2791 bool HadMultipleCandidates,
2792 bool ListInitialization,
2793 bool StdInitListInitialization,
2794 bool RequiresZeroInit,
2798 if (getSema().CompleteConstructorCall(Constructor, Args, Loc,
2802 return getSema().BuildCXXConstructExpr(Loc, T, Constructor,
2805 HadMultipleCandidates,
2807 StdInitListInitialization,
2808 RequiresZeroInit, ConstructKind,
2816 bool ConstructsVBase,
2817 bool InheritedFromVBase) {
2819 Loc, T, Constructor, ConstructsVBase, InheritedFromVBase);
2830 return getSema().BuildCXXTypeConstructExpr(TSInfo,
2844 return getSema().BuildCXXTypeConstructExpr(TSInfo,
2864 SS.
Adopt(QualifierLoc);
2866 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
2867 OperatorLoc, IsArrow,
2869 FirstQualifierInScope,
2871 TemplateArgs,
nullptr);
2887 SS.
Adopt(QualifierLoc);
2889 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
2890 OperatorLoc, IsArrow,
2892 FirstQualifierInScope,
2893 R, TemplateArgs,
nullptr);
2901 return SemaRef.BuildCXXNoexceptExpr(Range.
getBegin(), Arg, Range.
getEnd());
2912 RParenLoc, Length, PartialArgs);
2920 return getSema().BuildObjCBoxedExpr(SR, ValueExpr);
2928 Expr **Elements,
unsigned NumElements) {
2929 return getSema().BuildObjCArrayLiteral(Range,
2937 return getSema().BuildObjCSubscriptExpression(RB, Base, Key,
2938 getterMethod, setterMethod);
2947 return getSema().BuildObjCDictionaryLiteral(Range, Elements);
2957 return SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo, RParenLoc);
2968 return SemaRef.BuildClassMessage(ReceiverTypeInfo,
2971 Sel, Method, LBracLoc, SelectorLocs,
2983 return SemaRef.BuildInstanceMessage(Receiver,
2986 Sel, Method, LBracLoc, SelectorLocs,
3002 Sel, Method, LBracLoc, SelectorLocs,
3004 : SemaRef.BuildClassMessage(
nullptr,
3007 Sel, Method, LBracLoc, SelectorLocs,
3019 bool IsArrow,
bool IsFreeIvar) {
3028 if (IsFreeIvar && Result.isUsable())
3029 cast<ObjCIvarRefExpr>(Result.get())->setIsFreeIvar(IsFreeIvar);
3042 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->
getType(),
3065 PropertyLoc, Base));
3076 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->
getType(),
3094 = SemaRef.Context.Idents.get(
"__builtin_shufflevector");
3097 assert(!Lookup.
empty() &&
"No __builtin_shufflevector?");
3102 SemaRef.Context.BuiltinFnTy,
3104 QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType());
3105 Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy,
3106 CK_BuiltinFnToFnPtr).get();
3110 SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(),
3114 return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.
get()));
3121 return SemaRef.SemaConvertVectorExpr(SrcExpr, DstTInfo,
3122 BuiltinLoc, RParenLoc);
3137 EllipsisLoc, NumExpansions);
3158 llvm_unreachable(
"Pack expansion pattern has no parameter packs");
3180 return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions);
3191 return getSema().BuildCXXFoldExpr(LParenLoc, LHS, Operator, EllipsisLoc,
3201 return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator);
3216 return new (SemaRef.Context)
AtomicExpr(BuiltinLoc, SubExprs, RetTy, Op,
3237 bool DeducibleTSTContext);
3240 template<
typename Derived>
3249 #define STMT(Node, Parent) \
3250 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
3251 #define ABSTRACT_STMT(Node)
3252 #define EXPR(Node, Parent)
3253 #include "clang/AST/StmtNodes.inc"
3256 #define STMT(Node, Parent)
3257 #define ABSTRACT_STMT(Stmt)
3258 #define EXPR(Node, Parent) case Stmt::Node##Class:
3259 #include "clang/AST/StmtNodes.inc"
3261 ExprResult E = getDerived().TransformExpr(cast<Expr>(S));
3265 return getSema().ActOnExprStmt(E);
3272 template<
typename Derived>
3280 #define OPENMP_CLAUSE(Name, Class) \
3281 case OMPC_ ## Name : \
3282 return getDerived().Transform ## Class(cast<Class>(S));
3283 #include "clang/Basic/OpenMPKinds.def"
3290 template<
typename Derived>
3297 #define STMT(Node, Parent) case Stmt::Node##Class: break;
3298 #define ABSTRACT_STMT(Stmt)
3299 #define EXPR(Node, Parent) \
3300 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
3301 #include "clang/AST/StmtNodes.inc"
3307 template<
typename Derived>
3316 Init = ExprTemp->getSubExpr();
3318 if (
auto *AIL = dyn_cast<ArrayInitLoopExpr>(Init))
3319 Init = AIL->getCommonExpr();
3322 Init = MTE->GetTemporaryExpr();
3325 Init = Binder->getSubExpr();
3328 Init = ICE->getSubExprAsWritten();
3331 dyn_cast<CXXStdInitializerListExpr>(Init))
3332 return TransformInitializer(ILE->getSubExpr(), NotCopyInit);
3338 if (!NotCopyInit && !(Construct && Construct->isListInitialization()))
3339 return getDerived().TransformExpr(Init);
3344 return getDerived().RebuildParenListExpr(Parens.
getBegin(),
None,
3349 if (isa<ImplicitValueInitExpr>(Init))
3355 if (!Construct || isa<CXXTemporaryObjectExpr>(Construct))
3356 return getDerived().TransformExpr(Init);
3360 if (Construct && Construct->isStdInitListInitialization())
3361 return TransformInitializer(Construct->getArg(0), NotCopyInit);
3364 bool ArgChanged =
false;
3365 if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(),
3366 true, NewArgs, &ArgChanged))
3370 if (Construct->isListInitialization())
3371 return getDerived().RebuildInitList(Construct->getLocStart(), NewArgs,
3372 Construct->getLocEnd(),
3373 Construct->getType());
3376 SourceRange Parens = Construct->getParenOrBraceRange();
3380 assert(NewArgs.empty() &&
3381 "no parens or braces but have direct init with arguments?");
3384 return getDerived().RebuildParenListExpr(Parens.
getBegin(), NewArgs,
3388 template<
typename Derived>
3394 for (
unsigned I = 0;
I != NumInputs; ++
I) {
3396 if (IsCall && getDerived().DropCallArgument(Inputs[
I])) {
3404 Expr *Pattern = Expansion->getPattern();
3407 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
3408 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
3413 bool RetainExpansion =
false;
3416 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
3419 Expand, RetainExpansion,
3428 ExprResult OutPattern = getDerived().TransformExpr(Pattern);
3432 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.
get(),
3433 Expansion->getEllipsisLoc(),
3440 Outputs.push_back(Out.
get());
3446 if (ArgChanged) *ArgChanged =
true;
3450 for (
unsigned I = 0; I != *NumExpansions; ++
I) {
3452 ExprResult Out = getDerived().TransformExpr(Pattern);
3457 Out = getDerived().RebuildPackExpansion(
3458 Out.
get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
3463 Outputs.push_back(Out.
get());
3468 if (RetainExpansion) {
3469 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
3471 ExprResult Out = getDerived().TransformExpr(Pattern);
3475 Out = getDerived().RebuildPackExpansion(
3476 Out.
get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
3480 Outputs.push_back(Out.
get());
3487 IsCall ? getDerived().TransformInitializer(Inputs[I],
false)
3488 : getDerived().TransformExpr(Inputs[I]);
3492 if (Result.
get() != Inputs[
I] && ArgChanged)
3495 Outputs.push_back(Result.
get());
3501 template <
typename Derived>
3505 VarDecl *ConditionVar = cast_or_null<VarDecl>(
3506 getDerived().TransformDefinition(Var->
getLocation(), Var));
3511 return getSema().ActOnConditionVariable(ConditionVar, Loc, Kind);
3515 ExprResult CondExpr = getDerived().TransformExpr(Expr);
3520 return getSema().ActOnCondition(
nullptr, Loc, CondExpr.
get(),
Kind);
3526 template<
typename Derived>
3535 Qualifiers.push_back(Qualifier);
3538 while (!Qualifiers.empty()) {
3546 if (SemaRef.BuildCXXNestedNameSpecifier(
nullptr, IdInfo,
false,
3547 SS, FirstQualifierInScope,
false))
3554 = cast_or_null<NamespaceDecl>(
3555 getDerived().TransformDecl(
3564 = cast_or_null<NamespaceAliasDecl>(
3580 cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
3589 FirstQualifierInScope, SS);
3595 (SemaRef.getLangOpts().CPlusPlus11 &&
3598 "Can't get cv-qualifiers here");
3601 diag::warn_cxx98_compat_enum_nested_name_spec);
3610 SemaRef.Diag(TL.
getBeginLoc(), diag::err_nested_name_spec_non_tag)
3618 FirstQualifierInScope =
nullptr;
3624 !getDerived().AlwaysRebuild())
3637 template<
typename Derived>
3657 TemplateDecl *NewTemplate = cast_or_null<TemplateDecl>(
3658 getDerived().TransformDecl(NameInfo.
getLoc(), OldTemplate));
3664 SemaRef.Context.DeclarationNames.getCXXDeductionGuideName(NewTemplate));
3674 NewTInfo = getDerived().TransformType(OldTInfo);
3677 NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->
getType());
3685 NewCanTy = SemaRef.Context.getCanonicalType(NewT);
3689 = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.
getNameKind(),
3698 llvm_unreachable(
"Unknown name kind.");
3701 template<
typename Derived>
3708 bool AllowInjectedClassName) {
3711 assert(Template &&
"qualified template name must refer to a template");
3714 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
3719 if (!getDerived().AlwaysRebuild() &&
3721 TransTemplate == Template)
3724 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
3732 FirstQualifierInScope =
nullptr;
3735 if (!getDerived().AlwaysRebuild() &&
3740 if (DTN->isIdentifier()) {
3741 return getDerived().RebuildTemplateName(SS,
3742 *DTN->getIdentifier(),
3745 FirstQualifierInScope,
3746 AllowInjectedClassName);
3749 return getDerived().RebuildTemplateName(SS, DTN->getOperator(), NameLoc,
3750 ObjectType, AllowInjectedClassName);
3755 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
3760 if (!getDerived().AlwaysRebuild() &&
3761 TransTemplate == Template)
3770 = cast_or_null<TemplateTemplateParmDecl>(
3771 getDerived().TransformDecl(NameLoc, SubstPack->getParameterPack()));
3775 if (!getDerived().AlwaysRebuild() &&
3776 TransParam == SubstPack->getParameterPack())
3779 return getDerived().RebuildTemplateName(TransParam,
3780 SubstPack->getArgumentPack());
3784 llvm_unreachable(
"overloaded function decl survived to here");
3787 template<
typename Derived>
3794 llvm_unreachable(
"null template argument in TreeTransform");
3799 SemaRef.Context.getTrivialTypeSourceInfo(Arg.
getAsType(), Loc));
3808 Builder.
MakeTrivial(SemaRef.Context, DTN->getQualifier(), Loc);
3810 Builder.
MakeTrivial(SemaRef.Context, QTN->getQualifier(), Loc);
3837 template<
typename Derived>
3848 llvm_unreachable(
"Unexpected TemplateArgument");
3855 DI = getDerived().TransformType(DI);
3856 if (!DI)
return true;
3865 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
3871 SS.
Adopt(QualifierLoc);
3873 = getDerived().TransformTemplateName(SS, Arg.
getAsTemplate(),
3884 llvm_unreachable(
"Caller should expand pack expansions");
3896 ExprResult E = getDerived().TransformExpr(InputExpr);
3897 E = SemaRef.ActOnConstantExpression(E);
3910 template<
typename Derived,
typename InputIterator>
3918 typedef typename std::iterator_traits<InputIterator>::difference_type
3935 : Self(Self), Iter(Iter) { }
3950 Self.InventTemplateArgumentLoc(*Iter, Result);
3958 return X.Iter == Y.Iter;
3963 return X.Iter != Y.Iter;
3967 template<
typename Derived>
3968 template<
typename InputIterator>
3972 for (; First != Last; ++First) {
3985 if (TransformTemplateArguments(PackLocIterator(*
this,
3987 PackLocIterator(*
this,
4001 = getSema().getTemplateArgumentPackExpansionPattern(
4002 In, Ellipsis, OrigNumExpansions);
4005 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
4006 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
4011 bool RetainExpansion =
false;
4013 if (getDerived().TryExpandParameterPacks(Ellipsis,
4027 if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))
4030 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,
4041 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
4044 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
4048 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
4059 if (RetainExpansion) {
4060 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4062 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
4065 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
4077 if (getDerived().TransformTemplateArgument(In, Out, Uneval))
4091 template<
typename Derived>
4093 if (getDerived().AlreadyTransformed(T))
4098 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
4099 getDerived().getBaseLocation());
4109 template<
typename Derived>
4113 getDerived().getBaseEntity());
4114 if (getDerived().AlreadyTransformed(DI->
getType()))
4129 template<
typename Derived>
4133 #define ABSTRACT_TYPELOC(CLASS, PARENT)
4134 #define TYPELOC(CLASS, PARENT) \
4135 case TypeLoc::CLASS: \
4136 return getDerived().Transform##CLASS##Type(TLB, \
4137 T.castAs<CLASS##TypeLoc>());
4138 #include "clang/AST/TypeLocNodes.def"
4141 llvm_unreachable(
"unhandled type loc!");
4144 template<
typename Derived>
4146 if (!isa<DependentNameType>(T))
4147 return TransformType(T);
4149 if (getDerived().AlreadyTransformed(T))
4151 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
4152 getDerived().getBaseLocation());
4153 TypeSourceInfo *NewDI = getDerived().TransformTypeWithDeducedTST(DI);
4157 template<
typename Derived>
4160 if (!isa<DependentNameType>(DI->
getType()))
4161 return TransformType(DI);
4165 getDerived().getBaseEntity());
4166 if (getDerived().AlreadyTransformed(DI->
getType()))
4183 if (Result.isNull())
4187 Result = getDerived().RebuildQualifiedType(
4188 Result, QTL.getBeginLoc(), QTL.getType().getLocalQualifiers());
4195 template<
typename Derived>
4205 Result = getDerived().RebuildQualifiedType(Result, T.
getBeginLoc(), Quals);
4215 template<
typename Derived>
4242 = dyn_cast<SubstTemplateTypeParmType>(T)) {
4246 Replacement = SemaRef.Context.getQualifiedType(
4248 T = SemaRef.Context.getSubstTemplateTypeParmType(
4249 SubstTypeParam->getReplacedParameter(),
Replacement);
4250 }
else if ((AutoTy = dyn_cast<AutoType>(T)) && AutoTy->
isDeduced()) {
4257 T = SemaRef.Context.getAutoType(Deduced, AutoTy->
getKeyword(),
4263 SemaRef.Diag(Loc, diag::err_attr_objc_ownership_redundant) << T;
4269 return SemaRef.BuildQualifiedType(T, Loc, Quals);
4272 template<
typename Derived>
4278 if (getDerived().AlreadyTransformed(TL.
getType()))
4282 TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
4288 template<
typename Derived>
4290 TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
4291 QualType ObjectType,
4292 NamedDecl *UnqualLookup,
4294 if (getDerived().AlreadyTransformed(TSInfo->getType()))
4297 return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType,
4301 template <
typename Derived>
4302 TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope(
4303 TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup,
4306 assert(!getDerived().AlreadyTransformed(T));
4311 if (isa<TemplateSpecializationType>(T)) {
4312 TemplateSpecializationTypeLoc SpecTL =
4313 TL.castAs<TemplateSpecializationTypeLoc>();
4315 TemplateName Template = getDerived().TransformTemplateName(
4316 SS, SpecTL.getTypePtr()->getTemplateName(), SpecTL.getTemplateNameLoc(),
4317 ObjectType, UnqualLookup,
true);
4318 if (Template.isNull())
4321 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL,
4323 }
else if (isa<DependentTemplateSpecializationType>(T)) {
4324 DependentTemplateSpecializationTypeLoc SpecTL =
4325 TL.castAs<DependentTemplateSpecializationTypeLoc>();
4327 TemplateName Template
4328 = getDerived().RebuildTemplateName(SS,
4329 *SpecTL.getTypePtr()->getIdentifier(),
4330 SpecTL.getTemplateNameLoc(),
4331 ObjectType, UnqualLookup,
4333 if (Template.isNull())
4336 Result = getDerived().TransformDependentTemplateSpecializationType(TLB,
4342 Result = getDerived().TransformType(TLB, TL);
4345 if (Result.isNull())
4348 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
4351 template <
class TyLoc>
static inline
4353 TyLoc NewT = TLB.
push<TyLoc>(T.getType());
4354 NewT.setNameLoc(T.getNameLoc());
4358 template<
typename Derived>
4359 QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
4361 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType());
4362 NewT.setBuiltinLoc(T.getBuiltinLoc());
4363 if (T.needsExtraLocalData())
4364 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs();
4368 template<
typename Derived>
4369 QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
4375 template <
typename Derived>
4376 QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB,
4377 AdjustedTypeLoc TL) {
4379 return getDerived().TransformType(TLB, TL.getOriginalLoc());
4382 template<
typename Derived>
4383 QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB,
4384 DecayedTypeLoc TL) {
4385 QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc());
4386 if (OriginalType.isNull())
4389 QualType Result = TL.getType();
4390 if (getDerived().AlwaysRebuild() ||
4391 OriginalType != TL.getOriginalLoc().getType())
4392 Result = SemaRef.Context.getDecayedType(OriginalType);
4393 TLB.push<DecayedTypeLoc>(Result);
4398 template<
typename Derived>
4399 QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
4400 PointerTypeLoc TL) {
4401 QualType PointeeType
4402 = getDerived().TransformType(TLB, TL.getPointeeLoc());
4403 if (PointeeType.isNull())
4406 QualType Result = TL.getType();
4407 if (PointeeType->getAs<ObjCObjectType>()) {
4412 Result = SemaRef.Context.getObjCObjectPointerType(PointeeType);
4414 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
4415 NewT.setStarLoc(TL.getStarLoc());
4419 if (getDerived().AlwaysRebuild() ||
4420 PointeeType != TL.getPointeeLoc().getType()) {
4421 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
4422 if (Result.isNull())
4428 TLB.TypeWasModifiedSafely(Result->getPointeeType());
4430 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result);
4431 NewT.setSigilLoc(TL.getSigilLoc());
4435 template<
typename Derived>
4437 TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
4438 BlockPointerTypeLoc TL) {
4439 QualType PointeeType
4440 = getDerived().TransformType(TLB, TL.getPointeeLoc());
4441 if (PointeeType.isNull())
4444 QualType Result = TL.getType();
4445 if (getDerived().AlwaysRebuild() ||
4446 PointeeType != TL.getPointeeLoc().getType()) {
4447 Result = getDerived().RebuildBlockPointerType(PointeeType,
4449 if (Result.isNull())
4453 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result);
4454 NewT.setSigilLoc(TL.getSigilLoc());
4462 template<
typename Derived>
4470 if (PointeeType.
isNull())
4474 if (getDerived().AlwaysRebuild() ||
4476 Result = getDerived().RebuildReferenceType(PointeeType,
4490 if (isa<LValueReferenceType>(Result))
4499 template<
typename Derived>
4503 return TransformReferenceType(TLB, TL);
4506 template<
typename Derived>
4508 TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
4509 RValueReferenceTypeLoc TL) {
4510 return TransformReferenceType(TLB, TL);
4513 template<
typename Derived>
4515 TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
4516 MemberPointerTypeLoc TL) {
4517 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
4518 if (PointeeType.isNull())
4521 TypeSourceInfo* OldClsTInfo = TL.getClassTInfo();
4522 TypeSourceInfo *NewClsTInfo =
nullptr;
4524 NewClsTInfo = getDerived().TransformType(OldClsTInfo);
4529 const MemberPointerType *T = TL.getTypePtr();
4530 QualType OldClsType = QualType(T->getClass(), 0);
4531 QualType NewClsType;
4533 NewClsType = NewClsTInfo->getType();
4535 NewClsType = getDerived().TransformType(OldClsType);
4536 if (NewClsType.isNull())
4540 QualType Result = TL.getType();
4541 if (getDerived().AlwaysRebuild() ||
4542 PointeeType != T->getPointeeType() ||
4543 NewClsType != OldClsType) {
4544 Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType,
4546 if (Result.isNull())
4552 const MemberPointerType *MPT = Result->getAs<MemberPointerType>();
4553 if (MPT && PointeeType != MPT->getPointeeType()) {
4554 assert(isa<AdjustedType>(MPT->getPointeeType()));
4555 TLB.push<AdjustedTypeLoc>(MPT->getPointeeType());
4558 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
4559 NewTL.setSigilLoc(TL.getSigilLoc());
4560 NewTL.setClassTInfo(NewClsTInfo);
4565 template<
typename Derived>
4567 TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
4568 ConstantArrayTypeLoc TL) {
4569 const ConstantArrayType *T = TL.getTypePtr();
4570 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4571 if (ElementType.isNull())
4574 QualType Result = TL.getType();
4575 if (getDerived().AlwaysRebuild() ||
4576 ElementType != T->getElementType()) {
4577 Result = getDerived().RebuildConstantArrayType(ElementType,
4578 T->getSizeModifier(),
4580 T->getIndexTypeCVRQualifiers(),
4581 TL.getBracketsRange());
4582 if (Result.isNull())
4590 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4591 NewTL.setLBracketLoc(TL.getLBracketLoc());
4592 NewTL.setRBracketLoc(TL.getRBracketLoc());
4594 Expr *Size = TL.getSizeExpr();
4596 EnterExpressionEvaluationContext Unevaluated(
4598 Size = getDerived().TransformExpr(Size).template getAs<Expr>();
4599 Size = SemaRef.ActOnConstantExpression(Size).get();
4601 NewTL.setSizeExpr(Size);
4606 template<
typename Derived>
4607 QualType TreeTransform<Derived>::TransformIncompleteArrayType(
4608 TypeLocBuilder &TLB,
4609 IncompleteArrayTypeLoc TL) {
4610 const IncompleteArrayType *T = TL.getTypePtr();
4611 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4612 if (ElementType.isNull())
4615 QualType Result = TL.getType();
4616 if (getDerived().AlwaysRebuild() ||
4617 ElementType != T->getElementType()) {
4618 Result = getDerived().RebuildIncompleteArrayType(ElementType,
4619 T->getSizeModifier(),
4620 T->getIndexTypeCVRQualifiers(),
4621 TL.getBracketsRange());
4622 if (Result.isNull())
4626 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
4627 NewTL.setLBracketLoc(TL.getLBracketLoc());
4628 NewTL.setRBracketLoc(TL.getRBracketLoc());
4629 NewTL.setSizeExpr(
nullptr);
4634 template<
typename Derived>
4636 TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
4637 VariableArrayTypeLoc TL) {
4638 const VariableArrayType *T = TL.getTypePtr();
4639 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4640 if (ElementType.isNull())
4645 EnterExpressionEvaluationContext
Context(
4647 SizeResult = getDerived().TransformExpr(T->getSizeExpr());
4649 if (SizeResult.isInvalid())
4651 SizeResult = SemaRef.ActOnFinishFullExpr(SizeResult.get());
4652 if (SizeResult.isInvalid())
4655 Expr *Size = SizeResult.get();
4657 QualType Result = TL.getType();
4658 if (getDerived().AlwaysRebuild() ||
4659 ElementType != T->getElementType() ||
4660 Size != T->getSizeExpr()) {
4661 Result = getDerived().RebuildVariableArrayType(ElementType,
4662 T->getSizeModifier(),
4664 T->getIndexTypeCVRQualifiers(),
4665 TL.getBracketsRange());
4666 if (Result.isNull())
4672 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4673 NewTL.setLBracketLoc(TL.getLBracketLoc());
4674 NewTL.setRBracketLoc(TL.getRBracketLoc());
4675 NewTL.setSizeExpr(Size);
4680 template<
typename Derived>
4682 TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
4683 DependentSizedArrayTypeLoc TL) {
4684 const DependentSizedArrayType *T = TL.getTypePtr();
4685 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4686 if (ElementType.isNull())
4690 EnterExpressionEvaluationContext Unevaluated(
4694 Expr *origSize = TL.getSizeExpr();
4695 if (!origSize) origSize = T->getSizeExpr();
4698 = getDerived().TransformExpr(origSize);
4699 sizeResult = SemaRef.ActOnConstantExpression(sizeResult);
4700 if (sizeResult.isInvalid())
4703 Expr *size = sizeResult.
get();
4705 QualType Result = TL.
getType();
4706 if (getDerived().AlwaysRebuild() ||
4707 ElementType != T->getElementType() ||
4709 Result = getDerived().RebuildDependentSizedArrayType(ElementType,
4710 T->getSizeModifier(),
4712 T->getIndexTypeCVRQualifiers(),
4713 TL.getBracketsRange());
4714 if (Result.isNull())
4720 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4721 NewTL.setLBracketLoc(TL.getLBracketLoc());
4722 NewTL.setRBracketLoc(TL.getRBracketLoc());
4723 NewTL.setSizeExpr(size);
4728 template<
typename Derived>
4729 QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
4730 TypeLocBuilder &TLB,
4731 DependentSizedExtVectorTypeLoc TL) {
4732 const DependentSizedExtVectorType *T = TL.
getTypePtr();
4735 QualType ElementType = getDerived().TransformType(T->getElementType());
4736 if (ElementType.isNull())
4740 EnterExpressionEvaluationContext Unevaluated(
4743 ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
4744 Size = SemaRef.ActOnConstantExpression(Size);
4745 if (Size.isInvalid())
4748 QualType Result = TL.getType();
4749 if (getDerived().AlwaysRebuild() ||
4750 ElementType != T->getElementType() ||
4751 Size.get() != T->getSizeExpr()) {
4752 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
4754 T->getAttributeLoc());
4755 if (Result.isNull())
4760 if (isa<DependentSizedExtVectorType>(Result)) {
4761 DependentSizedExtVectorTypeLoc NewTL
4762 = TLB.push<DependentSizedExtVectorTypeLoc>(Result);
4763 NewTL.setNameLoc(TL.getNameLoc());
4765 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
4766 NewTL.setNameLoc(TL.getNameLoc());
4772 template<
typename Derived>
4773 QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
4775 const VectorType *T = TL.getTypePtr();
4776 QualType ElementType = getDerived().TransformType(T->getElementType());
4777 if (ElementType.isNull())
4780 QualType Result = TL.getType();
4781 if (getDerived().AlwaysRebuild() ||
4782 ElementType != T->getElementType()) {
4783 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(),
4784 T->getVectorKind());
4785 if (Result.isNull())
4789 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
4790 NewTL.setNameLoc(TL.getNameLoc());
4795 template<
typename Derived>
4796 QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
4797 ExtVectorTypeLoc TL) {
4798 const VectorType *T = TL.getTypePtr();
4799 QualType ElementType = getDerived().TransformType(T->getElementType());
4800 if (ElementType.isNull())
4803 QualType Result = TL.getType();
4804 if (getDerived().AlwaysRebuild() ||
4805 ElementType != T->getElementType()) {
4806 Result = getDerived().RebuildExtVectorType(ElementType,
4807 T->getNumElements(),
4809 if (Result.isNull())
4813 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
4814 NewTL.setNameLoc(TL.getNameLoc());
4819 template <
typename Derived>
4822 bool ExpectParameterPack) {
4826 if (NumExpansions && isa<PackExpansionType>(OldDI->
getType())) {
4836 QualType Result = getDerived().TransformType(TLB,
4841 Result = RebuildPackExpansionType(Result,
4851 NewDI = TLB.getTypeSourceInfo(SemaRef.Context, Result);
4853 NewDI = getDerived().TransformType(OldDI);
4857 if (NewDI == OldDI && indexAdjustment == 0)
4874 template <
typename Derived>
4882 int indexAdjustment = 0;
4884 unsigned NumParams = Params.size();
4885 for (
unsigned i = 0; i != NumParams; ++i) {
4887 assert(OldParm->getFunctionScopeIndex() == i);
4891 if (OldParm->isParameterPack()) {
4896 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc();
4899 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
4900 assert(Unexpanded.size() > 0 &&
"Could not find parameter packs!");
4903 bool ShouldExpand =
false;
4904 bool RetainExpansion =
false;
4907 NumExpansions = OrigNumExpansions;
4908 if (getDerived().TryExpandParameterPacks(ExpansionTL.
getEllipsisLoc(),
4909 Pattern.getSourceRange(),
4920 getDerived().ExpandingFunctionParameterPack(OldParm);
4921 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
4924 = getDerived().TransformFunctionTypeParam(OldParm,
4932 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
4933 OutParamTypes.push_back(NewParm->
getType());
4935 PVars->push_back(NewParm);
4940 if (RetainExpansion) {
4941 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4943 = getDerived().TransformFunctionTypeParam(OldParm,
4951 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
4952 OutParamTypes.push_back(NewParm->
getType());
4954 PVars->push_back(NewParm);
4970 NewParm = getDerived().TransformFunctionTypeParam(OldParm,
4975 NewParm = getDerived().TransformFunctionTypeParam(
4976 OldParm, indexAdjustment,
None,
false);
4983 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
4984 OutParamTypes.push_back(NewParm->
getType());
4986 PVars->push_back(NewParm);
4993 bool IsPackExpansion =
false;
4997 = dyn_cast<PackExpansionType>(OldType)) {
4999 QualType Pattern = Expansion->getPattern();
5001 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
5004 bool ShouldExpand =
false;
5005 bool RetainExpansion =
false;
5006 if (getDerived().TryExpandParameterPacks(Loc,
SourceRange(),
5017 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
5019 QualType NewType = getDerived().TransformType(Pattern);
5025 getSema().getASTContext().getPackExpansionType(NewType,
None);
5032 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
5033 OutParamTypes.push_back(NewType);
5035 PVars->push_back(
nullptr);
5044 if (RetainExpansion) {
5045 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
5046 QualType NewType = getDerived().TransformType(Pattern);
5051 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
5052 OutParamTypes.push_back(NewType);
5054 PVars->push_back(
nullptr);
5059 OldType = Expansion->getPattern();
5060 IsPackExpansion =
true;
5062 NewType = getDerived().TransformType(OldType);
5064 NewType = getDerived().TransformType(OldType);
5070 if (IsPackExpansion)
5071 NewType = getSema().Context.getPackExpansionType(NewType,
5075 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
5076 OutParamTypes.push_back(NewType);
5078 PVars->push_back(
nullptr);
5083 for (
unsigned i = 0, e = PVars->size(); i != e; ++i)
5085 assert(parm->getFunctionScopeIndex() == i);
5092 template<
typename Derived>
5099 TLB, TL,
nullptr, 0,
5102 ExceptionStorage, Changed);
5106 template<
typename Derived>
template<
typename Fn>
5109 unsigned ThisTypeQuals, Fn TransformExceptionSpec) {
5126 if (getDerived().TransformFunctionTypeParams(
5130 ParamTypes, &ParamDecls, ExtParamInfos))
5142 ResultType = getDerived().TransformType(TLB, TL.
getReturnLoc());
5148 ResultType = getDerived().TransformType(TLB, TL.
getReturnLoc());
5152 if (getDerived().TransformFunctionTypeParams(
5156 ParamTypes, &ParamDecls, ExtParamInfos))
5162 bool EPIChanged =
false;
5167 if (
auto NewExtParamInfos =
5171 != llvm::makeArrayRef(NewExtParamInfos, ParamTypes.size())) {
5181 if (getDerived().AlwaysRebuild() || ResultType != T->
getReturnType() ||
5182 T->
getParamTypes() != llvm::makeArrayRef(ParamTypes) || EPIChanged) {
5183 Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI);
5194 for (
unsigned i = 0, e = NewTL.
getNumParams(); i != e; ++i)
5200 template<
typename Derived>
5215 NoexceptExpr = getSema().CheckBooleanCondition(Loc, NoexceptExpr.
get());
5220 NoexceptExpr = getSema().VerifyIntegerConstantExpression(
5221 NoexceptExpr.
get(),
nullptr,
5222 diag::err_noexcept_needs_constant_expression,
5244 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
5246 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
5251 bool Expand =
false;
5252 bool RetainExpansion =
false;
5256 if (getDerived().TryExpandParameterPacks(
5258 RetainExpansion, NumExpansions))
5266 QualType U = getDerived().TransformType(PackExpansion->getPattern());
5270 U = SemaRef.Context.getPackExpansionType(U, NumExpansions);
5271 Exceptions.push_back(U);
5277 for (
unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
5280 QualType U = getDerived().TransformType(PackExpansion->getPattern());
5281 if (U.
isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
5284 Exceptions.push_back(U);
5287 QualType U = getDerived().TransformType(T);
5288 if (U.
isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
5293 Exceptions.push_back(U);
5303 template<
typename Derived>
5313 if (getDerived().AlwaysRebuild() || ResultType != T->
getReturnType())
5314 Result = getDerived().RebuildFunctionNoProtoType(ResultType);
5325 template<
typename Derived> QualType
5326 TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB,
5327 UnresolvedUsingTypeLoc TL) {
5328 const UnresolvedUsingType *T = TL.getTypePtr();
5329 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl());
5333 QualType Result = TL.getType();
5334 if (getDerived().AlwaysRebuild() || D != T->getDecl()) {
5335 Result = getDerived().RebuildUnresolvedUsingType(TL.getNameLoc(), D);
5336 if (Result.isNull())
5342 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result);
5343 NewTL.setNameLoc(TL.getNameLoc());
5348 template<
typename Derived>
5349 QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
5350 TypedefTypeLoc TL) {
5352 TypedefNameDecl *Typedef
5353 = cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5358 QualType Result = TL.getType();
5359 if (getDerived().AlwaysRebuild() ||
5360 Typedef != T->getDecl()) {
5361 Result = getDerived().RebuildTypedefType(Typedef);
5362 if (Result.isNull())
5366 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result);
5367 NewTL.setNameLoc(TL.getNameLoc());
5372 template<
typename Derived>
5373 QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
5374 TypeOfExprTypeLoc TL) {
5376 EnterExpressionEvaluationContext Unevaluated(
5380 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
5384 E = SemaRef.HandleExprEvaluationContextForTypeof(E.get());
5388 QualType Result = TL.getType();
5389 if (getDerived().AlwaysRebuild() ||
5390 E.get() != TL.getUnderlyingExpr()) {
5391 Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc());
5392 if (Result.isNull())
5397 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result);
5398 NewTL.setTypeofLoc(TL.getTypeofLoc());
5399 NewTL.setLParenLoc(TL.getLParenLoc());
5400 NewTL.setRParenLoc(TL.getRParenLoc());
5405 template<
typename Derived>
5406 QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
5408 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo();
5409 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);
5413 QualType Result = TL.getType();
5414 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {
5415 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType());
5416 if (Result.isNull())
5420 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result);
5421 NewTL.setTypeofLoc(TL.getTypeofLoc());
5422 NewTL.setLParenLoc(TL.getLParenLoc());
5423 NewTL.setRParenLoc(TL.getRParenLoc());
5424 NewTL.setUnderlyingTInfo(New_Under_TI);
5429 template<
typename Derived>
5430 QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
5431 DecltypeTypeLoc TL) {
5432 const DecltypeType *T = TL.getTypePtr();
5435 EnterExpressionEvaluationContext Unevaluated(
5439 ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
5443 E = getSema().ActOnDecltypeExpression(E.get());
5447 QualType Result = TL.getType();
5448 if (getDerived().AlwaysRebuild() ||
5449 E.get() != T->getUnderlyingExpr()) {
5450 Result = getDerived().RebuildDecltypeType(E.get(), TL.getNameLoc());
5451 if (Result.isNull())
5456 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
5457 NewTL.setNameLoc(TL.getNameLoc());
5462 template<
typename Derived>
5463 QualType TreeTransform<Derived>::TransformUnaryTransformType(
5464 TypeLocBuilder &TLB,
5465 UnaryTransformTypeLoc TL) {
5466 QualType Result = TL.
getType();
5467 if (Result->isDependentType()) {
5468 const UnaryTransformType *T = TL.
getTypePtr();
5470 getDerived().TransformType(TL.getUnderlyingTInfo())->getType();
5471 Result = getDerived().RebuildUnaryTransformType(NewBase,
5474 if (Result.isNull())
5478 UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result);
5479 NewTL.setKWLoc(TL.getKWLoc());
5480 NewTL.setParensRange(TL.getParensRange());
5481 NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo());
5485 template<
typename Derived>
5486 QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
5488 const AutoType *T = TL.getTypePtr();
5489 QualType OldDeduced = T->getDeducedType();
5490 QualType NewDeduced;
5491 if (!OldDeduced.isNull()) {
5492 NewDeduced = getDerived().TransformType(OldDeduced);
5493 if (NewDeduced.isNull())
5497 QualType Result = TL.getType();
5498 if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
5499 T->isDependentType()) {
5500 Result = getDerived().RebuildAutoType(NewDeduced, T->getKeyword());
5501 if (Result.isNull())
5505 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
5506 NewTL.setNameLoc(TL.getNameLoc());
5511 template<
typename Derived>
5512 QualType TreeTransform<Derived>::TransformDeducedTemplateSpecializationType(
5513 TypeLocBuilder &TLB, DeducedTemplateSpecializationTypeLoc TL) {
5514 const DeducedTemplateSpecializationType *T = TL.getTypePtr();
5517 TemplateName TemplateName = getDerived().TransformTemplateName(
5518 SS, T->getTemplateName(), TL.getTemplateNameLoc());
5519 if (TemplateName.isNull())
5522 QualType OldDeduced = T->getDeducedType();
5523 QualType NewDeduced;
5524 if (!OldDeduced.isNull()) {
5525 NewDeduced = getDerived().TransformType(OldDeduced);
5526 if (NewDeduced.isNull())
5530 QualType Result = getDerived().RebuildDeducedTemplateSpecializationType(
5531 TemplateName, NewDeduced);
5532 if (Result.isNull())
5535 DeducedTemplateSpecializationTypeLoc NewTL =
5536 TLB.push<DeducedTemplateSpecializationTypeLoc>(Result);
5537 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5542 template<
typename Derived>
5543 QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,
5545 const RecordType *T = TL.getTypePtr();
5547 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5552 QualType Result = TL.getType();
5553 if (getDerived().AlwaysRebuild() ||
5554 Record != T->getDecl()) {
5555 Result = getDerived().RebuildRecordType(Record);
5556 if (Result.isNull())
5560 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
5561 NewTL.setNameLoc(TL.getNameLoc());
5566 template<
typename Derived>
5567 QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
5569 const EnumType *T = TL.getTypePtr();
5571 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5576 QualType Result = TL.getType();
5577 if (getDerived().AlwaysRebuild() ||
5578 Enum != T->getDecl()) {
5579 Result = getDerived().RebuildEnumType(Enum);
5580 if (Result.isNull())
5584 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result);
5585 NewTL.setNameLoc(TL.getNameLoc());
5590 template<
typename Derived>
5591 QualType TreeTransform<Derived>::TransformInjectedClassNameType(
5592 TypeLocBuilder &TLB,
5593 InjectedClassNameTypeLoc TL) {
5594 Decl *D = getDerived().TransformDecl(TL.getNameLoc(),
5595 TL.getTypePtr()->getDecl());
5596 if (!D)
return QualType();
5598 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D));
5599 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc());
5603 template<
typename Derived>
5604 QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
5605 TypeLocBuilder &TLB,
5606 TemplateTypeParmTypeLoc TL) {
5610 template<
typename Derived>
5611 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
5612 TypeLocBuilder &TLB,
5613 SubstTemplateTypeParmTypeLoc TL) {
5614 const SubstTemplateTypeParmType *T = TL.getTypePtr();
5619 TemporaryBase Rebase(*
this, TL.getNameLoc(), DeclarationName());
5620 QualType
Replacement = getDerived().TransformType(T->getReplacementType());
5621 if (Replacement.isNull())
5625 Replacement = SemaRef.Context.getCanonicalType(Replacement);
5627 = SemaRef.Context.getSubstTemplateTypeParmType(T->getReplacedParameter(),
5631 SubstTemplateTypeParmTypeLoc NewTL
5632 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
5633 NewTL.setNameLoc(TL.getNameLoc());
5638 template<
typename Derived>
5639 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
5640 TypeLocBuilder &TLB,
5641 SubstTemplateTypeParmPackTypeLoc TL) {
5645 template<
typename Derived>
5654 TemplateName Template
5660 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template);
5663 template<
typename Derived>
5671 if (getDerived().AlwaysRebuild() ||
5673 Result = getDerived().RebuildAtomicType(ValueType, TL.
getKWLoc());
5678 AtomicTypeLoc NewTL = TLB.
push<AtomicTypeLoc>(Result);
5686 template <
typename Derived>
5687 QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB,
5689 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
5690 if (ValueType.isNull())
5693 QualType Result = TL.getType();
5694 if (getDerived().AlwaysRebuild() || ValueType != TL.getValueLoc().getType()) {
5695 const PipeType *PT = Result->
getAs<PipeType>();
5696 bool isReadPipe = PT->isReadOnly();
5697 Result = getDerived().RebuildPipeType(ValueType, TL.getKWLoc(), isReadPipe);
5698 if (Result.isNull())
5702 PipeTypeLoc NewTL = TLB.push<PipeTypeLoc>(Result);
5703 NewTL.setKWLoc(TL.getKWLoc());
5713 template<
typename ArgLocContainer>
5715 ArgLocContainer *Container;
5740 : Container(&Container), Index(Index) { }
5754 return Container->getArgLoc(Index);
5758 return pointer(Container->getArgLoc(Index));
5763 return X.Container == Y.Container && X.Index == Y.Index;
5773 template <
typename Derived>
5775 TypeLocBuilder &TLB,
5776 TemplateSpecializationTypeLoc TL,
5777 TemplateName Template) {
5778 TemplateArgumentListInfo NewTemplateArgs;
5779 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
5780 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
5781 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>
5783 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5784 ArgIterator(TL, TL.getNumArgs()),
5791 getDerived().RebuildTemplateSpecializationType(Template,
5792 TL.getTemplateNameLoc(),
5795 if (!Result.isNull()) {
5800 if (isa<DependentTemplateSpecializationType>(Result)) {
5801 DependentTemplateSpecializationTypeLoc NewTL
5802 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
5803 NewTL.setElaboratedKeywordLoc(SourceLocation());
5804 NewTL.setQualifierLoc(NestedNameSpecifierLoc());
5805 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5806 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5807 NewTL.setLAngleLoc(TL.getLAngleLoc());
5808 NewTL.setRAngleLoc(TL.getRAngleLoc());
5809 for (
unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
5810 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
5814 TemplateSpecializationTypeLoc NewTL
5815 = TLB.push<TemplateSpecializationTypeLoc>(Result);
5816 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5817 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5818 NewTL.setLAngleLoc(TL.getLAngleLoc());
5819 NewTL.setRAngleLoc(TL.getRAngleLoc());
5820 for (
unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
5821 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
5827 template <
typename Derived>
5831 TemplateName Template,
5838 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5847 = getSema().Context.getDependentTemplateSpecializationType(
5849 DTN->getQualifier(),
5850 DTN->getIdentifier(),
5861 for (
unsigned i = 0, e = NewTemplateArgs.
size(); i != e; ++i)
5867 = getDerived().RebuildTemplateSpecializationType(Template,
5879 for (
unsigned i = 0, e = NewTemplateArgs.
size(); i != e; ++i)
5886 template<
typename Derived>
5901 QualType NamedT = getDerived().TransformType(TLB, TL.
getNamedTypeLoc());
5902 if (NamedT.isNull())
5910 if (
const TemplateSpecializationType *TST =
5911 NamedT->getAs<TemplateSpecializationType>()) {
5912 TemplateName Template = TST->getTemplateName();
5913 if (TypeAliasTemplateDecl *TAT = dyn_cast_or_null<TypeAliasTemplateDecl>(
5914 Template.getAsTemplateDecl())) {
5916 diag::err_tag_reference_non_tag)
5919 SemaRef.Diag(TAT->getLocation(), diag::note_declared_at);
5924 QualType Result = TL.
getType();
5925 if (getDerived().AlwaysRebuild() ||
5930 QualifierLoc, NamedT);
5931 if (Result.isNull())
5935 ElaboratedTypeLoc NewTL = TLB.
push<ElaboratedTypeLoc>(Result);
5937 NewTL.setQualifierLoc(QualifierLoc);
5941 template<
typename Derived>
5942 QualType TreeTransform<Derived>::TransformAttributedType(
5943 TypeLocBuilder &TLB,
5944 AttributedTypeLoc TL) {
5946 QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc());
5947 if (modifiedType.isNull())
5950 QualType result = TL.getType();
5953 if (getDerived().AlwaysRebuild() ||
5954 modifiedType != oldType->getModifiedType()) {
5957 QualType equivalentType
5958 = getDerived().TransformType(oldType->getEquivalentType());
5959 if (equivalentType.isNull())
5964 if (
auto nullability = oldType->getImmediateNullability()) {
5965 if (!modifiedType->canHaveNullability()) {
5966 SemaRef.Diag(TL.getAttrNameLoc(), diag::err_nullability_nonpointer)
5972 result = SemaRef.Context.getAttributedType(oldType->getAttrKind(),
5977 AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result);
5978 newTL.setAttrNameLoc(TL.getAttrNameLoc());
5979 if (TL.hasAttrOperand())
5980 newTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5981 if (TL.hasAttrExprOperand())
5982 newTL.setAttrExprOperand(TL.getAttrExprOperand());
5983 else if (TL.hasAttrEnumOperand())
5984 newTL.setAttrEnumOperandLoc(TL.getAttrEnumOperandLoc());
5989 template<
typename Derived>
5991 TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB,
5993 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
5997 QualType Result = TL.getType();
5998 if (getDerived().AlwaysRebuild() ||
5999 Inner != TL.getInnerLoc().getType()) {
6000 Result = getDerived().RebuildParenType(Inner);
6001 if (Result.isNull())
6005 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result);
6006 NewTL.setLParenLoc(TL.getLParenLoc());
6007 NewTL.setRParenLoc(TL.getRParenLoc());
6011 template<
typename Derived>
6012 QualType TreeTransform<Derived>::TransformDependentNameType(
6013 TypeLocBuilder &TLB, DependentNameTypeLoc TL) {
6014 return TransformDependentNameType(TLB, TL,
false);
6017 template<
typename Derived>
6018 QualType TreeTransform<Derived>::TransformDependentNameType(
6019 TypeLocBuilder &TLB, DependentNameTypeLoc TL,
bool DeducedTSTContext) {
6020 const DependentNameType *T = TL.getTypePtr();
6022 NestedNameSpecifierLoc QualifierLoc
6023 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
6028 = getDerived().RebuildDependentNameType(T->getKeyword(),
6029 TL.getElaboratedKeywordLoc(),
6034 if (Result.isNull())
6037 if (
const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) {
6038 QualType NamedT = ElabT->getNamedType();
6039 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc());
6041 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
6042 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
6043 NewTL.setQualifierLoc(QualifierLoc);
6045 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result);
6046 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
6047 NewTL.setQualifierLoc(QualifierLoc);
6048 NewTL.setNameLoc(TL.getNameLoc());
6053 template<
typename Derived>
6056 DependentTemplateSpecializationTypeLoc TL) {
6057 NestedNameSpecifierLoc QualifierLoc;
6058 if (TL.getQualifierLoc()) {
6060 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
6066 .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc);
6069 template<
typename Derived>
6082 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
6087 QualType Result = getDerived().RebuildDependentTemplateSpecializationType(
6094 if (
const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) {
6095 QualType NamedT = ElabT->getNamedType();
6104 for (
unsigned I = 0, E = NewTemplateArgs.
size();
I !=
E; ++
I)
6111 }
else if (isa<DependentTemplateSpecializationType>(Result)) {
6120 for (
unsigned I = 0, E = NewTemplateArgs.
size();
I !=
E; ++
I)
6129 for (
unsigned I = 0, E = NewTemplateArgs.
size();
I !=
E; ++
I)
6135 template<
typename Derived>
6144 if (getDerived().AlwaysRebuild() ||
6146 Result = getDerived().RebuildPackExpansionType(Pattern,
6154 PackExpansionTypeLoc NewT = TLB.
push<PackExpansionTypeLoc>(Result);
6159 template<
typename Derived>
6161 TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
6162 ObjCInterfaceTypeLoc TL) {
6164 TLB.pushFullCopy(TL);
6165 return TL.getType();
6168 template<
typename Derived>
6170 TreeTransform<Derived>::TransformObjCTypeParamType(TypeLocBuilder &TLB,
6171 ObjCTypeParamTypeLoc TL) {
6172 const ObjCTypeParamType *T = TL.
getTypePtr();
6173 ObjCTypeParamDecl *OTP = cast_or_null<ObjCTypeParamDecl>(
6174 getDerived().TransformDecl(T->getDecl()->getLocation(), T->getDecl()));
6178 QualType Result = TL.getType();
6179 if (getDerived().AlwaysRebuild() ||
6180 OTP != T->getDecl()) {
6181 Result = getDerived().RebuildObjCTypeParamType(OTP,
6182 TL.getProtocolLAngleLoc(),
6183 llvm::makeArrayRef(TL.getTypePtr()->qual_begin(),
6184 TL.getNumProtocols()),
6185 TL.getProtocolLocs(),
6186 TL.getProtocolRAngleLoc());
6187 if (Result.isNull())
6191 ObjCTypeParamTypeLoc NewTL = TLB.push<ObjCTypeParamTypeLoc>(Result);
6192 if (TL.getNumProtocols()) {
6193 NewTL.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
6194 for (
unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
6195 NewTL.setProtocolLoc(i, TL.getProtocolLoc(i));
6196 NewTL.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
6201 template<
typename Derived>
6203 TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
6204 ObjCObjectTypeLoc TL) {
6206 QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc());
6207 if (BaseType.isNull())
6210 bool AnyChanged = BaseType != TL.getBaseLoc().getType();
6213 SmallVector<TypeSourceInfo *, 4> NewTypeArgInfos;
6214 for (
unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) {
6215 TypeSourceInfo *TypeArgInfo = TL.getTypeArgTInfo(i);
6216 TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc();
6217 QualType TypeArg = TypeArgInfo->getType();
6218 if (
auto PackExpansionLoc = TypeArgLoc.getAs<PackExpansionTypeLoc>()) {
6222 const auto *PackExpansion = PackExpansionLoc.getType()
6223 ->
castAs<PackExpansionType>();
6224 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
6225 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
6227 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
6231 TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc();
6232 bool Expand =
false;
6233 bool RetainExpansion =
false;
6234 Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
6235 if (getDerived().TryExpandParameterPacks(
6236 PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(),
6237 Unexpanded, Expand, RetainExpansion, NumExpansions))
6244 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
6246 TypeLocBuilder TypeArgBuilder;
6247 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
6248 QualType NewPatternType = getDerived().TransformType(TypeArgBuilder,
6250 if (NewPatternType.isNull())
6253 QualType NewExpansionType = SemaRef.Context.getPackExpansionType(
6254 NewPatternType, NumExpansions);
6255 auto NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(NewExpansionType);
6256 NewExpansionLoc.setEllipsisLoc(PackExpansionLoc.getEllipsisLoc());
6257 NewTypeArgInfos.push_back(
6258 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewExpansionType));
6264 for (
unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
6265 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);
6267 TypeLocBuilder TypeArgBuilder;
6268 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
6270 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder,
6272 if (NewTypeArg.isNull())
6275 NewTypeArgInfos.push_back(
6276 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
6282 TypeLocBuilder TypeArgBuilder;
6283 TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize());
6284 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder, TypeArgLoc);
6285 if (NewTypeArg.isNull())
6289 if (NewTypeArg == TypeArg) {
6290 NewTypeArgInfos.push_back(TypeArgInfo);
6294 NewTypeArgInfos.push_back(
6295 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
6299 QualType Result = TL.getType();
6300 if (getDerived().AlwaysRebuild() || AnyChanged) {
6302 Result = getDerived().RebuildObjCObjectType(
6305 TL.getTypeArgsLAngleLoc(),
6307 TL.getTypeArgsRAngleLoc(),
6308 TL.getProtocolLAngleLoc(),
6309 llvm::makeArrayRef(TL.getTypePtr()->qual_begin(),
6310 TL.getNumProtocols()),
6311 TL.getProtocolLocs(),
6312 TL.getProtocolRAngleLoc());
6314 if (Result.isNull())
6318 ObjCObjectTypeLoc NewT = TLB.push<ObjCObjectTypeLoc>(Result);
6319 NewT.setHasBaseTypeAsWritten(
true);
6320 NewT.setTypeArgsLAngleLoc(TL.getTypeArgsLAngleLoc());
6321 for (
unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)
6322 NewT.setTypeArgTInfo(i, NewTypeArgInfos[i]);
6323 NewT.setTypeArgsRAngleLoc(TL.getTypeArgsRAngleLoc());
6324 NewT.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
6325 for (
unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
6326 NewT.setProtocolLoc(i, TL.getProtocolLoc(i));
6327 NewT.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
6331 template<
typename Derived>
6333 TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
6334 ObjCObjectPointerTypeLoc TL) {
6335 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
6336 if (PointeeType.isNull())
6339 QualType Result = TL.getType();
6340 if (getDerived().AlwaysRebuild() ||
6341 PointeeType != TL.getPointeeLoc().getType()) {
6342 Result = getDerived().RebuildObjCObjectPointerType(PointeeType,
6344 if (Result.isNull())
6348 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
6349 NewT.setStarLoc(TL.getStarLoc());
6356 template<
typename Derived>
6358 TreeTransform<Derived>::TransformNullStmt(NullStmt *
S) {
6362 template<
typename Derived>
6365 return getDerived().TransformCompoundStmt(S,
false);
6368 template<
typename Derived>
6374 bool SubStmtInvalid =
false;
6375 bool SubStmtChanged =
false;
6377 for (
auto *B : S->
body()) {
6378 StmtResult Result = getDerived().TransformStmt(B);
6382 if (isa<DeclStmt>(B))
6386 SubStmtInvalid =
true;
6390 SubStmtChanged = SubStmtChanged || Result.
get() != B;
6391 Statements.push_back(Result.
getAs<Stmt>());
6397 if (!getDerived().AlwaysRebuild() &&
6401 return getDerived().RebuildCompoundStmt(S->
getLBracLoc(),
6407 template<
typename Derived>
6409 TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
6412 EnterExpressionEvaluationContext Unevaluated(
6416 LHS = getDerived().TransformExpr(S->getLHS());
6417 LHS = SemaRef.ActOnConstantExpression(LHS);
6418 if (LHS.isInvalid())
6422 RHS = getDerived().TransformExpr(S->getRHS());
6423 RHS = SemaRef.ActOnConstantExpression(RHS);
6424 if (RHS.isInvalid())
6431 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
6433 S->getEllipsisLoc(),
6436 if (Case.isInvalid())
6440 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6441 if (SubStmt.isInvalid())
6445 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get());
6448 template<
typename Derived>
6450 TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
6452 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6453 if (SubStmt.isInvalid())
6457 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
6461 template<
typename Derived>
6463 TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) {
6464 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6465 if (SubStmt.isInvalid())
6468 Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(),
6475 return getDerived().RebuildLabelStmt(S->getIdentLoc(),
6476 cast<LabelDecl>(LD), SourceLocation(),
6480 template <
typename Derived>
6488 #define PRAGMA_SPELLING_ATTR(X) \
6490 return getDerived().Transform##X##Attr(cast<X##Attr>(R));
6491 #include "clang/Basic/AttrList.inc"
6497 template <
typename Derived>
6499 bool AttrsChanged =
false;
6504 const Attr *R = getDerived().TransformAttr(
I);
6505 AttrsChanged |= (
I != R);
6510 if (SubStmt.isInvalid())
6513 if (SubStmt.get() == S->
getSubStmt() && !AttrsChanged)
6516 return getDerived().RebuildAttributedStmt(S->
getAttrLoc(), Attrs,
6520 template<
typename Derived>
6522 TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
6524 StmtResult Init = getDerived().TransformStmt(S->getInit());
6525 if (Init.isInvalid())
6529 Sema::ConditionResult Cond = getDerived().TransformCondition(
6530 S->getIfLoc(), S->getConditionVariable(), S->getCond(),
6533 if (Cond.isInvalid())
6538 if (S->isConstexpr())
6539 ConstexprConditionValue = Cond.getKnownValue();
6543 if (!ConstexprConditionValue || *ConstexprConditionValue) {
6544 Then = getDerived().TransformStmt(S->getThen());
6545 if (Then.isInvalid())
6548 Then =
new (getSema().Context) NullStmt(S->getThen()->getLocStart());
6553 if (!ConstexprConditionValue || !*ConstexprConditionValue) {
6554 Else = getDerived().TransformStmt(S->getElse());
6555 if (Else.isInvalid())
6559 if (!getDerived().AlwaysRebuild() &&
6560 Init.get() == S->getInit() &&
6561 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
6562 Then.get() == S->getThen() &&
6563 Else.get() == S->getElse())
6566 return getDerived().RebuildIfStmt(S->getIfLoc(), S->isConstexpr(), Cond,
6567 Init.get(), Then.get(), S->getElseLoc(),
6571 template<
typename Derived>
6573 TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
6575 StmtResult Init = getDerived().TransformStmt(S->getInit());
6576 if (Init.isInvalid())
6580 Sema::ConditionResult Cond = getDerived().TransformCondition(
6581 S->getSwitchLoc(), S->getConditionVariable(), S->getCond(),
6583 if (Cond.isInvalid())
6588 = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(),
6589 S->getInit(), Cond);
6590 if (Switch.isInvalid())
6594 StmtResult Body = getDerived().TransformStmt(S->getBody());
6595 if (Body.isInvalid())
6599 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(),
6603 template<
typename Derived>
6605 TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
6607 Sema::ConditionResult Cond = getDerived().TransformCondition(
6608 S->getWhileLoc(), S->getConditionVariable(), S->getCond(),
6610 if (Cond.isInvalid())
6614 StmtResult Body = getDerived().TransformStmt(S->getBody());
6615 if (Body.isInvalid())
6618 if (!getDerived().AlwaysRebuild() &&
6619 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
6620 Body.get() == S->getBody())
6623 return getDerived().RebuildWhileStmt(S->getWhileLoc(), Cond, Body.get());
6626 template<
typename Derived>
6628 TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
6630 StmtResult Body = getDerived().TransformStmt(S->getBody());
6631 if (Body.isInvalid())
6635 ExprResult Cond = getDerived().TransformExpr(S->getCond());
6636 if (Cond.isInvalid())
6639 if (!getDerived().AlwaysRebuild() &&
6640 Cond.get() == S->getCond() &&
6641 Body.get() == S->getBody())
6644 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(),
6645 S->getWhileLoc(), Cond.get(),
6649 template<
typename Derived>
6651 TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
6653 StmtResult Init = getDerived().TransformStmt(S->getInit());
6654 if (Init.isInvalid())
6659 if (getSema().getLangOpts().OpenMP && Init.isUsable())
6660 getSema().ActOnOpenMPLoopInitialization(S->getForLoc(), Init.get());
6663 Sema::ConditionResult Cond = getDerived().TransformCondition(
6664 S->getForLoc(), S->getConditionVariable(), S->getCond(),
6666 if (Cond.isInvalid())
6670 ExprResult Inc = getDerived().TransformExpr(S->getInc());
6671 if (Inc.isInvalid())
6674 Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(Inc.get()));
6675 if (S->getInc() && !FullInc.get())
6679 StmtResult Body = getDerived().TransformStmt(S->getBody());
6680 if (Body.isInvalid())
6683 if (!getDerived().AlwaysRebuild() &&
6684 Init.get() == S->getInit() &&
6685 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
6686 Inc.get() == S->getInc() &&
6687 Body.get() == S->getBody())
6690 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
6691 Init.get(), Cond, FullInc,
6692 S->getRParenLoc(), Body.get());
6695 template<
typename Derived>
6697 TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
6698 Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(),
6704 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
6705 cast<LabelDecl>(LD));
6708 template<
typename Derived>
6710 TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
6711 ExprResult Target = getDerived().TransformExpr(S->getTarget());
6712 if (Target.isInvalid())
6714 Target = SemaRef.MaybeCreateExprWithCleanups(Target.get());
6716 if (!getDerived().AlwaysRebuild() &&
6717 Target.get() == S->getTarget())
6720 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
6724 template<
typename Derived>
6726 TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
6730 template<
typename Derived>
6732 TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
6736 template<
typename Derived>
6738 TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
6739 ExprResult Result = getDerived().TransformInitializer(S->getRetValue(),
6741 if (Result.isInvalid())
6746 return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get());
6749 template<
typename Derived>
6751 TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
6752 bool DeclChanged =
false;
6753 SmallVector<Decl *, 4> Decls;
6754 for (
auto *D : S->decls()) {
6755 Decl *Transformed = getDerived().TransformDefinition(D->getLocation(), D);
6759 if (Transformed != D)
6762 Decls.push_back(Transformed);
6765 if (!getDerived().AlwaysRebuild() && !DeclChanged)
6768 return getDerived().RebuildDeclStmt(Decls, S->getStartLoc(), S->getEndLoc());
6771 template<
typename Derived>
6773 TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) {
6775 SmallVector<Expr*, 8> Constraints;
6776 SmallVector<Expr*, 8> Exprs;
6777 SmallVector<IdentifierInfo *, 4>
Names;
6780 SmallVector<Expr*, 8> Clobbers;
6782 bool ExprsChanged =
false;
6785 for (
unsigned I = 0, E = S->getNumOutputs();
I !=
E; ++
I) {
6786 Names.push_back(S->getOutputIdentifier(
I));
6789 Constraints.push_back(S->getOutputConstraintLiteral(
I));
6792 Expr *OutputExpr = S->getOutputExpr(
I);
6793 ExprResult Result = getDerived().TransformExpr(OutputExpr);
6794 if (Result.isInvalid())
6797 ExprsChanged |= Result.
get() != OutputExpr;
6799 Exprs.push_back(Result.get());
6803 for (
unsigned I = 0, E = S->getNumInputs();
I !=
E; ++
I) {
6804 Names.push_back(S->getInputIdentifier(
I));
6807 Constraints.push_back(S->getInputConstraintLiteral(
I));
6810 Expr *InputExpr = S->getInputExpr(
I);
6811 ExprResult Result = getDerived().TransformExpr(InputExpr);
6812 if (Result.isInvalid())
6815 ExprsChanged |= Result.
get() != InputExpr;
6817 Exprs.push_back(Result.get());
6820 if (!getDerived().AlwaysRebuild() && !ExprsChanged)
6824 for (
unsigned I = 0, E = S->getNumClobbers();
I !=
E; ++
I)
6825 Clobbers.push_back(S->getClobberStringLiteral(
I));
6828 AsmString = S->getAsmString();
6829 return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(),
6830 S->isVolatile(), S->getNumOutputs(),
6831 S->getNumInputs(), Names.data(),
6832 Constraints, Exprs, AsmString.get(),
6833 Clobbers, S->getRParenLoc());
6836 template<
typename Derived>
6838 TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
6839 ArrayRef<Token> AsmToks =
6840 llvm::makeArrayRef(S->getAsmToks(), S->getNumAsmToks());
6842 bool HadError =
false, HadChange =
false;
6844 ArrayRef<Expr*> SrcExprs = S->getAllExprs();
6845 SmallVector<Expr*, 8> TransformedExprs;
6846 TransformedExprs.reserve(SrcExprs.size());
6847 for (
unsigned i = 0, e = SrcExprs.size(); i != e; ++i) {
6848 ExprResult Result = getDerived().TransformExpr(SrcExprs[i]);
6849 if (!Result.isUsable()) {
6852 HadChange |= (Result.get() != SrcExprs[i]);
6853 TransformedExprs.push_back(Result.get());
6858 if (!HadChange && !getDerived().AlwaysRebuild())
6861 return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(),
6862 AsmToks, S->getAsmString(),
6863 S->getNumOutputs(), S->getNumInputs(),
6864 S->getAllConstraints(), S->getClobbers(),
6865 TransformedExprs, S->getEndLoc());
6870 template<
typename Derived>
6872 TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) {
6873 auto *ScopeInfo = SemaRef.getCurFunction();
6874 auto *FD = cast<FunctionDecl>(SemaRef.CurContext);
6875 assert(FD && ScopeInfo && !ScopeInfo->CoroutinePromise &&
6876 ScopeInfo->NeedsCoroutineSuspends &&
6877 ScopeInfo->CoroutineSuspends.first ==
nullptr &&
6878 ScopeInfo->CoroutineSuspends.second ==
nullptr &&
6879 "expected clean scope info");
6883 ScopeInfo->setNeedsCoroutineSuspends(
false);
6887 auto *Promise = SemaRef.buildCoroutinePromise(FD->getLocation());
6890 getDerived().transformedLocalDecl(S->getPromiseDecl(), Promise);
6891 ScopeInfo->CoroutinePromise = Promise;
6895 StmtResult InitSuspend = getDerived().TransformStmt(S->getInitSuspendStmt());
6896 if (InitSuspend.isInvalid())
6899 getDerived().TransformStmt(S->getFinalSuspendStmt());
6900 if (FinalSuspend.isInvalid())
6902 ScopeInfo->setCoroutineSuspends(InitSuspend.get(), FinalSuspend.get());
6903 assert(isa<Expr>(InitSuspend.get()) && isa<Expr>(FinalSuspend.get()));
6905 StmtResult BodyRes = getDerived().TransformStmt(S->getBody());
6906 if (BodyRes.isInvalid())
6909 CoroutineStmtBuilder
Builder(SemaRef, *FD, *ScopeInfo, BodyRes.get());
6913 Expr *ReturnObject = S->getReturnValueInit();
6914 assert(ReturnObject &&
"the return object is expected to be valid");
6915 ExprResult Res = getDerived().TransformInitializer(ReturnObject,
6917 if (Res.isInvalid())
6919 Builder.ReturnValue = Res.get();
6921 if (S->hasDependentPromiseType()) {
6922 assert(!Promise->getType()->isDependentType() &&
6923 "the promise type must no longer be dependent");
6924 assert(!S->getFallthroughHandler() && !S->getExceptionHandler() &&
6925 !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() &&
6926 "these nodes should not have been built yet");
6927 if (!
Builder.buildDependentStatements())
6930 if (
auto *OnFallthrough = S->getFallthroughHandler()) {
6931 StmtResult Res = getDerived().TransformStmt(OnFallthrough);
6932 if (Res.isInvalid())
6934 Builder.OnFallthrough = Res.get();
6937 if (
auto *OnException = S->getExceptionHandler()) {
6938 StmtResult Res = getDerived().TransformStmt(OnException);
6939 if (Res.isInvalid())
6941 Builder.OnException = Res.get();
6944 if (
auto *OnAllocFailure = S->getReturnStmtOnAllocFailure()) {
6945 StmtResult Res = getDerived().TransformStmt(OnAllocFailure);
6946 if (Res.isInvalid())
6948 Builder.ReturnStmtOnAllocFailure = Res.get();
6952 assert(S->getAllocate() && S->getDeallocate() &&
6953 "allocation and deallocation calls must already be built");
6954 ExprResult AllocRes = getDerived().TransformExpr(S->getAllocate());
6955 if (AllocRes.isInvalid())
6957 Builder.Allocate = AllocRes.get();
6959 ExprResult DeallocRes = getDerived().TransformExpr(S->getDeallocate());
6960 if (DeallocRes.isInvalid())
6962 Builder.Deallocate = DeallocRes.get();
6964 assert(S->getResultDecl() &&
"ResultDecl must already be built");
6965 StmtResult ResultDecl = getDerived().TransformStmt(S->getResultDecl());
6966 if (ResultDecl.isInvalid())
6968 Builder.ResultDecl = ResultDecl.get();
6970 if (
auto *ReturnStmt = S->getReturnStmt()) {
6971 StmtResult Res = getDerived().TransformStmt(ReturnStmt);
6972 if (Res.isInvalid())
6974 Builder.ReturnStmt = Res.get();
6977 if (!
Builder.buildParameterMoves())
6980 return getDerived().RebuildCoroutineBodyStmt(
Builder);
6983 template<
typename Derived>
6985 TreeTransform<Derived>::TransformCoreturnStmt(CoreturnStmt *S) {
6986 ExprResult Result = getDerived().TransformInitializer(S->getOperand(),
6988 if (Result.isInvalid())
6993 return getDerived().RebuildCoreturnStmt(S->getKeywordLoc(), Result.get(),
6997 template<
typename Derived>
6999 TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *E) {
7000 ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
7002 if (Result.isInvalid())
7007 return getDerived().RebuildCoawaitExpr(E->getKeywordLoc(), Result.get(),
7011 template <
typename Derived>
7013 TreeTransform<Derived>::TransformDependentCoawaitExpr(DependentCoawaitExpr *E) {
7014 ExprResult OperandResult = getDerived().TransformInitializer(E->getOperand(),
7016 if (OperandResult.isInvalid())
7019 ExprResult LookupResult = getDerived().TransformUnresolvedLookupExpr(
7020 E->getOperatorCoawaitLookup());
7022 if (LookupResult.isInvalid())
7027 return getDerived().RebuildDependentCoawaitExpr(
7028 E->getKeywordLoc(), OperandResult.get(),
7029 cast<UnresolvedLookupExpr>(LookupResult.get()));
7032 template<
typename Derived>
7034 TreeTransform<Derived>::TransformCoyieldExpr(CoyieldExpr *E) {
7035 ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
7037 if (Result.isInvalid())
7042 return getDerived().RebuildCoyieldExpr(E->getKeywordLoc(), Result.get());
7047 template<
typename Derived>
7049 TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
7051 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
7052 if (TryBody.isInvalid())
7056 bool AnyCatchChanged =
false;
7057 SmallVector<Stmt*, 8> CatchStmts;
7058 for (
unsigned I = 0, N = S->getNumCatchStmts();
I != N; ++
I) {
7059 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(
I));
7060 if (Catch.isInvalid())
7062 if (Catch.get() != S->getCatchStmt(
I))
7063 AnyCatchChanged =
true;
7064 CatchStmts.push_back(Catch.get());
7069 if (S->getFinallyStmt()) {
7070 Finally = getDerived().TransformStmt(S->getFinallyStmt());
7071 if (Finally.isInvalid())
7076 if (!getDerived().AlwaysRebuild() &&
7077 TryBody.get() == S->getTryBody() &&
7079 Finally.get() == S->getFinallyStmt())
7083 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(),
7084 CatchStmts, Finally.get());
7087 template<
typename Derived>
7089 TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
7091 VarDecl *Var =
nullptr;
7092 if (VarDecl *FromVar = S->getCatchParamDecl()) {
7093 TypeSourceInfo *TSInfo =
nullptr;
7094 if (FromVar->getTypeSourceInfo()) {
7095 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
7102 T = TSInfo->getType();
7104 T = getDerived().TransformType(FromVar->getType());
7109 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T);
7114 StmtResult Body = getDerived().TransformStmt(S->getCatchBody());
7115 if (Body.isInvalid())
7118 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
7123 template<
typename Derived>
7125 TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
7127 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
7128 if (Body.isInvalid())
7132 if (!getDerived().AlwaysRebuild() &&
7133 Body.get() == S->getFinallyBody())
7137 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
7141 template<
typename Derived>
7143 TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
7145 if (S->getThrowExpr()) {
7146 Operand = getDerived().TransformExpr(S->getThrowExpr());
7147 if (Operand.isInvalid())
7151 if (!getDerived().AlwaysRebuild() &&
7152 Operand.get() == S->getThrowExpr())
7155 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get());
7158 template<
typename Derived>
7160 TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
7161 ObjCAtSynchronizedStmt *S) {
7163 ExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
7164 if (Object.isInvalid())
7167 getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(),
7169 if (Object.isInvalid())
7173 StmtResult Body = getDerived().TransformStmt(S->getSynchBody());
7174 if (Body.isInvalid())
7178 if (!getDerived().AlwaysRebuild() &&
7179 Object.get() == S->getSynchExpr() &&
7180 Body.get() == S->getSynchBody())
7184 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
7185 Object.get(), Body.get());
7188 template<
typename Derived>
7190 TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt(
7191 ObjCAutoreleasePoolStmt *S) {
7193 StmtResult Body = getDerived().TransformStmt(S->getSubStmt());
7194 if (Body.isInvalid())
7198 if (!getDerived().AlwaysRebuild() &&
7199 Body.get() == S->getSubStmt())
7203 return getDerived().RebuildObjCAutoreleasePoolStmt(
7204 S->getAtLoc(), Body.get());
7207 template<
typename Derived>
7209 TreeTransform<Derived>::TransformObjCForCollectionStmt(
7210 ObjCForCollectionStmt *S) {
7212 StmtResult Element = getDerived().TransformStmt(S->getElement());
7213 if (Element.isInvalid())
7217 ExprResult Collection = getDerived().TransformExpr(S->getCollection());
7218 if (Collection.isInvalid())
7222 StmtResult Body = getDerived().TransformStmt(S->getBody());
7223 if (Body.isInvalid())
7227 if (!getDerived().AlwaysRebuild() &&
7228 Element.get() == S->getElement() &&
7229 Collection.get() == S->getCollection() &&
7230 Body.get() == S->getBody())
7234 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
7241 template <
typename Derived>
7242 StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
7244 VarDecl *Var =
nullptr;
7245 if (VarDecl *ExceptionDecl = S->getExceptionDecl()) {
7247 getDerived().TransformType(ExceptionDecl->getTypeSourceInfo());
7251 Var = getDerived().RebuildExceptionDecl(
7252 ExceptionDecl, T, ExceptionDecl->getInnerLocStart(),
7253 ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier());
7254 if (!Var || Var->isInvalidDecl())
7259 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
7260 if (Handler.isInvalid())
7263 if (!getDerived().AlwaysRebuild() && !Var &&
7264 Handler.get() == S->getHandlerBlock())
7267 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get());
7270 template <
typename Derived>
7271 StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
7273 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
7274 if (TryBlock.isInvalid())
7278 bool HandlerChanged =
false;
7279 SmallVector<Stmt *, 8> Handlers;
7280 for (
unsigned I = 0, N = S->getNumHandlers();
I != N; ++
I) {
7281 StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(
I));
7282 if (Handler.isInvalid())
7285 HandlerChanged = HandlerChanged || Handler.
get() != S->getHandler(
I);
7286 Handlers.push_back(Handler.getAs<Stmt>());
7289 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
7293 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(),
7297 template<
typename Derived>
7299 TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) {
7300 StmtResult Range = getDerived().TransformStmt(S->getRangeStmt());
7301 if (Range.isInvalid())
7305 if (Begin.isInvalid())
7307 StmtResult End = getDerived().TransformStmt(S->getEndStmt());
7308 if (End.isInvalid())
7311 ExprResult Cond = getDerived().TransformExpr(S->getCond());
7312 if (Cond.isInvalid())
7315 Cond = SemaRef.CheckBooleanCondition(S->getColonLoc(), Cond.get());
7316 if (Cond.isInvalid())
7319 Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.get());
7321 ExprResult Inc = getDerived().TransformExpr(S->getInc());
7322 if (Inc.isInvalid())
7325 Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.get());
7327 StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt());
7328 if (LoopVar.isInvalid())
7332 if (getDerived().AlwaysRebuild() ||
7333 Range.get() != S->getRangeStmt() ||
7334 Begin.get() != S->getBeginStmt() ||
7335 End.get() != S->getEndStmt() ||
7336 Cond.get() != S->getCond() ||
7337 Inc.get() != S->getInc() ||
7338 LoopVar.get() != S->getLoopVarStmt()) {
7339 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
7341 S->getColonLoc(), Range.get(),
7342 Begin.get(), End.get(),
7344 Inc.get(), LoopVar.get(),
7346 if (NewStmt.isInvalid())
7350 StmtResult Body = getDerived().TransformStmt(S->getBody());
7351 if (Body.isInvalid())
7356 if (Body.get() != S->getBody() && NewStmt.get() ==
S) {
7357 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
7359 S->getColonLoc(), Range.get(),
7360 Begin.get(), End.get(),
7362 Inc.get(), LoopVar.get(),
7364 if (NewStmt.isInvalid())
7368 if (NewStmt.get() ==
S)
7371 return FinishCXXForRangeStmt(NewStmt.get(), Body.get());
7374 template<
typename Derived>
7376 TreeTransform<Derived>::TransformMSDependentExistsStmt(
7377 MSDependentExistsStmt *S) {
7379 NestedNameSpecifierLoc QualifierLoc;
7380 if (S->getQualifierLoc()) {
7382 = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc());
7388 DeclarationNameInfo NameInfo = S->getNameInfo();
7389 if (NameInfo.getName()) {
7390 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
7391 if (!NameInfo.getName())
7396 if (!getDerived().AlwaysRebuild() &&
7397 QualifierLoc == S->getQualifierLoc() &&
7398 NameInfo.getName() == S->getNameInfo().getName())
7403 SS.Adopt(QualifierLoc);
7404 bool Dependent =
false;
7405 switch (getSema().CheckMicrosoftIfExistsSymbol(
nullptr, SS, NameInfo)) {
7407 if (S->isIfExists())
7410 return new (getSema().Context) NullStmt(S->getKeywordLoc());
7413 if (S->isIfNotExists())
7416 return new (getSema().Context) NullStmt(S->getKeywordLoc());
7427 StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt());
7428 if (SubStmt.isInvalid())
7436 return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(),
7443 template<
typename Derived>
7445 TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *E) {
7446 NestedNameSpecifierLoc QualifierLoc;
7447 if (E->getQualifierLoc()) {
7449 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
7454 MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>(
7455 getDerived().TransformDecl(E->getMemberLoc(), E->getPropertyDecl()));
7460 if (Base.isInvalid())
7463 return new (SemaRef.getASTContext())
7464 MSPropertyRefExpr(Base.get(), PD, E->isArrow(),
7465 SemaRef.getASTContext().PseudoObjectTy,
VK_LValue,
7466 QualifierLoc, E->getMemberLoc());
7469 template <
typename Derived>
7470 ExprResult TreeTransform<Derived>::TransformMSPropertySubscriptExpr(
7471 MSPropertySubscriptExpr *E) {
7472 auto BaseRes = getDerived().TransformExpr(E->getBase());
7473 if (BaseRes.isInvalid())
7475 auto IdxRes = getDerived().TransformExpr(E->getIdx());
7476 if (IdxRes.isInvalid())
7479 if (!getDerived().AlwaysRebuild() &&
7480 BaseRes.get() == E->getBase() &&
7481 IdxRes.get() == E->getIdx())
7484 return getDerived().RebuildArraySubscriptExpr(
7485 BaseRes.get(), SourceLocation(), IdxRes.get(), E->getRBracketLoc());
7488 template <
typename Derived>
7489 StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) {
7490 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
7491 if (TryBlock.isInvalid())
7494 StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler());
7495 if (Handler.isInvalid())
7498 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
7499 Handler.get() == S->getHandler())
7502 return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(),
7503 TryBlock.get(), Handler.get());
7506 template <
typename Derived>
7507 StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) {
7508 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
7509 if (Block.isInvalid())
7512 return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.get());
7515 template <
typename Derived>
7516 StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) {
7517 ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr());
7518 if (FilterExpr.isInvalid())
7521 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
7522 if (Block.isInvalid())
7525 return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(),
7529 template <
typename Derived>
7531 if (isa<SEHFinallyStmt>(Handler))
7532 return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler));
7534 return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler));
7537 template<
typename Derived>
7546 template <
typename Derived>
7553 TClauses.reserve(Clauses.size());
7557 getDerived().getSema().StartOpenMPClause((*I)->getClauseKind());
7558 OMPClause *Clause = getDerived().TransformOMPClause(*
I);
7559 getDerived().getSema().EndOpenMPClause();
7561 TClauses.push_back(Clause);
7563 TClauses.push_back(
nullptr);
7573 int ThisCaptureLevel =
7576 while (--ThisCaptureLevel >= 0)
7577 CS = cast<CapturedStmt>(CS)->getCapturedStmt();
7578 Body = getDerived().TransformStmt(CS);
7581 getDerived().getSema().ActOnOpenMPRegionEnd(Body, TClauses);
7586 if (TClauses.size() != Clauses.size()) {
7593 DirName = cast<OMPCriticalDirective>(D)->getDirectiveName();
7594 DirName = getDerived().TransformDeclarationNameInfo(DirName);
7598 CancelRegion = cast<OMPCancellationPointDirective>(D)->getCancelRegion();
7600 CancelRegion = cast<OMPCancelDirective>(D)->getCancelRegion();
7603 return getDerived().RebuildOMPExecutableDirective(
7608 template <
typename Derived>
7612 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel, DirName,
nullptr,
7614 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7615 getDerived().getSema().EndOpenMPDSABlock(Res.
get());
7619 template <
typename Derived>
7621 TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *D) {
7622 DeclarationNameInfo DirName;
7623 getDerived().getSema().StartOpenMPDSABlock(OMPD_simd, DirName,
nullptr,
7625 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7626 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7630 template <
typename Derived>
7632 TreeTransform<Derived>::TransformOMPForDirective(OMPForDirective *D) {
7633 DeclarationNameInfo DirName;
7634 getDerived().getSema().StartOpenMPDSABlock(OMPD_for, DirName,
nullptr,
7636 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7637 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7641 template <
typename Derived>
7643 TreeTransform<Derived>::TransformOMPForSimdDirective(OMPForSimdDirective *D) {
7644 DeclarationNameInfo DirName;
7645 getDerived().getSema().StartOpenMPDSABlock(OMPD_for_simd, DirName,
nullptr,
7647 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7648 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7652 template <
typename Derived>
7654 TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *D) {
7655 DeclarationNameInfo DirName;
7656 getDerived().getSema().StartOpenMPDSABlock(OMPD_sections, DirName,
nullptr,
7658 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7659 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7663 template <
typename Derived>
7665 TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *D) {
7666 DeclarationNameInfo DirName;
7667 getDerived().getSema().StartOpenMPDSABlock(OMPD_section, DirName,
nullptr,
7669 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7670 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7674 template <
typename Derived>
7676 TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *D) {
7677 DeclarationNameInfo DirName;
7678 getDerived().getSema().StartOpenMPDSABlock(OMPD_single, DirName,
nullptr,
7680 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7681 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7685 template <
typename Derived>
7687 TreeTransform<Derived>::TransformOMPMasterDirective(OMPMasterDirective *D) {
7688 DeclarationNameInfo DirName;
7689 getDerived().getSema().StartOpenMPDSABlock(OMPD_master, DirName,
nullptr,
7691 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7692 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7696 template <
typename Derived>
7698 TreeTransform<Derived>::TransformOMPCriticalDirective(OMPCriticalDirective *D) {
7699 getDerived().getSema().StartOpenMPDSABlock(
7700 OMPD_critical, D->getDirectiveName(),
nullptr, D->getLocStart());
7701 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7702 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7706 template <
typename Derived>
7707 StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective(
7708 OMPParallelForDirective *D) {
7709 DeclarationNameInfo DirName;
7710 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for, DirName,
7711 nullptr, D->getLocStart());
7712 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7713 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7717 template <
typename Derived>
7718 StmtResult TreeTransform<Derived>::TransformOMPParallelForSimdDirective(
7719 OMPParallelForSimdDirective *D) {
7720 DeclarationNameInfo DirName;
7721 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for_simd, DirName,
7722 nullptr, D->getLocStart());
7723 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7724 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7728 template <
typename Derived>
7729 StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective(
7730 OMPParallelSectionsDirective *D) {
7731 DeclarationNameInfo DirName;
7732 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_sections, DirName,
7733 nullptr, D->getLocStart());
7734 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7735 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7739 template <
typename Derived>
7741 TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *D) {
7742 DeclarationNameInfo DirName;
7743 getDerived().getSema().StartOpenMPDSABlock(OMPD_task, DirName,
nullptr,
7745 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7746 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7750 template <
typename Derived>
7751 StmtResult TreeTransform<Derived>::TransformOMPTaskyieldDirective(
7752 OMPTaskyieldDirective *D) {
7753 DeclarationNameInfo DirName;
7754 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskyield, DirName,
nullptr,
7756 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7757 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7761 template <
typename Derived>
7763 TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *D) {
7764 DeclarationNameInfo DirName;
7765 getDerived().getSema().StartOpenMPDSABlock(OMPD_barrier, DirName,
nullptr,
7767 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7768 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7772 template <
typename Derived>
7774 TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
7775 DeclarationNameInfo DirName;
7776 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskwait, DirName,
nullptr,
7778 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7779 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7783 template <
typename Derived>
7784 StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective(
7785 OMPTaskgroupDirective *D) {
7786 DeclarationNameInfo DirName;
7787 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskgroup, DirName,
nullptr,
7789 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7790 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7794 template <
typename Derived>
7796 TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *D) {
7797 DeclarationNameInfo DirName;
7798 getDerived().getSema().StartOpenMPDSABlock(OMPD_flush, DirName,
nullptr,
7800 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7801 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7805 template <
typename Derived>
7807 TreeTransform<Derived>::TransformOMPOrderedDirective(OMPOrderedDirective *D) {
7808 DeclarationNameInfo DirName;
7809 getDerived().getSema().StartOpenMPDSABlock(OMPD_ordered, DirName,
nullptr,
7811 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7812 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7816 template <
typename Derived>
7818 TreeTransform<Derived>::TransformOMPAtomicDirective(OMPAtomicDirective *D) {
7819 DeclarationNameInfo DirName;
7820 getDerived().getSema().StartOpenMPDSABlock(OMPD_atomic, DirName,
nullptr,
7822 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7823 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7827 template <
typename Derived>
7829 TreeTransform<Derived>::TransformOMPTargetDirective(OMPTargetDirective *D) {
7830 DeclarationNameInfo DirName;
7831 getDerived().getSema().StartOpenMPDSABlock(OMPD_target, DirName,
nullptr,
7833 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7834 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7838 template <
typename Derived>
7839 StmtResult TreeTransform<Derived>::TransformOMPTargetDataDirective(
7840 OMPTargetDataDirective *D) {
7841 DeclarationNameInfo DirName;
7842 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_data, DirName,
nullptr,
7844 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7845 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7849 template <
typename Derived>
7850 StmtResult TreeTransform<Derived>::TransformOMPTargetEnterDataDirective(
7851 OMPTargetEnterDataDirective *D) {
7852 DeclarationNameInfo DirName;
7853 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_enter_data, DirName,
7854 nullptr, D->getLocStart());
7855 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7856 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7860 template <
typename Derived>
7861 StmtResult TreeTransform<Derived>::TransformOMPTargetExitDataDirective(
7862 OMPTargetExitDataDirective *D) {
7863 DeclarationNameInfo DirName;
7864 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_exit_data, DirName,
7865 nullptr, D->getLocStart());
7866 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7867 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7871 template <
typename Derived>
7872 StmtResult TreeTransform<Derived>::TransformOMPTargetParallelDirective(
7873 OMPTargetParallelDirective *D) {
7874 DeclarationNameInfo DirName;
7875 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel, DirName,
7876 nullptr, D->getLocStart());
7877 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7878 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7882 template <
typename Derived>
7883 StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForDirective(
7884 OMPTargetParallelForDirective *D) {
7885 DeclarationNameInfo DirName;
7886 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel_for, DirName,
7887 nullptr, D->getLocStart());
7888 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7889 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7893 template <
typename Derived>
7894 StmtResult TreeTransform<Derived>::TransformOMPTargetUpdateDirective(
7895 OMPTargetUpdateDirective *D) {
7896 DeclarationNameInfo DirName;
7897 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_update, DirName,
7898 nullptr, D->getLocStart());
7899 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7900 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7904 template <
typename Derived>
7906 TreeTransform<Derived>::TransformOMPTeamsDirective(OMPTeamsDirective *D) {
7907 DeclarationNameInfo DirName;
7908 getDerived().getSema().StartOpenMPDSABlock(OMPD_teams, DirName,
nullptr,
7910 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7911 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7915 template <
typename Derived>
7916 StmtResult TreeTransform<Derived>::TransformOMPCancellationPointDirective(
7917 OMPCancellationPointDirective *D) {
7918 DeclarationNameInfo DirName;
7919 getDerived().getSema().StartOpenMPDSABlock(OMPD_cancellation_point, DirName,
7920 nullptr, D->getLocStart());
7921 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7922 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7926 template <
typename Derived>
7928 TreeTransform<Derived>::TransformOMPCancelDirective(OMPCancelDirective *D) {
7929 DeclarationNameInfo DirName;
7930 getDerived().getSema().StartOpenMPDSABlock(OMPD_cancel, DirName,
nullptr,
7932 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7933 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7937 template <
typename Derived>
7939 TreeTransform<Derived>::TransformOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
7940 DeclarationNameInfo DirName;
7941 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop, DirName,
nullptr,
7943 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7944 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7948 template <
typename Derived>
7949 StmtResult TreeTransform<Derived>::TransformOMPTaskLoopSimdDirective(
7950 OMPTaskLoopSimdDirective *D) {
7951 DeclarationNameInfo DirName;
7952 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop_simd, DirName,
7953 nullptr, D->getLocStart());
7954 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7955 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7959 template <
typename Derived>
7960 StmtResult TreeTransform<Derived>::TransformOMPDistributeDirective(
7961 OMPDistributeDirective *D) {
7962 DeclarationNameInfo DirName;
7963 getDerived().getSema().StartOpenMPDSABlock(OMPD_distribute, DirName,
nullptr,
7965 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7966 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7970 template <
typename Derived>
7971 StmtResult TreeTransform<Derived>::TransformOMPDistributeParallelForDirective(
7972 OMPDistributeParallelForDirective *D) {
7973 DeclarationNameInfo DirName;
7974 getDerived().getSema().StartOpenMPDSABlock(
7975 OMPD_distribute_parallel_for, DirName,
nullptr, D->getLocStart());
7976 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7977 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7981 template <
typename Derived>
7983 TreeTransform<Derived>::TransformOMPDistributeParallelForSimdDirective(
7984 OMPDistributeParallelForSimdDirective *D) {
7985 DeclarationNameInfo DirName;
7986 getDerived().getSema().StartOpenMPDSABlock(
7987 OMPD_distribute_parallel_for_simd, DirName,
nullptr, D->getLocStart());
7988 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7989 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7993 template <
typename Derived>
7994 StmtResult TreeTransform<Derived>::TransformOMPDistributeSimdDirective(
7995 OMPDistributeSimdDirective *D) {
7996 DeclarationNameInfo DirName;
7997 getDerived().getSema().StartOpenMPDSABlock(OMPD_distribute_simd, DirName,
7998 nullptr, D->getLocStart());
7999 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8000 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8004 template <
typename Derived>
8005 StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForSimdDirective(
8006 OMPTargetParallelForSimdDirective *D) {
8007 DeclarationNameInfo DirName;
8008 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel_for_simd,
8011 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8012 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8016 template <
typename Derived>
8017 StmtResult TreeTransform<Derived>::TransformOMPTargetSimdDirective(
8018 OMPTargetSimdDirective *D) {
8019 DeclarationNameInfo DirName;
8020 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_simd, DirName,
nullptr,
8022 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8023 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8027 template <
typename Derived>
8028 StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeDirective(
8029 OMPTeamsDistributeDirective *D) {
8030 DeclarationNameInfo DirName;
8031 getDerived().getSema().StartOpenMPDSABlock(OMPD_teams_distribute, DirName,
8032 nullptr, D->getLocStart());
8033 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8034 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8038 template <
typename Derived>
8039 StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeSimdDirective(
8040 OMPTeamsDistributeSimdDirective *D) {
8041 DeclarationNameInfo DirName;
8042 getDerived().getSema().StartOpenMPDSABlock(
8043 OMPD_teams_distribute_simd, DirName,
nullptr, D->getLocStart());
8044 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8045 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8049 template <
typename Derived>
8050 StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForSimdDirective(
8051 OMPTeamsDistributeParallelForSimdDirective *D) {
8052 DeclarationNameInfo DirName;
8053 getDerived().getSema().StartOpenMPDSABlock(
8054 OMPD_teams_distribute_parallel_for_simd, DirName,
nullptr, D->getLocStart());
8055 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8056 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8060 template <
typename Derived>
8061 StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForDirective(
8062 OMPTeamsDistributeParallelForDirective *D) {
8063 DeclarationNameInfo DirName;
8064 getDerived().getSema().StartOpenMPDSABlock(OMPD_teams_distribute_parallel_for,
8065 DirName,
nullptr, D->getLocStart());
8066 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8067 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8071 template <
typename Derived>
8072 StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDirective(
8073 OMPTargetTeamsDirective *D) {
8074 DeclarationNameInfo DirName;
8075 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_teams, DirName,
8076 nullptr, D->getLocStart());
8077 auto Res = getDerived().TransformOMPExecutableDirective(D);
8078 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8082 template <
typename Derived>
8083 StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDistributeDirective(
8084 OMPTargetTeamsDistributeDirective *D) {
8085 DeclarationNameInfo DirName;
8086 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_teams_distribute,
8087 DirName,
nullptr, D->getLocStart());
8088 auto Res = getDerived().TransformOMPExecutableDirective(D);
8089 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8093 template <
typename Derived>
8095 TreeTransform<Derived>::TransformOMPTargetTeamsDistributeParallelForDirective(
8096 OMPTargetTeamsDistributeParallelForDirective *D) {
8097 DeclarationNameInfo DirName;
8098 getDerived().getSema().StartOpenMPDSABlock(
8099 OMPD_target_teams_distribute_parallel_for, DirName,
nullptr,
8101 auto Res = getDerived().TransformOMPExecutableDirective(D);
8102 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8106 template <
typename Derived>
8108 TransformOMPTargetTeamsDistributeParallelForSimdDirective(
8109 OMPTargetTeamsDistributeParallelForSimdDirective *D) {
8110 DeclarationNameInfo DirName;
8111 getDerived().getSema().StartOpenMPDSABlock(
8112 OMPD_target_teams_distribute_parallel_for_simd, DirName,
nullptr,
8114 auto Res = getDerived().TransformOMPExecutableDirective(D);
8115 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8119 template <
typename Derived>
8121 TreeTransform<Derived>::TransformOMPTargetTeamsDistributeSimdDirective(
8122 OMPTargetTeamsDistributeSimdDirective *D) {
8123 DeclarationNameInfo DirName;
8124 getDerived().getSema().StartOpenMPDSABlock(
8125 OMPD_target_teams_distribute_simd, DirName,
nullptr, D->getLocStart());
8126 auto Res = getDerived().TransformOMPExecutableDirective(D);
8127 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8135 template <
typename Derived>
8136 OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *C) {
8137 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
8138 if (Cond.isInvalid())
8140 return getDerived().RebuildOMPIfClause(
8141 C->getNameModifier(), Cond.get(), C->getLocStart(), C->getLParenLoc(),
8142 C->getNameModifierLoc(), C->getColonLoc(), C->getLocEnd());
8145 template <
typename Derived>
8146 OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *C) {
8147 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
8148 if (Cond.isInvalid())
8150 return getDerived().RebuildOMPFinalClause(Cond.get(), C->getLocStart(),
8151 C->getLParenLoc(), C->getLocEnd());
8154 template <
typename Derived>
8156 TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *C) {
8157 ExprResult NumThreads = getDerived().TransformExpr(C->getNumThreads());
8158 if (NumThreads.isInvalid())
8160 return getDerived().RebuildOMPNumThreadsClause(
8161 NumThreads.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8164 template <
typename Derived>
8166 TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *C) {
8167 ExprResult E = getDerived().TransformExpr(C->getSafelen());
8170 return getDerived().RebuildOMPSafelenClause(
8171 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8174 template <
typename Derived>
8176 TreeTransform<Derived>::TransformOMPSimdlenClause(OMPSimdlenClause *C) {
8177 ExprResult E = getDerived().TransformExpr(C->getSimdlen());
8180 return getDerived().RebuildOMPSimdlenClause(
8181 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8184 template <
typename Derived>
8186 TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) {
8187 ExprResult E = getDerived().TransformExpr(C->getNumForLoops());
8190 return getDerived().RebuildOMPCollapseClause(
8191 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8194 template <
typename Derived>
8196 TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *C) {
8197 return getDerived().RebuildOMPDefaultClause(
8198 C->getDefaultKind(), C->getDefaultKindKwLoc(), C->getLocStart(),
8199 C->getLParenLoc(), C->getLocEnd());
8202 template <
typename Derived>
8204 TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *C) {
8205 return getDerived().RebuildOMPProcBindClause(
8206 C->getProcBindKind(), C->getProcBindKindKwLoc(), C->getLocStart(),
8207 C->getLParenLoc(), C->getLocEnd());
8210 template <
typename Derived>
8212 TreeTransform<Derived>::TransformOMPScheduleClause(OMPScheduleClause *C) {
8213 ExprResult E = getDerived().TransformExpr(C->getChunkSize());
8216 return getDerived().RebuildOMPScheduleClause(
8217 C->getFirstScheduleModifier(), C->getSecondScheduleModifier(),
8218 C->getScheduleKind(), E.get(), C->getLocStart(), C->getLParenLoc(),
8219 C->getFirstScheduleModifierLoc(), C->getSecondScheduleModifierLoc(),
8220 C->getScheduleKindLoc(), C->getCommaLoc(), C->getLocEnd());
8223 template <
typename Derived>
8225 TreeTransform<Derived>::TransformOMPOrderedClause(OMPOrderedClause *C) {
8227 if (
auto *Num = C->getNumForLoops()) {
8228 E = getDerived().TransformExpr(Num);
8232 return getDerived().RebuildOMPOrderedClause(C->getLocStart(), C->getLocEnd(),
8233 C->getLParenLoc(), E.get());
8236 template <
typename Derived>
8238 TreeTransform<Derived>::TransformOMPNowaitClause(OMPNowaitClause *C) {
8243 template <
typename Derived>
8245 TreeTransform<Derived>::TransformOMPUntiedClause(OMPUntiedClause *C) {
8250 template <
typename Derived>
8252 TreeTransform<Derived>::TransformOMPMergeableClause(OMPMergeableClause *C) {
8257 template <
typename Derived>
8258 OMPClause *TreeTransform<Derived>::TransformOMPReadClause(OMPReadClause *C) {
8263 template <
typename Derived>
8264 OMPClause *TreeTransform<Derived>::TransformOMPWriteClause(OMPWriteClause *C) {
8269 template <
typename Derived>
8271 TreeTransform<Derived>::TransformOMPUpdateClause(OMPUpdateClause *C) {
8276 template <
typename Derived>
8278 TreeTransform<Derived>::TransformOMPCaptureClause(OMPCaptureClause *C) {
8283 template <
typename Derived>
8285 TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *C) {
8290 template <
typename Derived>
8297 template <
typename Derived>
8303 template <
typename Derived>
8310 template <
typename Derived>
8312 TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) {
8314 Vars.reserve(C->varlist_size());
8315 for (
auto *VE : C->varlists()) {
8316 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8317 if (EVar.isInvalid())
8319 Vars.push_back(EVar.get());
8321 return getDerived().RebuildOMPPrivateClause(
8322 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8325 template <
typename Derived>
8326 OMPClause *TreeTransform<Derived>::TransformOMPFirstprivateClause(
8327 OMPFirstprivateClause *C) {
8329 Vars.reserve(C->varlist_size());
8330 for (
auto *VE : C->varlists()) {
8331 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8332 if (EVar.isInvalid())
8334 Vars.push_back(EVar.get());
8336 return getDerived().RebuildOMPFirstprivateClause(
8337 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8340 template <
typename Derived>
8342 TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *C) {
8344 Vars.reserve(C->varlist_size());
8345 for (
auto *VE : C->varlists()) {
8346 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8347 if (EVar.isInvalid())
8349 Vars.push_back(EVar.get());
8351 return getDerived().RebuildOMPLastprivateClause(
8352 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8355 template <
typename Derived>
8357 TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *C) {
8359 Vars.reserve(C->varlist_size());
8360 for (
auto *VE : C->varlists()) {
8361 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8362 if (EVar.isInvalid())
8364 Vars.push_back(EVar.get());
8366 return getDerived().RebuildOMPSharedClause(Vars, C->getLocStart(),
8367 C->getLParenLoc(), C->getLocEnd());
8370 template <
typename Derived>
8372 TreeTransform<Derived>::TransformOMPReductionClause(OMPReductionClause *C) {
8374 Vars.reserve(C->varlist_size());
8375 for (
auto *VE : C->varlists()) {
8376 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8377 if (EVar.isInvalid())
8379 Vars.push_back(EVar.get());
8381 CXXScopeSpec ReductionIdScopeSpec;
8382 ReductionIdScopeSpec.Adopt(C->getQualifierLoc());
8384 DeclarationNameInfo NameInfo = C->getNameInfo();
8385 if (NameInfo.getName()) {
8386 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
8387 if (!NameInfo.getName())
8393 for (
auto *E : C->reduction_ops()) {
8396 auto *ULE = cast<UnresolvedLookupExpr>(
E);
8397 UnresolvedSet<8> Decls;
8398 for (
auto *D : ULE->decls()) {
8400 cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
8401 Decls.addDecl(InstD, InstD->getAccess());
8403 UnresolvedReductions.push_back(
8405 SemaRef.Context,
nullptr,
8406 ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context),
8407 NameInfo,
true, ULE->isOverloaded(),
8408 Decls.begin(), Decls.end()));
8410 UnresolvedReductions.push_back(
nullptr);
8412 return getDerived().RebuildOMPReductionClause(
8413 Vars, C->getLocStart(), C->getLParenLoc(), C->getColonLoc(),
8414 C->getLocEnd(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
8417 template <
typename Derived>
8418 OMPClause *TreeTransform<Derived>::TransformOMPTaskReductionClause(
8419 OMPTaskReductionClause *C) {
8421 Vars.reserve(C->varlist_size());
8422 for (
auto *VE : C->varlists()) {
8423 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8424 if (EVar.isInvalid())
8426 Vars.push_back(EVar.get());
8428 CXXScopeSpec ReductionIdScopeSpec;
8429 ReductionIdScopeSpec.Adopt(C->getQualifierLoc());
8431 DeclarationNameInfo NameInfo = C->getNameInfo();
8432 if (NameInfo.getName()) {
8433 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
8434 if (!NameInfo.getName())
8440 for (
auto *E : C->reduction_ops()) {
8443 auto *ULE = cast<UnresolvedLookupExpr>(
E);
8444 UnresolvedSet<8> Decls;
8445 for (
auto *D : ULE->decls()) {
8447 cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
8448 Decls.addDecl(InstD, InstD->getAccess());
8451 SemaRef.Context,
nullptr,
8452 ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), NameInfo,
8453 true, ULE->isOverloaded(), Decls.begin(), Decls.end()));
8455 UnresolvedReductions.push_back(
nullptr);
8457 return getDerived().RebuildOMPTaskReductionClause(
8458 Vars, C->getLocStart(), C->getLParenLoc(), C->getColonLoc(),
8459 C->getLocEnd(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
8462 template <
typename Derived>
8464 TreeTransform<Derived>::TransformOMPLinearClause(
OMPLinearClause *C) {
8466 Vars.reserve(C->varlist_size());
8467 for (
auto *VE : C->varlists()) {
8468 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8469 if (EVar.isInvalid())
8471 Vars.push_back(EVar.get());
8474 if (Step.isInvalid())
8476 return getDerived().RebuildOMPLinearClause(
8477 Vars, Step.get(), C->getLocStart(), C->getLParenLoc(), C->getModifier(),
8478 C->getModifierLoc(), C->getColonLoc(), C->getLocEnd());
8481 template <
typename Derived>
8485 Vars.reserve(C->varlist_size());
8486 for (
auto *VE : C->varlists()) {
8487 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8488 if (EVar.isInvalid())
8490 Vars.push_back(EVar.get());
8493 if (Alignment.isInvalid())
8495 return getDerived().RebuildOMPAlignedClause(
8496 Vars, Alignment.get(), C->getLocStart(), C->getLParenLoc(),
8500 template <
typename Derived>
8502 TreeTransform<Derived>::TransformOMPCopyinClause(
OMPCopyinClause *C) {
8504 Vars.reserve(C->varlist_size());
8505 for (
auto *VE : C->varlists()) {
8506 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8507 if (EVar.isInvalid())
8509 Vars.push_back(EVar.get());
8511 return getDerived().RebuildOMPCopyinClause(Vars, C->getLocStart(),
8512 C->getLParenLoc(), C->getLocEnd());
8515 template <
typename Derived>
8519 Vars.reserve(C->varlist_size());
8520 for (
auto *VE : C->varlists()) {
8521 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8522 if (EVar.isInvalid())
8524 Vars.push_back(EVar.get());
8526 return getDerived().RebuildOMPCopyprivateClause(
8527 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8530 template <
typename Derived>
8533 Vars.reserve(C->varlist_size());
8534 for (
auto *VE : C->varlists()) {
8535 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8536 if (EVar.isInvalid())
8538 Vars.push_back(EVar.get());
8540 return getDerived().RebuildOMPFlushClause(Vars, C->getLocStart(),
8541 C->getLParenLoc(), C->getLocEnd());
8544 template <
typename Derived>
8546 TreeTransform<Derived>::TransformOMPDependClause(
OMPDependClause *C) {
8548 Vars.reserve(C->varlist_size());
8549 for (
auto *VE : C->varlists()) {
8550 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8551 if (EVar.isInvalid())
8553 Vars.push_back(EVar.get());
8555 return getDerived().RebuildOMPDependClause(
8557 C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8560 template <
typename Derived>
8562 TreeTransform<Derived>::TransformOMPDeviceClause(
OMPDeviceClause *C) {
8566 return getDerived().RebuildOMPDeviceClause(
8567 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
8570 template <
typename Derived>
8573 Vars.reserve(C->varlist_size());
8574 for (
auto *VE : C->varlists()) {
8575 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8576 if (EVar.isInvalid())
8578 Vars.push_back(EVar.get());
8580 return getDerived().RebuildOMPMapClause(
8583 C->getLParenLoc(), C->getLocEnd());
8586 template <
typename Derived>
8592 return getDerived().RebuildOMPNumTeamsClause(
8593 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
8596 template <
typename Derived>
8602 return getDerived().RebuildOMPThreadLimitClause(
8603 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
8606 template <
typename Derived>
8612 return getDerived().RebuildOMPPriorityClause(
8613 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
8616 template <
typename Derived>
8622 return getDerived().RebuildOMPGrainsizeClause(
8623 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
8626 template <
typename Derived>
8632 return getDerived().RebuildOMPNumTasksClause(
8633 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
8636 template <
typename Derived>
8641 return getDerived().RebuildOMPHintClause(E.get(), C->getLocStart(),
8645 template <
typename Derived>
8646 OMPClause *TreeTransform<Derived>::TransformOMPDistScheduleClause(
8651 return getDerived().RebuildOMPDistScheduleClause(
8656 template <
typename Derived>
8662 template <
typename Derived>
8665 Vars.reserve(C->varlist_size());
8666 for (
auto *VE : C->varlists()) {
8667 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8668 if (EVar.isInvalid())
8670 Vars.push_back(EVar.get());
8672 return getDerived().RebuildOMPToClause(Vars, C->getLocStart(),
8673 C->getLParenLoc(), C->getLocEnd());
8676 template <
typename Derived>
8679 Vars.reserve(C->varlist_size());
8680 for (
auto *VE : C->varlists()) {
8681 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8682 if (EVar.isInvalid())
8684 Vars.push_back(EVar.get());
8686 return getDerived().RebuildOMPFromClause(Vars, C->getLocStart(),
8687 C->getLParenLoc(), C->getLocEnd());
8690 template <
typename Derived>
8691 OMPClause *TreeTransform<Derived>::TransformOMPUseDevicePtrClause(
8694 Vars.reserve(C->varlist_size());
8695 for (
auto *VE : C->varlists()) {
8696 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8697 if (EVar.isInvalid())
8699 Vars.push_back(EVar.get());
8701 return getDerived().RebuildOMPUseDevicePtrClause(
8702 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8705 template <
typename Derived>
8709 Vars.reserve(C->varlist_size());
8710 for (
auto *VE : C->varlists()) {
8711 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8712 if (EVar.isInvalid())
8714 Vars.push_back(EVar.get());
8716 return getDerived().RebuildOMPIsDevicePtrClause(
8717 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8723 template<
typename Derived>
8725 TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) {
8726 if (!E->isTypeDependent())
8729 return getDerived().RebuildPredefinedExpr(E->getLocation(),
8733 template<
typename Derived>
8735 TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) {
8736 NestedNameSpecifierLoc QualifierLoc;
8737 if (E->getQualifierLoc()) {
8739 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
8745 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
8750 DeclarationNameInfo NameInfo = E->getNameInfo();
8751 if (NameInfo.getName()) {
8752 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
8753 if (!NameInfo.getName())
8757 if (!getDerived().AlwaysRebuild() &&
8758 QualifierLoc == E->getQualifierLoc() &&
8759 ND == E->getDecl() &&
8760 NameInfo.getName() == E->getDecl()->getDeclName() &&
8761 !E->hasExplicitTemplateArgs()) {
8765 SemaRef.MarkDeclRefReferenced(E);
8770 TemplateArgumentListInfo TransArgs, *TemplateArgs =
nullptr;
8771 if (E->hasExplicitTemplateArgs()) {
8772 TemplateArgs = &TransArgs;
8773 TransArgs.setLAngleLoc(E->getLAngleLoc());
8774 TransArgs.setRAngleLoc(E->getRAngleLoc());
8775 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
8776 E->getNumTemplateArgs(),
8781 return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo,
8785 template<
typename Derived>
8787 TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) {
8791 template<
typename Derived>
8793 TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) {
8797 template<
typename Derived>
8799 TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) {
8803 template<
typename Derived>
8805 TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) {
8809 template<
typename Derived>
8811 TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) {
8815 template<
typename Derived>
8817 TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) {
8818 if (FunctionDecl *FD = E->getDirectCallee())
8819 SemaRef.MarkFunctionReferenced(E->getLocStart(), FD);
8820 return SemaRef.MaybeBindToTemporary(E);
8823 template<
typename Derived>
8825 TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) {
8827 getDerived().TransformExpr(E->getControllingExpr());
8828 if (ControllingExpr.isInvalid())
8831 SmallVector<Expr *, 4> AssocExprs;
8832 SmallVector<TypeSourceInfo *, 4> AssocTypes;
8833 for (
unsigned i = 0; i != E->getNumAssocs(); ++i) {
8834 TypeSourceInfo *TS = E->getAssocTypeSourceInfo(i);
8836 TypeSourceInfo *AssocType = getDerived().TransformType(TS);
8839 AssocTypes.push_back(AssocType);
8841 AssocTypes.push_back(
nullptr);
8844 ExprResult AssocExpr = getDerived().TransformExpr(E->getAssocExpr(i));
8845 if (AssocExpr.isInvalid())
8847 AssocExprs.push_back(AssocExpr.get());
8850 return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(),
8853 ControllingExpr.get(),
8858 template<
typename Derived>
8860 TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
8861 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
8862 if (SubExpr.isInvalid())
8865 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
8868 return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(),
8875 template<
typename Derived>
8879 return getDerived().TransformDependentScopeDeclRefExpr(DRE,
true,
nullptr);
8881 return getDerived().TransformExpr(E);
8884 template<
typename Derived>
8889 SubExpr = TransformAddressOfOperand(E->
getSubExpr());
8895 if (!getDerived().AlwaysRebuild() && SubExpr.
get() == E->
getSubExpr())
8903 template<
typename Derived>
8905 TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) {
8907 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
8917 bool ExprChanged =
false;
8918 typedef Sema::OffsetOfComponent Component;
8919 SmallVector<Component, 4> Components;
8920 for (
unsigned I = 0, N = E->getNumComponents();
I != N; ++
I) {
8921 const OffsetOfNode &ON = E->getComponent(
I);
8923 Comp.isBrackets =
true;
8924 Comp.LocStart = ON.getSourceRange().getBegin();
8925 Comp.LocEnd = ON.getSourceRange().getEnd();
8926 switch (ON.getKind()) {
8928 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex());
8929 ExprResult Index = getDerived().TransformExpr(FromIndex);
8930 if (Index.isInvalid())
8933 ExprChanged = ExprChanged || Index.
get() != FromIndex;
8934 Comp.isBrackets =
true;
8935 Comp.U.E = Index.get();
8941 Comp.isBrackets =
false;
8942 Comp.U.IdentInfo = ON.getFieldName();
8943 if (!Comp.U.IdentInfo)
8953 Components.push_back(Comp);
8957 if (!getDerived().AlwaysRebuild() &&
8958 Type == E->getTypeSourceInfo() &&
8963 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type,
8964 Components, E->getRParenLoc());
8967 template<
typename Derived>
8969 TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) {
8970 assert((!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) &&
8971 "opaque value expression requires transformation");
8975 template<
typename Derived>
8977 TreeTransform<Derived>::TransformTypoExpr(TypoExpr *E) {
8981 template<
typename Derived>
8983 TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) {
8990 Expr *newSyntacticForm = SemaRef.recreateSyntacticForm(E);
8991 ExprResult result = getDerived().TransformExpr(newSyntacticForm);
8992 if (result.isInvalid())
return ExprError();
8997 if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject))
8998 result = SemaRef.checkPseudoObjectRValue(result.get());
9003 template<
typename Derived>
9005 TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr(
9006 UnaryExprOrTypeTraitExpr *E) {
9007 if (E->isArgumentType()) {
9008 TypeSourceInfo *OldT = E->getArgumentTypeInfo();
9010 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
9014 if (!getDerived().AlwaysRebuild() && OldT == NewT)
9017 return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(),
9019 E->getSourceRange());
9025 EnterExpressionEvaluationContext Unevaluated(
9031 TypeSourceInfo *RecoveryTSI =
nullptr;
9033 auto *PE = dyn_cast<ParenExpr>(E->getArgumentExpr());
9035 PE ? dyn_cast<DependentScopeDeclRefExpr>(PE->getSubExpr()) :
nullptr)
9036 SubExpr = getDerived().TransformParenDependentScopeDeclRefExpr(
9037 PE, DRE,
false, &RecoveryTSI);
9039 SubExpr = getDerived().TransformExpr(E->getArgumentExpr());
9042 return getDerived().RebuildUnaryExprOrTypeTrait(
9043 RecoveryTSI, E->getOperatorLoc(), E->getKind(), E->getSourceRange());
9044 }
else if (SubExpr.isInvalid())
9047 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
9050 return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(),
9051 E->getOperatorLoc(),
9053 E->getSourceRange());
9056 template<
typename Derived>
9058 TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
9059 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
9060 if (LHS.isInvalid())
9063 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
9064 if (RHS.isInvalid())
9068 if (!getDerived().AlwaysRebuild() &&
9069 LHS.get() == E->getLHS() &&
9070 RHS.get() == E->getRHS())
9073 return getDerived().RebuildArraySubscriptExpr(LHS.get(),
9074 E->getLHS()->getLocStart(),
9076 E->getRBracketLoc());
9079 template <
typename Derived>
9081 TreeTransform<Derived>::TransformOMPArraySectionExpr(OMPArraySectionExpr *E) {
9082 ExprResult Base = getDerived().TransformExpr(E->getBase());
9083 if (Base.isInvalid())
9087 if (E->getLowerBound()) {
9088 LowerBound = getDerived().TransformExpr(E->getLowerBound());
9089 if (LowerBound.isInvalid())
9094 if (E->getLength()) {
9095 Length = getDerived().TransformExpr(E->getLength());
9096 if (Length.isInvalid())
9100 if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
9101 LowerBound.get() == E->getLowerBound() && Length.get() == E->getLength())
9104 return getDerived().RebuildOMPArraySectionExpr(
9105 Base.get(), E->getBase()->getLocEnd(), LowerBound.get(), E->getColonLoc(),
9106 Length.get(), E->getRBracketLoc());
9109 template<
typename Derived>
9111 TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
9113 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
9114 if (Callee.isInvalid())
9118 bool ArgChanged =
false;
9119 SmallVector<Expr*, 8> Args;
9120 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(),
true, Args,
9124 if (!getDerived().AlwaysRebuild() &&
9125 Callee.get() == E->getCallee() &&
9127 return SemaRef.MaybeBindToTemporary(E);
9130 SourceLocation FakeLParenLoc
9132 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
9137 template<
typename Derived>
9139 TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
9140 ExprResult Base = getDerived().TransformExpr(E->getBase());
9141 if (Base.isInvalid())
9144 NestedNameSpecifierLoc QualifierLoc;
9145 if (E->hasQualifier()) {
9147 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
9152 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
9155 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
9156 E->getMemberDecl()));
9160 NamedDecl *
FoundDecl = E->getFoundDecl();
9161 if (FoundDecl == E->getMemberDecl()) {
9164 FoundDecl = cast_or_null<NamedDecl>(
9165 getDerived().TransformDecl(E->getMemberLoc(),
FoundDecl));
9170 if (!getDerived().AlwaysRebuild() &&
9171 Base.get() == E->getBase() &&
9172 QualifierLoc == E->getQualifierLoc() &&
9173 Member == E->getMemberDecl() &&
9174 FoundDecl == E->getFoundDecl() &&
9175 !E->hasExplicitTemplateArgs()) {
9179 SemaRef.MarkMemberReferenced(E);
9184 TemplateArgumentListInfo TransArgs;
9185 if (E->hasExplicitTemplateArgs()) {
9186 TransArgs.setLAngleLoc(E->getLAngleLoc());
9187 TransArgs.setRAngleLoc(E->getRAngleLoc());
9188 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
9189 E->getNumTemplateArgs(),
9195 SourceLocation FakeOperatorLoc =
9196 SemaRef.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd());
9202 NamedDecl *FirstQualifierInScope =
nullptr;
9203 DeclarationNameInfo MemberNameInfo = E->getMemberNameInfo();
9204 if (MemberNameInfo.getName()) {
9205 MemberNameInfo = getDerived().TransformDeclarationNameInfo(MemberNameInfo);
9206 if (!MemberNameInfo.getName())
9210 return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc,
9217 (E->hasExplicitTemplateArgs()
9218 ? &TransArgs :
nullptr),
9219 FirstQualifierInScope);
9222 template<
typename Derived>
9224 TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
9225 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
9226 if (LHS.isInvalid())
9229 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
9230 if (RHS.isInvalid())
9233 if (!getDerived().AlwaysRebuild() &&
9234 LHS.get() == E->getLHS() &&
9235 RHS.get() == E->getRHS())
9238 Sema::FPContractStateRAII FPContractState(getSema());
9239 getSema().FPFeatures = E->getFPFeatures();
9241 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
9242 LHS.get(), RHS.get());
9245 template<
typename Derived>
9247 TreeTransform<Derived>::TransformCompoundAssignOperator(
9248 CompoundAssignOperator *E) {
9249 return getDerived().TransformBinaryOperator(E);
9252 template<
typename Derived>
9254 TransformBinaryConditionalOperator(BinaryConditionalOperator *e) {
9258 ExprResult commonExpr = getDerived().TransformExpr(e->getCommon());
9259 if (commonExpr.isInvalid())
9262 ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr());
9263 if (rhs.isInvalid())
9266 if (!getDerived().AlwaysRebuild() &&
9267 commonExpr.get() == e->getCommon() &&
9268 rhs.get() == e->getFalseExpr())
9271 return getDerived().RebuildConditionalOperator(commonExpr.get(),
9272 e->getQuestionLoc(),
9278 template<
typename Derived>
9280 TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) {
9281 ExprResult Cond = getDerived().TransformExpr(E->getCond());
9282 if (Cond.isInvalid())
9285 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
9286 if (LHS.isInvalid())
9289 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
9290 if (RHS.isInvalid())
9293 if (!getDerived().AlwaysRebuild() &&
9294 Cond.get() == E->getCond() &&
9295 LHS.get() == E->getLHS() &&
9296 RHS.get() == E->getRHS())
9299 return getDerived().RebuildConditionalOperator(Cond.get(),
9300 E->getQuestionLoc(),
9306 template<
typename Derived>
9308 TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) {
9311 return getDerived().TransformExpr(E->getSubExprAsWritten());
9314 template<
typename Derived>
9316 TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
9317 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
9322 = getDerived().TransformExpr(E->getSubExprAsWritten());
9323 if (SubExpr.isInvalid())
9326 if (!getDerived().AlwaysRebuild() &&
9327 Type == E->getTypeInfoAsWritten() &&
9328 SubExpr.get() == E->getSubExpr())
9331 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
9337 template<
typename Derived>
9339 TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) {
9340 TypeSourceInfo *OldT = E->getTypeSourceInfo();
9341 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
9345 ExprResult Init = getDerived().TransformExpr(E->getInitializer());
9346 if (Init.isInvalid())
9349 if (!getDerived().AlwaysRebuild() &&
9351 Init.get() == E->getInitializer())
9352 return SemaRef.MaybeBindToTemporary(E);
9358 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT,
9359 E->getInitializer()->getLocEnd(),
9363 template<
typename Derived>
9365 TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) {
9366 ExprResult Base = getDerived().TransformExpr(E->getBase());
9367 if (Base.isInvalid())
9370 if (!getDerived().AlwaysRebuild() &&
9371 Base.get() == E->getBase())
9375 SourceLocation FakeOperatorLoc =
9376 SemaRef.getLocForEndOfToken(E->getBase()->getLocEnd());
9377 return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc,
9378 E->getAccessorLoc(),
9382 template<
typename Derived>
9384 TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) {
9385 if (InitListExpr *Syntactic = E->getSyntacticForm())
9388 bool InitChanged =
false;
9390 SmallVector<Expr*, 4>
Inits;
9391 if (getDerived().TransformExprs(E->getInits(), E->getNumInits(),
false,
9392 Inits, &InitChanged))
9395 if (!getDerived().AlwaysRebuild() && !InitChanged) {
9402 return getDerived().RebuildInitList(E->getLBraceLoc(),
Inits,
9403 E->getRBraceLoc(), E->getType());
9406 template<
typename Derived>
9408 TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) {
9412 ExprResult Init = getDerived().TransformExpr(E->getInit());
9413 if (Init.isInvalid())
9417 SmallVector<Expr*, 4> ArrayExprs;
9418 bool ExprChanged =
false;
9419 for (
const DesignatedInitExpr::Designator &D : E->designators()) {
9420 if (D.isFieldDesignator()) {
9425 FieldDecl *
Field = cast_or_null<FieldDecl>(
9426 getDerived().TransformDecl(D.getFieldLoc(), D.getField()));
9427 if (Field != D.getField())
9440 if (D.isArrayDesignator()) {
9441 ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(D));
9442 if (Index.isInvalid())
9445 Desig.AddDesignator(
9448 ExprChanged = ExprChanged || Init.
get() != E->getArrayIndex(D);
9449 ArrayExprs.push_back(Index.get());
9453 assert(D.isArrayRangeDesignator() &&
"New kind of designator?");
9455 = getDerived().TransformExpr(E->getArrayRangeStart(D));
9456 if (Start.isInvalid())
9459 ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(D));
9460 if (End.isInvalid())
9466 D.getEllipsisLoc()));
9468 ExprChanged = ExprChanged || Start.
get() != E->getArrayRangeStart(D) ||
9469 End.get() != E->getArrayRangeEnd(D);
9471 ArrayExprs.push_back(Start.get());
9472 ArrayExprs.push_back(End.get());
9475 if (!getDerived().AlwaysRebuild() &&
9476 Init.get() == E->getInit() &&
9480 return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs,
9481 E->getEqualOrColonLoc(),
9482 E->usesGNUSyntax(), Init.get());
9487 template<
typename Derived>
9489 TreeTransform<Derived>::TransformDesignatedInitUpdateExpr(
9490 DesignatedInitUpdateExpr *E) {
9491 llvm_unreachable(
"Unexpected DesignatedInitUpdateExpr in syntactic form of "
9496 template<
typename Derived>
9498 TreeTransform<Derived>::TransformNoInitExpr(
9500 llvm_unreachable(
"Unexpected NoInitExpr in syntactic form of initializer");
9504 template<
typename Derived>
9506 TreeTransform<Derived>::TransformArrayInitLoopExpr(ArrayInitLoopExpr *E) {
9507 llvm_unreachable(
"Unexpected ArrayInitLoopExpr outside of initializer");
9511 template<
typename Derived>
9513 TreeTransform<Derived>::TransformArrayInitIndexExpr(ArrayInitIndexExpr *E) {
9514 llvm_unreachable(
"Unexpected ArrayInitIndexExpr outside of initializer");
9518 template<
typename Derived>
9520 TreeTransform<Derived>::TransformImplicitValueInitExpr(
9521 ImplicitValueInitExpr *E) {
9522 TemporaryBase Rebase(*
this, E->getLocStart(), DeclarationName());
9526 QualType T = getDerived().TransformType(E->getType());
9530 if (!getDerived().AlwaysRebuild() &&
9534 return getDerived().RebuildImplicitValueInitExpr(T);
9537 template<
typename Derived>
9539 TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) {
9540 TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo());
9544 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
9545 if (SubExpr.isInvalid())
9548 if (!getDerived().AlwaysRebuild() &&
9549 TInfo == E->getWrittenTypeInfo() &&
9550 SubExpr.get() == E->getSubExpr())
9553 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(),
9554 TInfo, E->getRParenLoc());
9557 template<
typename Derived>
9559 TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) {
9560 bool ArgumentChanged =
false;
9561 SmallVector<Expr*, 4>
Inits;
9562 if (TransformExprs(E->getExprs(), E->getNumExprs(),
true,
Inits,
9566 return getDerived().RebuildParenListExpr(E->getLParenLoc(),
9576 template<
typename Derived>
9578 TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) {
9579 Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(),
9584 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
9585 cast<LabelDecl>(LD));
9588 template<
typename Derived>
9590 TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) {
9591 SemaRef.ActOnStartStmtExpr();
9593 = getDerived().TransformCompoundStmt(E->getSubStmt(),
true);
9594 if (SubStmt.isInvalid()) {
9595 SemaRef.ActOnStmtExprError();
9599 if (!getDerived().AlwaysRebuild() &&
9600 SubStmt.get() == E->getSubStmt()) {
9602 SemaRef.ActOnStmtExprError();
9603 return SemaRef.MaybeBindToTemporary(E);
9606 return getDerived().RebuildStmtExpr(E->getLParenLoc(),
9611 template<
typename Derived>
9613 TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) {
9614 ExprResult Cond = getDerived().TransformExpr(E->getCond());
9615 if (Cond.isInvalid())
9618 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
9619 if (LHS.isInvalid())
9622 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
9623 if (RHS.isInvalid())
9626 if (!getDerived().AlwaysRebuild() &&
9627 Cond.get() == E->getCond() &&
9628 LHS.get() == E->getLHS() &&
9629 RHS.get() == E->getRHS())
9632 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(),
9633 Cond.get(), LHS.get(), RHS.get(),
9637 template<
typename Derived>
9639 TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) {
9643 template<
typename Derived>
9645 TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
9646 switch (E->getOperator()) {
9650 case OO_Array_Delete:
9651 llvm_unreachable(
"new and delete operators cannot use CXXOperatorCallExpr");
9655 assert(E->getNumArgs() >= 1 &&
"Object call is missing arguments");
9658 ExprResult Object = getDerived().TransformExpr(E->getArg(0));
9659 if (Object.isInvalid())
9663 SourceLocation FakeLParenLoc = SemaRef.getLocForEndOfToken(
9664 static_cast<Expr *>(Object.get())->getLocEnd());
9667 SmallVector<Expr*, 8> Args;
9668 if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1,
true,
9672 return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc,
9677 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
9679 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
9680 #include "clang/Basic/OperatorKinds.def"
9685 case OO_Conditional:
9686 llvm_unreachable(
"conditional operator is not actually overloadable");
9690 llvm_unreachable(
"not an overloaded operator?");
9693 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
9694 if (Callee.isInvalid())
9698 if (E->getOperator() == OO_Amp)
9699 First = getDerived().TransformAddressOfOperand(E->getArg(0));
9701 First = getDerived().TransformExpr(E->getArg(0));
9702 if (First.isInvalid())
9706 if (E->getNumArgs() == 2) {
9707 Second = getDerived().TransformExpr(E->getArg(1));
9708 if (Second.isInvalid())
9712 if (!getDerived().AlwaysRebuild() &&
9713 Callee.get() == E->getCallee() &&
9714 First.get() == E->getArg(0) &&
9715 (E->getNumArgs() != 2 || Second.get() == E->getArg(1)))
9716 return SemaRef.MaybeBindToTemporary(E);
9718 Sema::FPContractStateRAII FPContractState(getSema());
9719 getSema().FPFeatures = E->getFPFeatures();
9721 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(),
9722 E->getOperatorLoc(),
9728 template<
typename Derived>
9730 TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) {
9731 return getDerived().TransformCallExpr(E);
9734 template<
typename Derived>
9736 TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
9738 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
9739 if (Callee.isInvalid())
9743 ExprResult EC = getDerived().TransformCallExpr(E->getConfig());
9748 bool ArgChanged =
false;
9749 SmallVector<Expr*, 8> Args;
9750 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(),
true, Args,
9754 if (!getDerived().AlwaysRebuild() &&
9755 Callee.get() == E->getCallee() &&
9757 return SemaRef.MaybeBindToTemporary(E);
9760 SourceLocation FakeLParenLoc
9762 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
9764 E->getRParenLoc(), EC.get());
9767 template<
typename Derived>
9779 if (!getDerived().AlwaysRebuild() &&
9783 return getDerived().RebuildCXXNamedCastExpr(
9790 template<
typename Derived>
9796 template<
typename Derived>
9798 TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
9799 return getDerived().TransformCXXNamedCastExpr(E);
9802 template<
typename Derived>
9804 TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
9805 CXXReinterpretCastExpr *E) {
9806 return getDerived().TransformCXXNamedCastExpr(E);
9809 template<
typename Derived>
9811 TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) {
9812 return getDerived().TransformCXXNamedCastExpr(E);
9815 template<
typename Derived>
9817 TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
9818 CXXFunctionalCastExpr *E) {
9819 TypeSourceInfo *Type =
9820 getDerived().TransformTypeWithDeducedTST(E->getTypeInfoAsWritten());
9825 = getDerived().TransformExpr(E->getSubExprAsWritten());
9826 if (SubExpr.isInvalid())
9829 if (!getDerived().AlwaysRebuild() &&
9830 Type == E->getTypeInfoAsWritten() &&
9831 SubExpr.get() == E->getSubExpr())
9834 return getDerived().RebuildCXXFunctionalCastExpr(Type,
9840 template<
typename Derived>
9842 TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) {
9843 if (E->isTypeOperand()) {
9844 TypeSourceInfo *TInfo
9845 = getDerived().TransformType(E->getTypeOperandSourceInfo());
9849 if (!getDerived().AlwaysRebuild() &&
9850 TInfo == E->getTypeOperandSourceInfo())
9853 return getDerived().RebuildCXXTypeidExpr(E->getType(),
9863 EnterExpressionEvaluationContext Unevaluated(
9867 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
9868 if (SubExpr.isInvalid())
9871 if (!getDerived().AlwaysRebuild() &&
9872 SubExpr.get() == E->getExprOperand())
9875 return getDerived().RebuildCXXTypeidExpr(E->getType(),
9881 template<
typename Derived>
9883 TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) {
9884 if (E->isTypeOperand()) {
9885 TypeSourceInfo *TInfo
9886 = getDerived().TransformType(E->getTypeOperandSourceInfo());
9890 if (!getDerived().AlwaysRebuild() &&
9891 TInfo == E->getTypeOperandSourceInfo())
9894 return getDerived().RebuildCXXUuidofExpr(E->getType(),
9900 EnterExpressionEvaluationContext Unevaluated(
9903 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
9904 if (SubExpr.isInvalid())
9907 if (!getDerived().AlwaysRebuild() &&
9908 SubExpr.get() == E->getExprOperand())
9911 return getDerived().RebuildCXXUuidofExpr(E->getType(),
9917 template<
typename Derived>
9919 TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
9923 template<
typename Derived>
9925 TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
9926 CXXNullPtrLiteralExpr *E) {
9930 template<
typename Derived>
9932 TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) {
9933 QualType T = getSema().getCurrentThisType();
9935 if (!getDerived().AlwaysRebuild() && T == E->getType()) {
9937 getSema().CheckCXXThisCapture(E->getLocStart());
9941 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit());
9944 template<
typename Derived>
9946 TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) {
9947 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
9948 if (SubExpr.isInvalid())
9951 if (!getDerived().AlwaysRebuild() &&
9952 SubExpr.get() == E->getSubExpr())
9955 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(),
9956 E->isThrownVariableInScope());
9959 template<
typename Derived>
9961 TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
9963 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(),
9968 if (!getDerived().AlwaysRebuild() &&
9969 Param == E->getParam())
9972 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param);
9975 template<
typename Derived>
9977 TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
9979 = cast_or_null<FieldDecl>(getDerived().TransformDecl(E->getLocStart(),
9984 if (!getDerived().AlwaysRebuild() && Field == E->getField())
9987 return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field);
9990 template<
typename Derived>
9992 TreeTransform<Derived>::TransformCXXScalarValueInitExpr(
9993 CXXScalarValueInitExpr *E) {
9994 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
9998 if (!getDerived().AlwaysRebuild() &&
9999 T == E->getTypeSourceInfo())
10002 return getDerived().RebuildCXXScalarValueInitExpr(T,
10003 T->getTypeLoc().getEndLoc(),
10004 E->getRParenLoc());
10007 template<
typename Derived>
10009 TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) {
10011 TypeSourceInfo *AllocTypeInfo =
10012 getDerived().TransformTypeWithDeducedTST(E->getAllocatedTypeSourceInfo());
10013 if (!AllocTypeInfo)
10017 ExprResult ArraySize = getDerived().TransformExpr(E->getArraySize());
10018 if (ArraySize.isInvalid())
10022 bool ArgumentChanged =
false;
10023 SmallVector<Expr*, 8> PlacementArgs;
10024 if (getDerived().TransformExprs(E->getPlacementArgs(),
10025 E->getNumPlacementArgs(),
true,
10026 PlacementArgs, &ArgumentChanged))
10030 Expr *OldInit = E->getInitializer();
10033 NewInit = getDerived().TransformInitializer(OldInit,
true);
10034 if (NewInit.isInvalid())
10038 FunctionDecl *OperatorNew =
nullptr;
10039 if (E->getOperatorNew()) {
10040 OperatorNew = cast_or_null<FunctionDecl>(
10041 getDerived().TransformDecl(E->getLocStart(),
10042 E->getOperatorNew()));
10047 FunctionDecl *OperatorDelete =
nullptr;
10048 if (E->getOperatorDelete()) {
10049 OperatorDelete = cast_or_null<FunctionDecl>(
10050 getDerived().TransformDecl(E->getLocStart(),
10051 E->getOperatorDelete()));
10052 if (!OperatorDelete)
10056 if (!getDerived().AlwaysRebuild() &&
10057 AllocTypeInfo == E->getAllocatedTypeSourceInfo() &&
10058 ArraySize.get() == E->getArraySize() &&
10059 NewInit.get() == OldInit &&
10060 OperatorNew == E->getOperatorNew() &&
10061 OperatorDelete == E->getOperatorDelete() &&
10062 !ArgumentChanged) {
10066 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorNew);
10067 if (OperatorDelete)
10068 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete);
10070 if (E->isArray() && !E->getAllocatedType()->isDependentType()) {
10071 QualType ElementType
10072 = SemaRef.Context.getBaseElementType(E->getAllocatedType());
10073 if (
const RecordType *RecordT = ElementType->getAs<RecordType>()) {
10074 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordT->getDecl());
10075 if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(Record)) {
10076 SemaRef.MarkFunctionReferenced(E->getLocStart(),
Destructor);
10084 QualType AllocType = AllocTypeInfo->getType();
10085 if (!ArraySize.get()) {
10091 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType);
10094 }
else if (
const ConstantArrayType *ConsArrayT
10095 = dyn_cast<ConstantArrayType>(ArrayT)) {
10097 SemaRef.Context.getSizeType(),
10099 AllocType = ConsArrayT->getElementType();
10100 }
else if (
const DependentSizedArrayType *DepArrayT
10101 = dyn_cast<DependentSizedArrayType>(ArrayT)) {
10102 if (DepArrayT->getSizeExpr()) {
10103 ArraySize = DepArrayT->getSizeExpr();
10104 AllocType = DepArrayT->getElementType();
10109 return getDerived().RebuildCXXNewExpr(E->getLocStart(),
10114 E->getTypeIdParens(),
10118 E->getDirectInitRange(),
10122 template<
typename Derived>
10124 TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) {
10125 ExprResult Operand = getDerived().TransformExpr(E->getArgument());
10126 if (Operand.isInvalid())
10130 FunctionDecl *OperatorDelete =
nullptr;
10131 if (E->getOperatorDelete()) {
10132 OperatorDelete = cast_or_null<FunctionDecl>(
10133 getDerived().TransformDecl(E->getLocStart(),
10134 E->getOperatorDelete()));
10135 if (!OperatorDelete)
10139 if (!getDerived().AlwaysRebuild() &&
10140 Operand.get() == E->getArgument() &&
10141 OperatorDelete == E->getOperatorDelete()) {
10144 if (OperatorDelete)
10145 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete);
10147 if (!E->getArgument()->isTypeDependent()) {
10148 QualType Destroyed = SemaRef.Context.getBaseElementType(
10149 E->getDestroyedType());
10150 if (
const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
10151 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
10152 SemaRef.MarkFunctionReferenced(E->getLocStart(),
10153 SemaRef.LookupDestructor(Record));
10160 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(),
10161 E->isGlobalDelete(),
10166 template<
typename Derived>
10168 TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
10169 CXXPseudoDestructorExpr *E) {
10170 ExprResult Base = getDerived().TransformExpr(E->getBase());
10171 if (Base.isInvalid())
10175 bool MayBePseudoDestructor =
false;
10176 Base = SemaRef.ActOnStartCXXMemberReference(
nullptr, Base.get(),
10177 E->getOperatorLoc(),
10178 E->isArrow()? tok::arrow : tok::period,
10180 MayBePseudoDestructor);
10181 if (Base.isInvalid())
10184 QualType ObjectType = ObjectTypePtr.
get();
10185 NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc();
10186 if (QualifierLoc) {
10188 = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType);
10193 SS.Adopt(QualifierLoc);
10195 PseudoDestructorTypeStorage Destroyed;
10196 if (E->getDestroyedTypeInfo()) {
10197 TypeSourceInfo *DestroyedTypeInfo
10198 = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(),
10199 ObjectType,
nullptr, SS);
10200 if (!DestroyedTypeInfo)
10202 Destroyed = DestroyedTypeInfo;
10203 }
else if (!ObjectType.isNull() && ObjectType->isDependentType()) {
10206 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(),
10207 E->getDestroyedTypeLoc());
10210 ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(),
10211 *E->getDestroyedTypeIdentifier(),
10212 E->getDestroyedTypeLoc(),
10220 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T),
10221 E->getDestroyedTypeLoc());
10224 TypeSourceInfo *ScopeTypeInfo =
nullptr;
10225 if (E->getScopeTypeInfo()) {
10226 CXXScopeSpec EmptySS;
10227 ScopeTypeInfo = getDerived().TransformTypeInObjectScope(
10228 E->getScopeTypeInfo(), ObjectType,
nullptr, EmptySS);
10229 if (!ScopeTypeInfo)
10233 return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(),
10234 E->getOperatorLoc(),
10238 E->getColonColonLoc(),
10243 template <
typename Derived>
10248 bool AllEmptyPacks =
true;
10249 for (
auto *OldD : Old->
decls()) {
10250 Decl *InstD = getDerived().TransformDecl(Old->
getNameLoc(), OldD);
10254 if (isa<UsingShadowDecl>(OldD))
10263 NamedDecl *SingleDecl = cast<NamedDecl>(InstD);
10265 if (
auto *UPD = dyn_cast<UsingPackDecl>(InstD))
10266 Decls = UPD->expansions();
10269 for (
auto *D : Decls) {
10270 if (
auto *UD = dyn_cast<UsingDecl>(D)) {
10271 for (
auto *SD : UD->shadows())
10278 AllEmptyPacks &= Decls.empty();
10287 if (AllEmptyPacks && !RequiresADL) {
10288 getSema().Diag(Old->
getNameLoc(), diag::err_using_pack_expansion_empty)
10299 template<
typename Derived>
10307 if (TransformOverloadExprDecls(Old, Old->
requiresADL(), R))
10314 = getDerived().TransformNestedNameSpecifierLoc(Old->
getQualifierLoc());
10318 SS.
Adopt(QualifierLoc);
10322 CXXRecordDecl *NamingClass
10323 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
10326 if (!NamingClass) {
10331 R.setNamingClass(NamingClass);
10339 NamedDecl *D = R.getAsSingle<NamedDecl>();
10343 if (D && D->isCXXInstanceMember()) {
10344 return SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, R,
10349 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->
requiresADL());
10363 return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R,
10367 template<
typename Derived>
10369 TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) {
10370 bool ArgChanged =
false;
10371 SmallVector<TypeSourceInfo *, 4> Args;
10372 for (
unsigned I = 0, N = E->getNumArgs();
I != N; ++
I) {
10373 TypeSourceInfo *From = E->getArg(
I);
10374 TypeLoc FromTL = From->getTypeLoc();
10375 if (!FromTL.getAs<PackExpansionTypeLoc>()) {
10376 TypeLocBuilder TLB;
10377 TLB.reserve(FromTL.getFullDataSize());
10378 QualType To = getDerived().TransformType(TLB, FromTL);
10382 if (To == From->getType())
10383 Args.push_back(From);
10385 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
10394 PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>();
10395 TypeLoc PatternTL = ExpansionTL.getPatternLoc();
10396 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
10397 SemaRef.collectUnexpandedParameterPacks(PatternTL, Unexpanded);
10401 bool Expand =
true;
10402 bool RetainExpansion =
false;
10403 Optional<unsigned> OrigNumExpansions =
10404 ExpansionTL.getTypePtr()->getNumExpansions();
10405 Optional<unsigned> NumExpansions = OrigNumExpansions;
10406 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
10407 PatternTL.getSourceRange(),
10409 Expand, RetainExpansion,
10417 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
10419 TypeLocBuilder TLB;
10420 TLB.reserve(From->getTypeLoc().getFullDataSize());
10422 QualType To = getDerived().TransformType(TLB, PatternTL);
10426 To = getDerived().RebuildPackExpansionType(To,
10427 PatternTL.getSourceRange(),
10428 ExpansionTL.getEllipsisLoc(),
10433 PackExpansionTypeLoc ToExpansionTL
10434 = TLB.push<PackExpansionTypeLoc>(To);
10435 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
10436 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
10442 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
10443 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef,
I);
10444 TypeLocBuilder TLB;
10445 TLB.reserve(PatternTL.getFullDataSize());
10446 QualType To = getDerived().TransformType(TLB, PatternTL);
10450 if (To->containsUnexpandedParameterPack()) {
10451 To = getDerived().RebuildPackExpansionType(To,
10452 PatternTL.getSourceRange(),
10453 ExpansionTL.getEllipsisLoc(),
10458 PackExpansionTypeLoc ToExpansionTL
10459 = TLB.push<PackExpansionTypeLoc>(To);
10460 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
10463 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
10466 if (!RetainExpansion)
10471 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
10473 TypeLocBuilder TLB;
10474 TLB.reserve(From->getTypeLoc().getFullDataSize());
10476 QualType To = getDerived().TransformType(TLB, PatternTL);
10480 To = getDerived().RebuildPackExpansionType(To,
10481 PatternTL.getSourceRange(),
10482 ExpansionTL.getEllipsisLoc(),
10487 PackExpansionTypeLoc ToExpansionTL
10488 = TLB.push<PackExpansionTypeLoc>(To);
10489 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
10490 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
10493 if (!getDerived().AlwaysRebuild() && !ArgChanged)
10496 return getDerived().RebuildTypeTrait(E->getTrait(),
10502 template<
typename Derived>
10504 TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
10505 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo());
10509 if (!getDerived().AlwaysRebuild() &&
10510 T == E->getQueriedTypeSourceInfo())
10515 EnterExpressionEvaluationContext Unevaluated(
10517 SubExpr = getDerived().TransformExpr(E->getDimensionExpression());
10518 if (SubExpr.isInvalid())
10521 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getDimensionExpression())
10525 return getDerived().RebuildArrayTypeTrait(E->getTrait(),
10532 template<
typename Derived>
10534 TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) {
10537 EnterExpressionEvaluationContext Unevaluated(
10539 SubExpr = getDerived().TransformExpr(E->getQueriedExpression());
10540 if (SubExpr.isInvalid())
10543 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression())
10547 return getDerived().RebuildExpressionTrait(
10548 E->getTrait(), E->getLocStart(), SubExpr.get(), E->getLocEnd());
10551 template <
typename Derived>
10555 ExprResult NewDRE = getDerived().TransformDependentScopeDeclRefExpr(
10556 DRE, AddrTaken, RecoveryTSI);
10563 if (!getDerived().AlwaysRebuild() && NewDRE.
get() == DRE)
10565 return getDerived().RebuildParenExpr(NewDRE.
get(), PE->
getLParen(),
10569 template <
typename Derived>
10572 return TransformDependentScopeDeclRefExpr(E,
false,
10576 template<
typename Derived>
10580 bool IsAddressOfOperand,
10584 = getDerived().TransformNestedNameSpecifierLoc(E->
getQualifierLoc());
10594 = getDerived().TransformDeclarationNameInfo(E->
getNameInfo());
10599 if (!getDerived().AlwaysRebuild() &&
10606 return getDerived().RebuildDependentScopeDeclRefExpr(
10607 QualifierLoc, TemplateKWLoc, NameInfo,
nullptr,
10608 IsAddressOfOperand, RecoveryTSI);
10617 return getDerived().RebuildDependentScopeDeclRefExpr(
10618 QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand,
10622 template<
typename Derived>
10624 TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) {
10628 if ((E->getNumArgs() == 1 ||
10629 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) &&
10630 (!getDerived().DropCallArgument(E->getArg(0))) &&
10631 !E->isListInitialization())
10632 return getDerived().TransformExpr(E->getArg(0));
10634 TemporaryBase Rebase(*
this, E->getLocStart(), DeclarationName());
10636 QualType T = getDerived().TransformType(E->getType());
10641 = cast_or_null<CXXConstructorDecl>(
10642 getDerived().TransformDecl(E->getLocStart(),
10643 E->getConstructor()));
10647 bool ArgumentChanged =
false;
10648 SmallVector<Expr*, 8> Args;
10649 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(),
true, Args,
10653 if (!getDerived().AlwaysRebuild() &&
10654 T == E->getType() &&
10655 Constructor == E->getConstructor() &&
10656 !ArgumentChanged) {
10659 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor);
10663 return getDerived().RebuildCXXConstructExpr(T, E->getLocStart(),
10665 E->isElidable(), Args,
10666 E->hadMultipleCandidates(),
10667 E->isListInitialization(),
10668 E->isStdInitListInitialization(),
10669 E->requiresZeroInitialization(),
10670 E->getConstructionKind(),
10671 E->getParenOrBraceRange());
10674 template<
typename Derived>
10675 ExprResult TreeTransform<Derived>::TransformCXXInheritedCtorInitExpr(
10676 CXXInheritedCtorInitExpr *E) {
10677 QualType T = getDerived().TransformType(E->getType());
10681 CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
10682 getDerived().TransformDecl(E->getLocStart(), E->getConstructor()));
10686 if (!getDerived().AlwaysRebuild() &&
10687 T == E->getType() &&
10688 Constructor == E->getConstructor()) {
10691 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor);
10695 return getDerived().RebuildCXXInheritedCtorInitExpr(
10696 T, E->getLocation(), Constructor,
10697 E->constructsVBase(), E->inheritedFromVBase());
10704 template<
typename Derived>
10706 TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
10707 return getDerived().TransformExpr(E->getSubExpr());
10715 template<
typename Derived>
10717 TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) {
10718 return getDerived().TransformExpr(E->getSubExpr());
10721 template<
typename Derived>
10723 TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
10724 CXXTemporaryObjectExpr *E) {
10725 TypeSourceInfo *T =
10726 getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo());
10730 CXXConstructorDecl *Constructor
10731 = cast_or_null<CXXConstructorDecl>(
10732 getDerived().TransformDecl(E->getLocStart(),
10733 E->getConstructor()));
10737 bool ArgumentChanged =
false;
10738 SmallVector<Expr*, 8> Args;
10739 Args.reserve(E->getNumArgs());
10740 if (TransformExprs(E->getArgs(), E->getNumArgs(),
true, Args,
10744 if (!getDerived().AlwaysRebuild() &&
10745 T == E->getTypeSourceInfo() &&
10746 Constructor == E->getConstructor() &&
10747 !ArgumentChanged) {
10749 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor);
10750 return SemaRef.MaybeBindToTemporary(E);
10754 return getDerived().RebuildCXXTemporaryObjectExpr(T,
10755 T->getTypeLoc().getEndLoc(),
10760 template<
typename Derived>
10762 TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
10765 typedef std::pair<ExprResult, QualType> InitCaptureInfoTy;
10766 SmallVector<InitCaptureInfoTy, 8> InitCaptureExprsAndTypes;
10767 InitCaptureExprsAndTypes.resize(E->explicit_capture_end() -
10768 E->explicit_capture_begin());
10770 CEnd = E->capture_end();
10772 if (!E->isInitCapture(C))
10774 EnterExpressionEvaluationContext EEEC(
10776 ExprResult NewExprInitResult = getDerived().TransformInitializer(
10777 C->getCapturedVar()->getInit(),
10780 if (NewExprInitResult.isInvalid())
10782 Expr *NewExprInit = NewExprInitResult.
get();
10784 VarDecl *OldVD = C->getCapturedVar();
10785 QualType NewInitCaptureType =
10786 getSema().buildLambdaInitCaptureInitialization(
10787 C->getLocation(), OldVD->getType()->isReferenceType(),
10788 OldVD->getIdentifier(),
10789 C->getCapturedVar()->getInitStyle() !=
VarDecl::CInit, NewExprInit);
10790 NewExprInitResult = NewExprInit;
10791 InitCaptureExprsAndTypes[C - E->capture_begin()] =
10792 std::make_pair(NewExprInitResult, NewInitCaptureType);
10797 auto TPL = getDerived().TransformTemplateParameterList(
10798 E->getTemplateParameterList());
10804 TypeSourceInfo *NewCallOpTSI =
nullptr;
10806 TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo();
10807 FunctionProtoTypeLoc OldCallOpFPTL =
10808 OldCallOpTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>();
10810 TypeLocBuilder NewCallOpTLBuilder;
10811 SmallVector<QualType, 4> ExceptionStorage;
10812 TreeTransform *This =
this;
10813 QualType NewCallOpType = TransformFunctionProtoType(
10814 NewCallOpTLBuilder, OldCallOpFPTL,
nullptr, 0,
10815 [&](FunctionProtoType::ExceptionSpecInfo &ESI,
bool &Changed) {
10816 return This->TransformExceptionSpec(OldCallOpFPTL.getBeginLoc(), ESI,
10817 ExceptionStorage, Changed);
10819 if (NewCallOpType.isNull())
10821 NewCallOpTSI = NewCallOpTLBuilder.getTypeSourceInfo(getSema().
Context,
10825 LambdaScopeInfo *LSI = getSema().PushLambdaScope();
10826 Sema::FunctionScopeRAII FuncScopeCleanup(getSema());
10827 LSI->GLTemplateParameterList = TPL;
10830 CXXRecordDecl *
Class
10831 = getSema().createLambdaClosureType(E->getIntroducerRange(),
10834 E->getCaptureDefault());
10835 getDerived().transformedLocalDecl(E->getLambdaClass(), Class);
10838 CXXMethodDecl *NewCallOperator = getSema().startLambdaDefinition(
10839 Class, E->getIntroducerRange(), NewCallOpTSI,
10840 E->getCallOperator()->getLocEnd(),
10841 NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams(),
10842 E->getCallOperator()->isConstexpr());
10844 LSI->CallOperator = NewCallOperator;
10846 for (
unsigned I = 0, NumParams = NewCallOperator->getNumParams();
10847 I != NumParams; ++
I) {
10848 auto *
P = NewCallOperator->getParamDecl(
I);
10849 if (
P->hasUninstantiatedDefaultArg()) {
10850 EnterExpressionEvaluationContext Eval(
10854 E->getCallOperator()->getParamDecl(
I)->getDefaultArg());
10855 P->setDefaultArg(R.get());
10859 getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
10860 getDerived().transformedLocalDecl(E->getCallOperator(), NewCallOperator);
10863 Sema::ContextRAII SavedContext(getSema(), NewCallOperator,
10867 getSema().buildLambdaScope(LSI, NewCallOperator,
10868 E->getIntroducerRange(),
10869 E->getCaptureDefault(),
10870 E->getCaptureDefaultLoc(),
10871 E->hasExplicitParameters(),
10872 E->hasExplicitResultType(),
10878 bool FinishedExplicitCaptures =
false;
10880 CEnd = E->capture_end();
10884 if (!FinishedExplicitCaptures && C->isImplicit()) {
10885 getSema().finishLambdaExplicitCaptures(LSI);
10886 FinishedExplicitCaptures =
true;
10890 if (C->capturesThis()) {
10891 getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(),
10898 if (C->capturesVLAType())
10902 if (E->isInitCapture(C)) {
10903 InitCaptureInfoTy InitExprTypePair =
10904 InitCaptureExprsAndTypes[C - E->capture_begin()];
10906 QualType InitQualType = InitExprTypePair.second;
10907 if (Init.isInvalid() || InitQualType.isNull()) {
10911 VarDecl *OldVD = C->getCapturedVar();
10912 VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl(
10913 OldVD->getLocation(), InitExprTypePair.second, OldVD->getIdentifier(),
10914 OldVD->getInitStyle(), Init.get());
10918 getDerived().transformedLocalDecl(OldVD, NewVD);
10920 getSema().buildInitCaptureField(LSI, NewVD);
10924 assert(C->capturesVariable() &&
"unexpected kind of lambda capture");
10932 SourceLocation EllipsisLoc;
10933 if (C->isPackExpansion()) {
10935 bool ShouldExpand =
false;
10936 bool RetainExpansion =
false;
10937 Optional<unsigned> NumExpansions;
10938 if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(),
10941 ShouldExpand, RetainExpansion,
10947 if (ShouldExpand) {
10951 VarDecl *Pack = C->getCapturedVar();
10952 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
10953 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(),
I);
10954 VarDecl *CapturedVar
10955 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
10957 if (!CapturedVar) {
10963 getSema().tryCaptureVariable(CapturedVar, C->getLocation(),
Kind);
10971 EllipsisLoc = C->getEllipsisLoc();
10975 VarDecl *CapturedVar
10976 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
10977 C->getCapturedVar()));
10978 if (!CapturedVar || CapturedVar->isInvalidDecl()) {
10984 getSema().tryCaptureVariable(CapturedVar, C->getLocation(),
Kind,
10987 if (!FinishedExplicitCaptures)
10988 getSema().finishLambdaExplicitCaptures(LSI);
10992 getSema().PushExpressionEvaluationContext(
10997 Invalid ?
StmtError() : getDerived().TransformStmt(E->getBody());
11000 FuncScopeCleanup.disable();
11002 if (Body.isInvalid()) {
11003 SavedContext.pop();
11004 getSema().ActOnLambdaError(E->getLocStart(),
nullptr,
11012 auto LSICopy = *LSI;
11013 getSema().ActOnFinishFunctionBody(NewCallOperator, Body.get(),
11015 SavedContext.pop();
11017 return getSema().BuildLambdaExpr(E->getLocStart(), Body.get()->getLocEnd(),
11021 template<
typename Derived>
11023 TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
11024 CXXUnresolvedConstructExpr *E) {
11025 TypeSourceInfo *T =
11026 getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo());
11030 bool ArgumentChanged =
false;
11031 SmallVector<Expr*, 8> Args;
11032 Args.reserve(E->arg_size());
11033 if (getDerived().TransformExprs(E->arg_begin(), E->arg_size(),
true, Args,
11037 if (!getDerived().AlwaysRebuild() &&
11038 T == E->getTypeSourceInfo() &&
11043 return getDerived().RebuildCXXUnresolvedConstructExpr(T,
11046 E->getRParenLoc());
11049 template<
typename Derived>
11051 TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
11052 CXXDependentScopeMemberExpr *E) {
11057 QualType ObjectType;
11058 if (!E->isImplicitAccess()) {
11059 OldBase = E->getBase();
11060 Base = getDerived().TransformExpr(OldBase);
11061 if (Base.isInvalid())
11066 bool MayBePseudoDestructor =
false;
11067 Base = SemaRef.ActOnStartCXXMemberReference(
nullptr, Base.get(),
11068 E->getOperatorLoc(),
11069 E->isArrow()? tok::arrow : tok::period,
11071 MayBePseudoDestructor);
11072 if (Base.isInvalid())
11075 ObjectType = ObjectTy.
get();
11076 BaseType = ((Expr*) Base.get())->getType();
11079 BaseType = getDerived().TransformType(E->getBaseType());
11080 ObjectType = BaseType->getAs<PointerType>()->getPointeeType();
11085 NamedDecl *FirstQualifierInScope
11086 = getDerived().TransformFirstQualifierInScope(
11087 E->getFirstQualifierFoundInScope(),
11088 E->getQualifierLoc().getBeginLoc());
11090 NestedNameSpecifierLoc QualifierLoc;
11091 if (E->getQualifier()) {
11093 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(),
11095 FirstQualifierInScope);
11100 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
11106 DeclarationNameInfo NameInfo
11107 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo());
11108 if (!NameInfo.getName())
11111 if (!E->hasExplicitTemplateArgs()) {
11114 if (!getDerived().AlwaysRebuild() &&
11115 Base.get() == OldBase &&
11116 BaseType == E->getBaseType() &&
11117 QualifierLoc == E->getQualifierLoc() &&
11118 NameInfo.getName() == E->getMember() &&
11119 FirstQualifierInScope == E->getFirstQualifierFoundInScope())
11122 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
11125 E->getOperatorLoc(),
11128 FirstQualifierInScope,
11133 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
11134 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
11135 E->getNumTemplateArgs(),
11139 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
11142 E->getOperatorLoc(),
11145 FirstQualifierInScope,
11150 template<
typename Derived>
11152 TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) {
11156 if (!Old->isImplicitAccess()) {
11157 Base = getDerived().TransformExpr(Old->getBase());
11158 if (Base.isInvalid())
11160 Base = getSema().PerformMemberExprBaseConversion(Base.get(),
11162 if (Base.isInvalid())
11166 BaseType = getDerived().TransformType(Old->getBaseType());
11169 NestedNameSpecifierLoc QualifierLoc;
11170 if (Old->getQualifierLoc()) {
11172 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
11177 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
11179 LookupResult R(SemaRef, Old->getMemberNameInfo(),
11183 if (TransformOverloadExprDecls(Old,
false, R))
11187 if (Old->getNamingClass()) {
11188 CXXRecordDecl *NamingClass
11189 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
11190 Old->getMemberLoc(),
11191 Old->getNamingClass()));
11195 R.setNamingClass(NamingClass);
11198 TemplateArgumentListInfo TransArgs;
11199 if (Old->hasExplicitTemplateArgs()) {
11200 TransArgs.setLAngleLoc(Old->getLAngleLoc());
11201 TransArgs.setRAngleLoc(Old->getRAngleLoc());
11202 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
11203 Old->getNumTemplateArgs(),
11212 NamedDecl *FirstQualifierInScope =
nullptr;
11214 return getDerived().RebuildUnresolvedMemberExpr(Base.get(),
11216 Old->getOperatorLoc(),
11220 FirstQualifierInScope,
11222 (Old->hasExplicitTemplateArgs()
11223 ? &TransArgs :
nullptr));
11226 template<
typename Derived>
11228 TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) {
11229 EnterExpressionEvaluationContext Unevaluated(
11231 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand());
11232 if (SubExpr.isInvalid())
11235 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand())
11238 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get());
11241 template<
typename Derived>
11243 TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) {
11244 ExprResult Pattern = getDerived().TransformExpr(E->getPattern());
11245 if (Pattern.isInvalid())
11248 if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern())
11251 return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(),
11252 E->getNumExpansions());
11255 template<
typename Derived>
11257 TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) {
11260 if (!E->isValueDependent())
11263 EnterExpressionEvaluationContext Unevaluated(
11266 ArrayRef<TemplateArgument> PackArgs;
11267 TemplateArgument ArgStorage;
11270 if (E->isPartiallySubstituted()) {
11271 PackArgs = E->getPartialArguments();
11272 }
else if (E->isValueDependent()) {
11274 bool ShouldExpand =
false;
11275 bool RetainExpansion =
false;
11276 Optional<unsigned> NumExpansions;
11277 if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(),
11279 ShouldExpand, RetainExpansion,
11285 if (ShouldExpand) {
11286 auto *Pack = E->getPack();
11287 if (
auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Pack)) {
11288 ArgStorage = getSema().Context.getPackExpansionType(
11290 }
else if (
auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Pack)) {
11291 ArgStorage = TemplateArgument(TemplateName(TTPD), None);
11293 auto *VD = cast<ValueDecl>(Pack);
11294 ExprResult DRE = getSema().BuildDeclRefExpr(VD, VD->getType(),
11296 if (DRE.isInvalid())
11298 ArgStorage =
new (getSema().Context) PackExpansionExpr(
11299 getSema().Context.DependentTy, DRE.get(), E->getPackLoc(),
None);
11301 PackArgs = ArgStorage;
11306 if (!PackArgs.size()) {
11307 auto *Pack = cast_or_null<NamedDecl>(
11308 getDerived().TransformDecl(E->getPackLoc(), E->getPack()));
11311 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), Pack,
11317 Optional<unsigned> Result = 0;
11318 for (
const TemplateArgument &Arg : PackArgs) {
11319 if (!Arg.isPackExpansion()) {
11320 Result = *Result + 1;
11324 TemplateArgumentLoc ArgLoc;
11325 InventTemplateArgumentLoc(Arg, ArgLoc);
11328 SourceLocation Ellipsis;
11329 Optional<unsigned> OrigNumExpansions;
11330 TemplateArgumentLoc Pattern =
11331 getSema().getTemplateArgumentPackExpansionPattern(ArgLoc, Ellipsis,
11332 OrigNumExpansions);
11335 TemplateArgumentLoc OutPattern;
11336 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
11337 if (getDerived().TransformTemplateArgument(Pattern, OutPattern,
11342 Optional<unsigned> NumExpansions =
11343 getSema().getFullyPackExpandedSize(OutPattern.getArgument());
11344 if (!NumExpansions) {
11351 Result = *Result + *NumExpansions;
11357 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
11359 E->getRParenLoc(), *Result,
None);
11361 TemplateArgumentListInfo TransformedPackArgs(E->getPackLoc(),
11364 TemporaryBase Rebase(*
this, E->getPackLoc(), getBaseEntity());
11365 typedef TemplateArgumentLocInventIterator<
11366 Derived,
const TemplateArgument*> PackLocIterator;
11367 if (TransformTemplateArguments(PackLocIterator(*
this, PackArgs.begin()),
11368 PackLocIterator(*
this, PackArgs.end()),
11369 TransformedPackArgs,
true))
11375 SmallVector<TemplateArgument, 8> Args;
11376 bool PartialSubstitution =
false;
11377 for (
auto &Loc : TransformedPackArgs.arguments()) {
11378 Args.push_back(Loc.getArgument());
11379 if (Loc.getArgument().isPackExpansion())
11380 PartialSubstitution =
true;
11383 if (PartialSubstitution)
11384 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
11386 E->getRParenLoc(),
None, Args);
11388 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
11389 E->getPackLoc(), E->getRParenLoc(),
11390 Args.size(),
None);
11393 template<
typename Derived>
11395 TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr(
11396 SubstNonTypeTemplateParmPackExpr *E) {
11401 template<
typename Derived>
11403 TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr(
11404 SubstNonTypeTemplateParmExpr *E) {
11409 template<
typename Derived>
11411 TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
11416 template<
typename Derived>
11418 TreeTransform<Derived>::TransformMaterializeTemporaryExpr(
11419 MaterializeTemporaryExpr *E) {
11420 return getDerived().TransformExpr(E->GetTemporaryExpr());
11423 template<
typename Derived>
11425 TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) {
11426 Expr *Pattern = E->getPattern();
11428 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
11429 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
11430 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
11434 bool Expand =
true;
11435 bool RetainExpansion =
false;
11436 Optional<unsigned> NumExpansions;
11437 if (getDerived().TryExpandParameterPacks(E->getEllipsisLoc(),
11438 Pattern->getSourceRange(),
11440 Expand, RetainExpansion,
11447 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
11450 E->getLHS() ? getDerived().TransformExpr(E->getLHS()) :
ExprResult();
11451 if (LHS.isInvalid())
11455 E->getRHS() ? getDerived().TransformExpr(E->getRHS()) :
ExprResult();
11456 if (RHS.isInvalid())
11459 if (!getDerived().AlwaysRebuild() &&
11460 LHS.get() == E->getLHS() && RHS.get() == E->getRHS())
11463 return getDerived().RebuildCXXFoldExpr(
11464 E->getLocStart(), LHS.get(), E->getOperator(), E->getEllipsisLoc(),
11465 RHS.get(), E->getLocEnd());
11470 ExprResult Result = getDerived().TransformExpr(E->getInit());
11471 if (Result.isInvalid())
11473 bool LeftFold = E->isLeftFold();
11477 if (!LeftFold && RetainExpansion) {
11478 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
11480 ExprResult Out = getDerived().TransformExpr(Pattern);
11481 if (Out.isInvalid())
11484 Result = getDerived().RebuildCXXFoldExpr(
11485 E->getLocStart(), Out.get(), E->getOperator(), E->getEllipsisLoc(),
11486 Result.get(), E->getLocEnd());
11487 if (Result.isInvalid())
11491 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
11492 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(
11493 getSema(), LeftFold ?
I : *NumExpansions -
I - 1);
11494 ExprResult Out = getDerived().TransformExpr(Pattern);
11495 if (Out.isInvalid())
11498 if (Out.get()->containsUnexpandedParameterPack()) {
11500 Result = getDerived().RebuildCXXFoldExpr(
11502 LeftFold ? Result.get() : Out.get(),
11503 E->getOperator(), E->getEllipsisLoc(),
11504 LeftFold ? Out.get() : Result.get(),
11506 }
else if (Result.isUsable()) {
11508 Result = getDerived().RebuildBinaryOperator(
11509 E->getEllipsisLoc(), E->getOperator(),
11510 LeftFold ? Result.get() : Out.get(),
11511 LeftFold ? Out.get() : Result.get());
11515 if (Result.isInvalid())
11521 if (LeftFold && RetainExpansion) {
11522 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
11524 ExprResult Out = getDerived().TransformExpr(Pattern);
11525 if (Out.isInvalid())
11528 Result = getDerived().RebuildCXXFoldExpr(
11529 E->getLocStart(), Result.get(),
11530 E->getOperator(), E->getEllipsisLoc(),
11531 Out.get(), E->getLocEnd());
11532 if (Result.isInvalid())
11538 if (Result.isUnset())
11539 return getDerived().RebuildEmptyCXXFoldExpr(E->getEllipsisLoc(),
11545 template<
typename Derived>
11547 TreeTransform<Derived>::TransformCXXStdInitializerListExpr(
11548 CXXStdInitializerListExpr *E) {
11549 return getDerived().TransformExpr(E->getSubExpr());
11552 template<
typename Derived>
11554 TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) {
11555 return SemaRef.MaybeBindToTemporary(E);
11558 template<
typename Derived>
11560 TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
11564 template<
typename Derived>
11566 TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) {
11567 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
11568 if (SubExpr.isInvalid())
11571 if (!getDerived().AlwaysRebuild() &&
11572 SubExpr.get() == E->getSubExpr())
11575 return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get());
11578 template<
typename Derived>
11580 TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *E) {
11582 SmallVector<Expr *, 8> Elements;
11583 bool ArgChanged =
false;
11584 if (getDerived().TransformExprs(E->getElements(), E->getNumElements(),
11585 false, Elements, &ArgChanged))
11588 if (!getDerived().AlwaysRebuild() && !ArgChanged)
11589 return SemaRef.MaybeBindToTemporary(E);
11591 return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(),
11596 template<
typename Derived>
11598 TreeTransform<Derived>::TransformObjCDictionaryLiteral(
11599 ObjCDictionaryLiteral *E) {
11601 SmallVector<ObjCDictionaryElement, 8> Elements;
11602 bool ArgChanged =
false;
11603 for (
unsigned I = 0, N = E->getNumElements();
I != N; ++
I) {
11604 ObjCDictionaryElement OrigElement = E->getKeyValueElement(
I);
11606 if (OrigElement.isPackExpansion()) {
11608 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
11609 getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded);
11610 getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded);
11611 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
11615 bool Expand =
true;
11616 bool RetainExpansion =
false;
11617 Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions;
11618 Optional<unsigned> NumExpansions = OrigNumExpansions;
11619 SourceRange PatternRange(OrigElement.Key->getLocStart(),
11620 OrigElement.Value->getLocEnd());
11621 if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc,
11624 Expand, RetainExpansion,
11632 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
11633 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
11634 if (Key.isInvalid())
11637 if (Key.get() != OrigElement.Key)
11641 if (Value.isInvalid())
11644 if (Value.get() != OrigElement.Value)
11647 ObjCDictionaryElement Expansion = {
11648 Key.
get(), Value.get(), OrigElement.EllipsisLoc, NumExpansions
11650 Elements.push_back(Expansion);
11660 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
11661 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(),
I);
11662 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
11663 if (Key.isInvalid())
11666 ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
11667 if (Value.isInvalid())
11670 ObjCDictionaryElement Element = {
11671 Key.
get(), Value.get(), SourceLocation(), NumExpansions
11677 if (Key.get()->containsUnexpandedParameterPack() ||
11678 Value.get()->containsUnexpandedParameterPack())
11679 Element.EllipsisLoc = OrigElement.EllipsisLoc;
11681 Elements.push_back(Element);
11691 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
11692 if (Key.isInvalid())
11695 if (Key.get() != OrigElement.Key)
11700 = getDerived().TransformExpr(OrigElement.Value);
11701 if (Value.isInvalid())
11704 if (Value.get() != OrigElement.Value)
11707 ObjCDictionaryElement Element = {
11708 Key.
get(), Value.get(), SourceLocation(),
None
11710 Elements.push_back(Element);
11713 if (!getDerived().AlwaysRebuild() && !ArgChanged)
11714 return SemaRef.MaybeBindToTemporary(E);
11716 return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(),
11720 template<
typename Derived>
11722 TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) {
11723 TypeSourceInfo *EncodedTypeInfo
11724 = getDerived().TransformType(E->getEncodedTypeSourceInfo());
11725 if (!EncodedTypeInfo)
11728 if (!getDerived().AlwaysRebuild() &&
11729 EncodedTypeInfo == E->getEncodedTypeSourceInfo())
11732 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(),
11734 E->getRParenLoc());
11737 template<
typename Derived>
11739 TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
11744 return getDerived().TransformExpr(E->getSubExpr());
11747 template<
typename Derived>
11749 TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
11750 TypeSourceInfo *TSInfo
11751 = getDerived().TransformType(E->getTypeInfoAsWritten());
11755 ExprResult Result = getDerived().TransformExpr(E->getSubExpr());
11756 if (Result.isInvalid())
11759 if (!getDerived().AlwaysRebuild() &&
11760 TSInfo == E->getTypeInfoAsWritten() &&
11761 Result.get() == E->getSubExpr())
11764 return SemaRef.BuildObjCBridgedCast(E->getLParenLoc(), E->getBridgeKind(),
11765 E->getBridgeKeywordLoc(), TSInfo,
11769 template <
typename Derived>
11770 ExprResult TreeTransform<Derived>::TransformObjCAvailabilityCheckExpr(
11771 ObjCAvailabilityCheckExpr *E) {
11775 template<
typename Derived>
11777 TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) {
11779 bool ArgChanged =
false;
11780 SmallVector<Expr*, 8> Args;
11781 Args.reserve(E->getNumArgs());
11782 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(),
false, Args,
11788 TypeSourceInfo *ReceiverTypeInfo
11789 = getDerived().TransformType(E->getClassReceiverTypeInfo());
11790 if (!ReceiverTypeInfo)
11794 if (!getDerived().AlwaysRebuild() &&
11795 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged)
11796 return SemaRef.MaybeBindToTemporary(E);
11799 SmallVector<SourceLocation, 16> SelLocs;
11800 E->getSelectorLocs(SelLocs);
11801 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo,
11804 E->getMethodDecl(),
11811 if (!E->getMethodDecl())
11815 SmallVector<SourceLocation, 16> SelLocs;
11816 E->getSelectorLocs(SelLocs);
11817 return getDerived().RebuildObjCMessageExpr(E->getSuperLoc(),
11820 E->getReceiverType(),
11821 E->getMethodDecl(),
11829 "Only class and instance messages may be instantiated");
11831 = getDerived().TransformExpr(E->getInstanceReceiver());
11832 if (Receiver.isInvalid())
11836 if (!getDerived().AlwaysRebuild() &&
11837 Receiver.get() == E->getInstanceReceiver() && !ArgChanged)
11838 return SemaRef.MaybeBindToTemporary(E);
11841 SmallVector<SourceLocation, 16> SelLocs;
11842 E->getSelectorLocs(SelLocs);
11843 return getDerived().RebuildObjCMessageExpr(Receiver.get(),
11846 E->getMethodDecl(),
11852 template<
typename Derived>
11854 TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) {
11858 template<
typename Derived>
11860 TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) {
11864 template<
typename Derived>
11866 TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) {
11868 ExprResult Base = getDerived().TransformExpr(E->getBase());
11869 if (Base.isInvalid())
11875 if (!getDerived().AlwaysRebuild() &&
11876 Base.get() == E->getBase())
11879 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(),
11881 E->isArrow(), E->isFreeIvar());
11884 template<
typename Derived>
11886 TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
11889 if (!E->isObjectReceiver())
11893 ExprResult Base = getDerived().TransformExpr(E->getBase());
11894 if (Base.isInvalid())
11900 if (!getDerived().AlwaysRebuild() &&
11901 Base.get() == E->getBase())
11904 if (E->isExplicitProperty())
11905 return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
11906 E->getExplicitProperty(),
11909 return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
11910 SemaRef.Context.PseudoObjectTy,
11911 E->getImplicitPropertyGetter(),
11912 E->getImplicitPropertySetter(),
11916 template<
typename Derived>
11918 TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
11920 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
11921 if (Base.isInvalid())
11925 ExprResult Key = getDerived().TransformExpr(E->getKeyExpr());
11926 if (Key.isInvalid())
11930 if (!getDerived().AlwaysRebuild() &&
11931 Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr())
11934 return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(),
11935 Base.get(), Key.get(),
11936 E->getAtIndexMethodDecl(),
11937 E->setAtIndexMethodDecl());
11940 template<
typename Derived>
11942 TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) {
11944 ExprResult Base = getDerived().TransformExpr(E->getBase());
11945 if (Base.isInvalid())
11949 if (!getDerived().AlwaysRebuild() &&
11950 Base.get() == E->getBase())
11953 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(),
11958 template<
typename Derived>
11960 TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) {
11961 bool ArgumentChanged =
false;
11962 SmallVector<Expr*, 8> SubExprs;
11963 SubExprs.reserve(E->getNumSubExprs());
11964 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(),
false,
11965 SubExprs, &ArgumentChanged))
11968 if (!getDerived().AlwaysRebuild() &&
11972 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(),
11974 E->getRParenLoc());
11977 template<
typename Derived>
11979 TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *E) {
11980 ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr());
11981 if (SrcExpr.isInvalid())
11984 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
11988 if (!getDerived().AlwaysRebuild() &&
11989 Type == E->getTypeSourceInfo() &&
11990 SrcExpr.get() == E->getSrcExpr())
11993 return getDerived().RebuildConvertVectorExpr(E->getBuiltinLoc(),
11994 SrcExpr.get(), Type,
11995 E->getRParenLoc());
11998 template<
typename Derived>
12000 TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) {
12001 BlockDecl *oldBlock = E->getBlockDecl();
12003 SemaRef.ActOnBlockStart(E->getCaretLocation(),
nullptr);
12004 BlockScopeInfo *blockScope = SemaRef.getCurBlock();
12006 blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic());
12007 blockScope->TheDecl->setBlockMissingReturnType(
12008 oldBlock->blockMissingReturnType());
12010 SmallVector<ParmVarDecl*, 4> params;
12011 SmallVector<QualType, 4> paramTypes;
12013 const FunctionProtoType *exprFunctionType = E->getFunctionType();
12016 Sema::ExtParameterInfoBuilder extParamInfos;
12017 if (getDerived().TransformFunctionTypeParams(
12018 E->getCaretLocation(), oldBlock->parameters(),
nullptr,
12019 exprFunctionType->getExtParameterInfosOrNull(), paramTypes, ¶ms,
12021 getSema().ActOnBlockError(E->getCaretLocation(),
nullptr);
12025 QualType exprResultType =
12026 getDerived().TransformType(exprFunctionType->getReturnType());
12028 auto epi = exprFunctionType->getExtProtoInfo();
12029 epi.ExtParameterInfos = extParamInfos.getPointerOrNull(paramTypes.size());
12031 QualType functionType =
12032 getDerived().RebuildFunctionProtoType(exprResultType, paramTypes, epi);
12033 blockScope->FunctionType = functionType;
12036 if (!params.empty())
12037 blockScope->TheDecl->setParams(params);
12039 if (!oldBlock->blockMissingReturnType()) {
12040 blockScope->HasImplicitReturnType =
false;
12041 blockScope->ReturnType = exprResultType;
12045 StmtResult body = getDerived().TransformStmt(E->getBody());
12046 if (body.isInvalid()) {
12047 getSema().ActOnBlockError(E->getCaretLocation(),
nullptr);
12054 if (!SemaRef.getDiagnostics().hasErrorOccurred()) {
12055 for (
const auto &
I : oldBlock->captures()) {
12056 VarDecl *oldCapture =
I.getVariable();
12059 if (isa<ParmVarDecl>(oldCapture) &&
12060 cast<ParmVarDecl>(oldCapture)->isParameterPack())
12063 VarDecl *newCapture =
12064 cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(),
12066 assert(blockScope->CaptureMap.count(newCapture));
12068 assert(oldBlock->capturesCXXThis() == blockScope->isCXXThisCaptured());
12072 return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(),
12076 template<
typename Derived>
12078 TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) {
12079 llvm_unreachable(
"Cannot transform asType expressions yet");
12082 template<
typename Derived>
12084 TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) {
12085 QualType RetTy = getDerived().TransformType(E->getType());
12086 bool ArgumentChanged =
false;
12087 SmallVector<Expr*, 8> SubExprs;
12088 SubExprs.reserve(E->getNumSubExprs());
12089 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(),
false,
12090 SubExprs, &ArgumentChanged))
12093 if (!getDerived().AlwaysRebuild() &&
12097 return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs,
12098 RetTy, E->getOp(), E->getRParenLoc());
12105 template<
typename Derived>
12108 return SemaRef.BuildPointerType(PointeeType, Star,
12109 getDerived().getBaseEntity());
12112 template<
typename Derived>
12115 return SemaRef.BuildBlockPointerType(PointeeType, Star,
12116 getDerived().getBaseEntity());
12119 template<
typename Derived>
12122 bool WrittenAsLValue,
12124 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue,
12125 Sigil, getDerived().getBaseEntity());
12128 template<
typename Derived>
12133 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Sigil,
12134 getDerived().getBaseEntity());
12137 template<
typename Derived>
12144 return SemaRef.BuildObjCTypeParamType(Decl,
12145 ProtocolLAngleLoc, Protocols,
12146 ProtocolLocs, ProtocolRAngleLoc,
12150 template<
typename Derived>
12161 return SemaRef.BuildObjCObjectType(BaseType, Loc, TypeArgsLAngleLoc,
12162 TypeArgs, TypeArgsRAngleLoc,
12163 ProtocolLAngleLoc, Protocols, ProtocolLocs,
12168 template<
typename Derived>
12172 return SemaRef.Context.getObjCObjectPointerType(PointeeType);
12175 template<
typename Derived>
12179 const llvm::APInt *Size,
12181 unsigned IndexTypeQuals,
12183 if (SizeExpr || !Size)
12184 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr,
12185 IndexTypeQuals, BracketsRange,
12186 getDerived().getBaseEntity());
12189 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy,
12190 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy,
12191 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty
12193 const unsigned NumTypes = llvm::array_lengthof(Types);
12195 for (
unsigned I = 0;
I != NumTypes; ++
I)
12196 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[
I])) {
12197 SizeType = Types[
I];
12206 return SemaRef.BuildArrayType(ElementType, SizeMod, ArraySize,
12207 IndexTypeQuals, BracketsRange,
12208 getDerived().getBaseEntity());
12211 template<
typename Derived>
12215 const llvm::APInt &Size,
12216 unsigned IndexTypeQuals,
12218 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size,
nullptr,
12219 IndexTypeQuals, BracketsRange);
12222 template<
typename Derived>
12226 unsigned IndexTypeQuals,
12228 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
nullptr,
12229 IndexTypeQuals, BracketsRange);
12232 template<
typename Derived>
12237 unsigned IndexTypeQuals,
12239 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
12241 IndexTypeQuals, BracketsRange);
12244 template<
typename Derived>
12249 unsigned IndexTypeQuals,
12251 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
12253 IndexTypeQuals, BracketsRange);
12256 template<
typename Derived>
12258 unsigned NumElements,
12261 return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind);
12264 template<
typename Derived>
12266 unsigned NumElements,
12268 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
12269 NumElements,
true);
12273 return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc);
12276 template<
typename Derived>
12281 return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc);
12284 template<
typename Derived>
12289 return SemaRef.BuildFunctionType(T, ParamTypes,
12290 getDerived().getBaseLocation(),
12291 getDerived().getBaseEntity(),
12295 template<
typename Derived>
12297 return SemaRef.Context.getFunctionNoProtoType(T);
12300 template<
typename Derived>
12303 assert(D &&
"no decl found");
12308 if (
auto *UPD = dyn_cast<UsingPackDecl>(D)) {
12312 if (UPD->expansions().empty()) {
12313 getSema().Diag(Loc, diag::err_using_pack_expansion_empty)
12323 for (
auto *E : UPD->expansions()) {
12324 QualType ThisT = RebuildUnresolvedUsingType(Loc, E);
12332 assert(getSema().
Context.hasSameType(ThisT, T) &&
12333 "mismatched resolved types in using pack expansion");
12335 return T.
isNull() ? FallbackT : T;
12336 }
else if (
auto *Using = dyn_cast<UsingDecl>(D)) {
12337 assert(Using->hasTypename() &&
12338 "UnresolvedUsingTypenameDecl transformed to non-typename using");
12341 assert(++Using->shadow_begin() == Using->shadow_end());
12342 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl());
12344 assert(isa<UnresolvedUsingTypenameDecl>(D) &&
12345 "UnresolvedUsingTypenameDecl transformed to non-using decl");
12346 Ty = cast<UnresolvedUsingTypenameDecl>(D);
12349 return SemaRef.Context.getTypeDeclType(Ty);
12352 template<
typename Derived>
12355 return SemaRef.BuildTypeofExprType(E, Loc);
12358 template<
typename Derived>
12360 return SemaRef.Context.getTypeOfType(Underlying);
12363 template<
typename Derived>
12366 return SemaRef.BuildDecltypeType(E, Loc);
12369 template<
typename Derived>
12373 return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc);
12376 template<
typename Derived>
12378 TemplateName Template,
12381 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
12384 template<
typename Derived>
12387 return SemaRef.BuildAtomicType(ValueType, KWLoc);
12390 template<
typename Derived>
12394 return isReadPipe ? SemaRef.BuildReadPipeType(ValueType, KWLoc)
12395 : SemaRef.BuildWritePipeType(ValueType, KWLoc);
12398 template<
typename Derived>
12403 return SemaRef.Context.getQualifiedTemplateName(SS.
getScopeRep(), TemplateKW,
12407 template<
typename Derived>
12414 bool AllowInjectedClassName) {
12419 getSema().ActOnDependentTemplateName(
nullptr,
12420 SS, TemplateKWLoc, TemplateName,
12423 Template, AllowInjectedClassName);
12424 return Template.
get();
12427 template<
typename Derived>
12433 bool AllowInjectedClassName) {
12436 SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc };
12440 getSema().ActOnDependentTemplateName(
nullptr,
12441 SS, TemplateKWLoc, Name,
12444 Template, AllowInjectedClassName);
12445 return Template.
get();
12448 template<
typename Derived>
12456 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus);
12461 return SemaRef.checkPseudoObjectAssignment(
nullptr, OpLoc, Opc,
12463 ExprResult Result = SemaRef.CheckPlaceholderExpr(First);
12466 First = Result.
get();
12470 ExprResult Result = SemaRef.CheckPlaceholderExpr(Second);
12473 Second = Result.
get();
12477 if (Op == OO_Subscript) {
12480 return getSema().CreateBuiltinArraySubscriptExpr(First,
12483 }
else if (Op == OO_Arrow) {
12485 return SemaRef.BuildOverloadedArrowExpr(
nullptr, First, OpLoc);
12486 }
else if (Second ==
nullptr || isPostIncDec) {
12493 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First);
12502 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second);
12515 assert(ULE->requiresADL());
12516 Functions.
append(ULE->decls_begin(), ULE->decls_end());
12521 NamedDecl *ND = cast<DeclRefExpr>(Callee)->getDecl();
12522 if (!isa<CXXMethodDecl>(ND))
12527 Expr *Args[2] = { First, Second };
12528 unsigned NumArgs = 1 + (Second !=
nullptr);
12531 if (NumArgs == 1 || isPostIncDec) {
12534 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First);
12537 if (Op == OO_Subscript) {
12541 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) {
12552 return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace,
12559 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]);
12566 template<
typename Derived>
12581 ->template getAs<RecordType>())){
12583 return SemaRef.BuildPseudoDestructorExpr(
12584 Base, OperatorLoc, isArrow ? tok::arrow : tok::period, SS, ScopeType,
12585 CCLoc, TildeLoc, Destroyed);
12590 SemaRef.Context.getCanonicalType(DestroyedType->
getType())));
12599 diag::err_expected_class_or_namespace)
12600 << ScopeType->
getType() << getSema().getLangOpts().CPlusPlus;
12608 return getSema().BuildMemberReferenceExpr(Base, BaseType,
12609 OperatorLoc, isArrow,
12617 template<
typename Derived>
12625 for (
unsigned I = 0;
I < NumParams; ++
I) {
12626 if (
I != ContextParamPos) {
12632 Params.push_back(std::make_pair(StringRef(), QualType()));
12635 getSema().ActOnCapturedRegionStart(Loc,
nullptr,
12639 Sema::CompoundScopeRAII CompoundScope(getSema());
12643 if (Body.isInvalid()) {
12644 getSema().ActOnCapturedRegionError();
12648 return getSema().ActOnCapturedRegionEnd(Body.get());
12653 #endif // LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
The receiver is the instance of the superclass object.
SourceLocation getLocalEndLoc() const
Retrieve the location of the end of this component of the nested-name-specifier.
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
SourceLocation getEnd() const
const ExtParameterInfo * getExtParameterInfosOrNull() const
Return a pointer to the beginning of the array of extra parameter information, if present...
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
StmtClass getStmtClass() const
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Name lookup found a set of overloaded functions that met the criteria.
This represents 'thread_limit' clause in the '#pragma omp ...' directive.
std::pair< llvm::PointerUnion< const TemplateTypeParmType *, NamedDecl * >, SourceLocation > UnexpandedParameterPack
const TemplateArgumentLoc * operator->() const
The receiver is an object instance.
SourceLocation getElaboratedKeywordLoc() const
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
friend bool operator==(const TemplateArgumentLocInventIterator &X, const TemplateArgumentLocInventIterator &Y)
Smart pointer class that efficiently represents Objective-C method names.
TemplateArgumentLoc reference
Expr * getSourceExpression() const
This represents clause 'copyin' in the '#pragma omp ...' directives.
PointerType - C99 6.7.5.1 - Pointer Declarators.
void MakeSuper(ASTContext &Context, CXXRecordDecl *RD, SourceLocation SuperLoc, SourceLocation ColonColonLoc)
Turns this (empty) nested-name-specifier into '__super' nested-name-specifier.
Represents the dependent type named by a dependently-scoped typename using declaration, e.g.
Stores the type being destroyed by a pseudo-destructor expression.
A (possibly-)qualified type.
Keeps information about an identifier in a nested-name-spec.
bool hasExplicitTemplateArgs() const
Determines whether this expression had explicit template arguments.
SourceLocation getColonLoc() const
Get colon location.
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates)...
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
ArrayRef< OMPClause * > clauses()
Instantiation or recovery rebuild of a for-range statement.
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
OpenMPDistScheduleClauseKind getDistScheduleKind() const
Get kind of the clause.
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
static ConditionResult ConditionError()
static UnresolvedLookupExpr * Create(const ASTContext &C, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool ADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
void setRParenLoc(SourceLocation Loc)
DeclClass * getAsSingle() const
AutoTypeKeyword
Which keyword(s) were used to create an AutoType.
Stmt - This represents one statement.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
void setLAngleLoc(SourceLocation Loc)
void setExceptionSpecRange(SourceRange R)
TypeLoc getNamedTypeLoc() const
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
SourceLocation getLAngleLoc() const
reference operator*() const
ActionResult< Expr * > ExprResult
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in...
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
The template argument is an expression, and we've not resolved it to one of the other forms yet...
TemplateArgumentLoc reference
SourceLocation getLParenLoc() const
Returns the location of '('.
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
bool isRecordType() const
Decl - This represents one declaration (or definition), e.g.
This represents 'grainsize' clause in the '#pragma omp ...' directive.
TypeLoc getPatternLoc() const
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Defines the C++ template declaration subclasses.
Represents a C++11 auto or C++14 decltype(auto) type.
Represents an attribute applied to a statement.
bool isEnumeralType() const
ParenExpr - This represents a parethesized expression, e.g.
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
This represents 'priority' clause in the '#pragma omp ...' directive.
The base class of the type hierarchy.
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier.
SourceLocation getLocalRangeBegin() const
SourceLocation getLAngleLoc() const
Retrieve the location of the left angle bracket starting the explicit template argument list followin...
void setTemplateKeywordLoc(SourceLocation Loc)
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
NamespaceDecl - Represent a C++ namespace.
Represents a call to a C++ constructor.
bool hasExplicitTemplateArgs() const
Determines whether this lookup had explicit template arguments.
Wrapper for source info for typedefs.
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
SourceLocation getColonLoc() const
Returns the location of ':'.
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
const TemplateArgumentLoc * operator->() const
std::input_iterator_tag iterator_category
A container of type source information.
Wrapper for void* pointer.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
SourceLocation getColonLoc() const
Get colon location.
Represents a C++ constructor within a class.
unsigned getNumTemplateArgs() const
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
bool isSpelledAsLValue() const
Expr * getAlignment()
Returns alignment.
static int getOpenMPCaptureLevels(OpenMPDirectiveKind Kind)
Return the number of captured regions created for an OpenMP directive.
An identifier, stored as an IdentifierInfo*.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
void setRAngleLoc(SourceLocation Loc)
RAII object that enters a new expression evaluation context.
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Information about one declarator, including the parsed type information and the identifier.
void removeObjCLifetime()
Wrapper of type source information for a type with non-trivial direct qualifiers. ...
Represents an empty template argument, e.g., one that has not been deduced.
Extra information about a function prototype.
This represents 'defaultmap' clause in the '#pragma omp ...' directive.
AutoTypeKeyword getKeyword() const
ObjCMethodDecl - Represents an instance or class method declaration.
RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...
A namespace, stored as a NamespaceDecl*.
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
Stores a list of template parameters for a TemplateDecl and its derived classes.
CapturedRegionKind getCapturedRegionKind() const
Retrieve the captured region kind.
This represents implicit clause 'flush' for the '#pragma omp flush' directive.
Defines the Objective-C statement AST node classes.
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
ParmVarDecl - Represents a parameter to a function.
Represents the result of substituting a type for a template type parameter.
TemplateArgumentLocContainerIterator operator++(int)
Defines the clang::Expr interface and subclasses for C++ expressions.
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
This represents 'nogroup' clause in the '#pragma omp ...' directive.
The collection of all-type qualifiers we support.
A C++ static_cast expression (C++ [expr.static.cast]).
OpenMPDirectiveKind getDirectiveKind() const
Base wrapper for a particular "section" of type source info.
RecordDecl - Represents a struct/union/class.
DeclarationName getName() const
getName - Returns the embedded declaration name.
One of these records is kept for each identifier that is lexed.
void setLocalRangeEnd(SourceLocation L)
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
SourceLocation getLParenLoc() const
Returns the location of '('.
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
This represents '#pragma omp parallel' directive.
TypeLoc getPointeeLoc() const
A C++ nested-name-specifier augmented with source location information.
Represents a dependent template name that cannot be resolved prior to template instantiation.
The results of name lookup within a DeclContext.
This represents 'simd' clause in the '#pragma omp ...' directive.
ArrayRef< QualType > getParamTypes() const
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
TemplateArgumentLoc value_type
static SourceLocation getFromRawEncoding(unsigned Encoding)
Turn a raw encoding of a SourceLocation object into a real SourceLocation.
bool isReferenceType() const
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
SourceLocation getLocalRangeEnd() const
OpenMPLinearClauseKind
OpenMP attributes for 'linear' clause.
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
The current expression is potentially evaluated at run time, which means that code may be generated t...
UnaryExprOrTypeTrait
Names for the "expression or type" traits.
SourceLocation getRParen() const
Get the location of the right parentheses ')'.
Expr * getChunkSize()
Get chunk size.
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
This represents clause 'map' in the '#pragma omp ...' directives.
Interesting information about a specific parameter that can't simply be reflected in parameter's type...
This represents clause 'to' in the '#pragma omp ...' directives.
const DeclarationNameInfo & getNameInfo() const
Gets the full name info.
SourceLocation getLBracLoc() const
TypeSourceInfo * getTypeSourceInfo() const
SourceRange getSourceRange() const LLVM_READONLY
Fetches the full source range of the argument.
Expr * getNumTeams()
Return NumTeams number.
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword...
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
TypeSourceInfo * getNamedTypeInfo() const
getNamedTypeInfo - Returns the source type info associated to the name.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
This represents clause 'copyprivate' in the '#pragma omp ...' directives.
OpenMPDistScheduleClauseKind
OpenMP attributes for 'dist_schedule' clause.
SourceLocation getBeginLoc() const
Get the begin source location.
Describes an C or C++ initializer list.
ImplicitParamDecl * getParam(unsigned i) const
bool containsUnexpandedParameterPack() const
Whether this template argument contains an unexpanded parameter pack.
Represents a C++ unqualified-id that has been parsed.
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
Represents the results of name lookup.
IdentifierInfo * getIdentifier() const
friend bool operator!=(const TemplateArgumentLocInventIterator &X, const TemplateArgumentLocInventIterator &Y)
void setRAngleLoc(SourceLocation Loc)
< Capturing the *this object by copy
A convenient class for passing around template argument information.
unsigned location_size() const
Retrieve the size of the data associated with source-location information.
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
QualType getReturnType() const
SourceLocation getLParen() const
Get the location of the left parentheses '('.
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
NestedNameSpecifierLoc getTemplateQualifierLoc() const
char * location_data() const
Retrieve the data associated with the source-location information.
TypeDecl - Represents a declaration of a type.
The l-value was considered opaque, so the alignment was determined from a type, but that type was an ...
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding this name, if any.
bool requiresADL() const
True if this declaration should be extended by argument-dependent lookup.
TemplateArgumentLocContainerIterator & operator++()
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
std::input_iterator_tag iterator_category
NonTagKind
Common ways to introduce type names without a tag for use in diagnostics.
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
void append(iterator I, iterator E)
Represents a C++ nested-name-specifier or a global scope specifier.
TypeSourceInfo * getTypeSourceInfo() const
Represents binding an expression to a temporary.
SourceLocation getTemplateNameLoc() const
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
ArrayTypeTrait
Names for the array type traits.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
TypeSourceInfo * getTypeInfoAsWritten() const
getTypeInfoAsWritten - Returns the type source info for the type that this expression is casting to...
An ordinary object is located at an address in memory.
This represents clause 'is_device_ptr' in the '#pragma omp ...' directives.
void setLocalRangeBegin(SourceLocation L)
This represents the body of a CapturedStmt, and serves as its DeclContext.
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
Expr * getHint() const
Returns number of threads.
Member name lookup, which finds the names of class/struct/union members.
detail::InMemoryDirectory::const_iterator I
unsigned getNumParams() const
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix)
Retrieve the unary opcode that corresponds to the given overloaded operator.
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
TypedefNameDecl * getTypedefNameDecl() const
RAII object used to change the argument pack substitution index within a Sema object.
SourceRange getRange() const
This represents clause 'from' in the '#pragma omp ...' directives.
Represents the this expression in C++.
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
A helper class for building up ExtParameterInfos.
Class that aids in the construction of nested-name-specifiers along with source-location information ...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
TypeTrait
Names for traits that operate specifically on types.
unsigned getNumParams() const
Represents a K&R-style 'int foo()' function, which has no information available about its arguments...
OpenMPClauseKind getClauseKind() const
Returns kind of OpenMP clause (private, shared, reduction, etc.).
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding this name, if any.
OpenMPDependClauseKind getDependencyKind() const
Get dependency type.
SourceLocation getLocation() const
Sema - This implements semantic analysis and AST building for C.
bool isAssignmentOp() const
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
CompoundStmt - This represents a group of statements like { stmt stmt }.
Represents a prototype with parameter type info, e.g.
OMPLinearClause(SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, unsigned NumVars)
Build 'linear' clause with given number of variables NumVars.
This represents 'threads' clause in the '#pragma omp ...' directive.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
void TypeWasModifiedSafely(QualType T)
Tell the TypeLocBuilder that the type it is storing has been modified in some safe way that doesn't a...
A RAII object to enter scope of a compound statement.
llvm::iterator_range< decls_iterator > decls() const
param_type_iterator param_type_begin() const
This represents clause 'aligned' in the '#pragma omp ...' directives.
ArraySizeModifier
Capture whether this is a normal array (e.g.
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
static CXXDefaultArgExpr * Create(const ASTContext &C, SourceLocation Loc, ParmVarDecl *Param)
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
bool hasLocalQualifiers() const
Determine whether this particular QualType instance has any qualifiers, without looking through any t...
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
void setTemplateNameLoc(SourceLocation Loc)
This represents implicit clause 'depend' for the '#pragma omp task' directive.
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
SourceLocation getElaboratedKeywordLoc() const
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
pointer(TemplateArgumentLoc Arg)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
The current expression is potentially evaluated, but any declarations referenced inside that expressi...
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Expr - This represents one expression.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
SourceLocation getMapLoc() const LLVM_READONLY
Fetches location of clause mapping kind.
NestedNameSpecifierLoc getQualifierLoc() const
Fetches the nested-name qualifier with source-location information, if one was given.
SourceLocation getNameLoc() const
Gets the location of the name.
TemplateDecl * getCXXDeductionGuideTemplate() const
If this name is the name of a C++ deduction guide, return the template associated with that name...
TemplateArgumentLocInventIterator(TreeTransform< Derived > &Self, InputIterator Iter)
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
TemplateArgumentLoc operator*() const
const DeclarationNameInfo & getNameInfo() const
Retrieve the name that this expression refers to.
SourceLocation getSigilLoc() const
TemplateArgumentLocInventIterator & operator++()
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source location information.
QualType getNamedType() const
Retrieve the type named by the qualified-id.
ArgKind getKind() const
Return the kind of stored template argument.
ExtProtoInfo getExtProtoInfo() const
SourceLocation getLParenLoc() const
DeclContext * getDeclContext()
SourceLocation getLParenLoc() const
Returns the location of '('.
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
unsigned getContextParamPosition() const
Represents a C++ template name within the type system.
A namespace alias, stored as a NamespaceAliasDecl*.
SourceRange getExceptionSpecRange() const
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
SourceRange getAngleBrackets() const LLVM_READONLY
SourceLocation getTemplateNameLoc() const
QualType getType() const
Get the type for which this source info wrapper provides information.
Expr * getSubExpr() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
pointer operator->() const
static QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T)
bool isInstanceMethod() const
bool hasTrailingReturn() const
void setEllipsisLoc(SourceLocation Loc)
QualType getCXXNameType() const
getCXXNameType - If this name is one of the C++ names (of a constructor, destructor, or conversion function), return the type associated with that name.
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion, return the pattern as a template name.
A boolean condition, from 'if', 'while', 'for', or 'do'.
Expr * getSubExprAsWritten()
Retrieve the cast subexpression as it was written in the source code, looking through any implicit ca...
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
struct CXXOpName CXXOperatorName
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Expr * getDevice()
Return device number.
const FunctionProtoType::ExtParameterInfo * getPointerOrNull(unsigned numParams)
Return a pointer (suitable for setting in an ExtProtoInfo) to the ExtParameterInfo array we've built ...
SourceLocation getLParenLoc() const
Returns the location of '('.
const IdentifierInfo * getField() const
SourceLocation getCommaLoc()
Get location of ','.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
OpenMPProcBindClauseKind
OpenMP attributes for 'proc_bind' clause.
A type, stored as a Type*.
TypeSourceInfo * getTypeSourceInfo() const
SourceLocation getRAngleLoc() const
const LambdaCapture * capture_iterator
An iterator that walks over the captures of the lambda, both implicit and explicit.
const TypeClass * getTypePtr() const
static SEHFinallyStmt * Create(const ASTContext &C, SourceLocation FinallyLoc, Stmt *Block)
bool hasObjCLifetime() const
TemplateArgumentLocInventIterator operator++(int)
SourceLocation getLocStart() const
Returns starting location of directive kind.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
unsigned getNumTemplateArgs() const
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
Simple iterator that traverses the template arguments in a container that provides a getArgLoc() memb...
const IdentifierInfo * getIdentifier() const
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)
Retrieve the binary opcode that corresponds to the given overloaded operator.
friend bool operator==(const TemplateArgumentLocContainerIterator &X, const TemplateArgumentLocContainerIterator &Y)
This represents 'num_teams' clause in the '#pragma omp ...' directive.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Tag name lookup, which finds the names of enums, classes, structs, and unions.
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
This captures a statement into a function.
A field in a dependent type, known only by its name.
TypeLoc getValueLoc() const
Represents a call to an inherited base class constructor from an inheriting constructor.
ExceptionSpecificationType Type
The kind of exception specification this is.
SourceLocation getLParenLoc()
Get location of '('.
void setLAngleLoc(SourceLocation Loc)
TemplateArgumentLocInventIterator()
friend bool operator!=(const TemplateArgumentLocContainerIterator &X, const TemplateArgumentLocContainerIterator &Y)
const ExtParameterInfo * ExtParameterInfos
Encodes a location in the source.
This represents 'hint' clause in the '#pragma omp ...' directive.
TemplateArgumentLoc const * getTemplateArgs() const
OpenMPDependClauseKind
OpenMP attributes for 'depend' clause.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
SourceLocation getLParenLoc() const
Returns the location of '('.
SourceLocation getEndLoc() const
Retrieve the location of the end of this nested-name-specifier.
This is a basic class for representing single OpenMP executable directive.
A structure for storing an already-substituted template template parameter pack.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLParenLoc() const
TagDecl - Represents the declaration of a struct/union/class/enum.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
static SizeOfPackExpr * Create(ASTContext &Context, SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, Optional< unsigned > Length=None, ArrayRef< TemplateArgument > PartialArgs=None)
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
OpenMPDirectiveKind
OpenMP directives.
LabelDecl - Represents the declaration of a label.
SourceLocation getLocalBeginLoc() const
Retrieve the location of the beginning of this component of the nested-name-specifier.
Expr * getPriority()
Return Priority number.
OpenMPLinearClauseKind Modifier
Modifier of 'linear' clause.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
C-style initialization with assignment.
OpenMPMapClauseKind getMapType() const LLVM_READONLY
Fetches mapping kind for the clause.
Name lookup found an unresolvable value declaration and cannot yet complete.
void reserve(size_t Requested)
Ensures that this buffer has at least as much capacity as described.
This is a basic class for representing single OpenMP clause.
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the similarly-named C++11 instructions, and __c11 variants for <stdatomic.h>.
void addDecl(NamedDecl *D)
SourceLocation getRParenLoc() const
SourceLocation getOperatorLoc() const
Retrieve the location of the cast operator keyword, e.g., static_cast.
static CXXDefaultInitExpr * Create(const ASTContext &C, SourceLocation Loc, FieldDecl *Field)
Field is the non-static data member whose default initializer is used by this expression.
Represents one property declaration in an Objective-C interface.
void setElaboratedKeywordLoc(SourceLocation Loc)
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Stmt * getCapturedStmt()
Retrieve the statement being captured.
TypeLocClass getTypeLocClass() const
OpenMPMapClauseKind getMapTypeModifier() const LLVM_READONLY
Fetches the map type modifier for the clause.
SourceLocation getLParenLoc() const
Returns the location of '('.
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
SourceLocation getBegin() const
const T * castAs() const
Member-template castAs<specific type>.
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
TypeLoc getReturnLoc() const
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
No entity found met the criteria.
SourceLocation getDependencyLoc() const
Get dependency type location.
The name is a dependent name, so the results will differ from one instantiation to the next...
SourceLocation getKWLoc() const
void set(unsigned index, FunctionProtoType::ExtParameterInfo info)
Set the ExtParameterInfo for the parameter at the given index,.
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)
Converts an elaborated type keyword into a TagTypeKind.
Expr * getGrainsize() const
Return safe iteration space distance.
void setLAngleLoc(SourceLocation Loc)
MutableArrayRef< Expr * > MultiExprArg
QualType getType() const
Return the type wrapped by this type source info.
void addArgument(const TemplateArgumentLoc &Loc)
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type...
QualType getPointeeType() const
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
A qualified reference to a name whose declaration cannot yet be resolved.
Represents a pack expansion of types.
DeclarationNameLoc - Additional source/type location info for a declaration name. ...
void setLParenLoc(SourceLocation Loc)
void setTemplateKeywordLoc(SourceLocation Loc)
DeclarationName getDeclName() const
Retrieve the name that this expression refers to.
attr::Kind getKind() const
Base class for declarations which introduce a typedef-name.
Represents a template argument.
QualType getAsType() const
Retrieve the type for a type template argument.
Represents a template name that was expressed as a qualified name.
TagTypeKind
The kind of a tag type.
OpenMPScheduleClauseModifier
OpenMP modifiers for 'schedule' clause.
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
This represents 'device' clause in the '#pragma omp ...' directive.
not evaluated yet, for special member function
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
The base class of all kinds of template declarations (e.g., class, function, etc.).
SourceLocation ModifierLoc
Location of linear modifier if any.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
TemplateArgumentLoc const * getTemplateArgs() const
SourceLocation getEllipsisLoc() const
The template argument is a pack expansion of a template name that was provided for a template templat...
bool isInvalidDecl() const
bool isDefaultArgument() const
Determine whether this expression is a default function argument.
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
A constant boolean condition from 'if constexpr'.
TemplateArgumentLocContainerIterator(ArgLocContainer &Container, unsigned Index)
SourceLocation getTemplateKeywordLoc() const
DeclarationName - The name of a declaration.
Represents the declaration of an Objective-C type parameter.
Expr * getNumTasks() const
Return safe iteration space distance.
Represents a C++11 pack expansion that produces a sequence of expressions.
A set of unresolved declarations.
pointer operator->() const
bool isNull() const
Determine whether this template argument has no value.
EnumDecl - Represents an enum.
unsigned getFunctionScopeDepth() const
detail::InMemoryDirectory::const_iterator E
void setSigilLoc(SourceLocation Loc)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
TemplateArgumentLoc value_type
A type that was preceded by the 'template' keyword, stored as a Type*.
void * getOpaqueData() const
Retrieve the opaque pointer that refers to source-location data.
bool isImplicitMapType() const LLVM_READONLY
Is this an implicit map type? We have to capture 'IsMapTypeImplicit' from the parser for more informa...
CXXRecordDecl * getNamingClass() const
Gets the 'naming class' (in the sense of C++0x [class.access.base]p5) of the lookup.
Represents a __leave statement.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Name lookup found a single declaration that met the criteria.
Not an overloaded operator.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Location wrapper for a TemplateArgument.
const T * getAs() const
Member-template getAs<specific type>'.
This file defines OpenMP AST classes for executable directives and clauses.
An implicit indirection through a C++ base class, when the field found is in a base class...
unsigned getNumArgs() const
UnqualTypeLoc getUnqualifiedLoc() const
bool isNull() const
Determine whether this template name is NULL.
std::iterator_traits< InputIterator >::difference_type difference_type
bool isFunctionType() const
void setOperatorFunctionId(SourceLocation OperatorLoc, OverloadedOperatorKind Op, SourceLocation SymbolLocations[3])
Specify that this unqualified-id was parsed as an operator-function-id.
OpenMPScheduleClauseKind
OpenMP attributes for 'schedule' clause.
Base for LValueReferenceType and RValueReferenceType.
ActionResult< Stmt * > StmtResult
SourceLocation getLAngleLoc() const
Retrieve the location of the left angle bracket starting the explicit template argument list followin...
The template argument is a type.
SourceLocation getLocStart() const LLVM_READONLY
OpenMPDefaultClauseKind
OpenMP attributes for 'default' clause.
SourceLocation getDistScheduleKindLoc()
Get kind location.
const TypeClass * getTypePtr() const
The template argument is actually a parameter pack.
void setNamedTypeInfo(TypeSourceInfo *TInfo)
setNamedTypeInfo - Sets the source type info associated to the name.
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
bool hasAssociatedStmt() const
Returns true if directive has associated statement.
ArrayRef< const Attr * > getAttrs() const
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
SourceLocation getAttrLoc() const
Expr * NoexceptExpr
Noexcept expression, if this is EST_ComputedNoexcept.
An integral condition for a 'switch' statement.
CapturedDecl * getCapturedDecl()
Retrieve the outlined function declaration.
pointer(TemplateArgumentLoc Arg)
unsigned getFullDataSize() const
Returns the size of the type source info data block.
Call-style initialization (C++98)
void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL, SourceLocation ColonColonLoc)
Extend the current nested-name-specifier by another nested-name-specifier component of the form 'type...
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
SourceLocation getRParenLoc() const
Retrieve the location of the closing parenthesis.
Represents a C++ struct/union/class.
BoundNodesTreeBuilder *const Builder
Represents a template specialization type whose template cannot be resolved, e.g. ...
This represents 'num_tasks' clause in the '#pragma omp ...' directive.
bool isObjCObjectPointerType() const
The template argument is a template name that was provided for a template template parameter...
CXXCatchStmt - This represents a C++ catch block.
SourceLocation getTemplateNameLoc() const
OpenMPMapClauseKind
OpenMP mapping kind for 'map' clause.
ObjCIvarDecl - Represents an ObjC instance variable.
void setParam(unsigned i, ParmVarDecl *VD)
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
ElaboratedTypeKeyword getKeyword() const
SourceLocation getRParenLoc() const
bool isOverloadableType() const
Determines whether this is a type for which one can define an overloaded operator.
Location information for a TemplateArgument.
Expr * getThreadLimit()
Return ThreadLimit number.
void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc)
Turn this (empty) nested-name-specifier into the global nested-name-specifier '::'.
pack_iterator pack_end() const
Iterator referencing one past the last argument of a template argument pack.
LookupResultKind getResultKind() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
DeclarationName getName() const
Gets the name looked up.
ArrayRef< ParmVarDecl * > getParams() const
void setRAngleLoc(SourceLocation Loc)
This represents 'dist_schedule' clause in the '#pragma omp ...' directive.
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it's either not been deduced or was deduce...
QualType getPointeeTypeAsWritten() const
SourceLocation getRBracLoc() const
Abstract class common to all of the C++ "named"/"keyword" casts.
Designation - Represent a full designation, which is a sequence of designators.
static OpaquePtr make(QualTypeP)
TranslationUnitDecl - The top declaration context.
A reference to a declared variable, function, enum, etc.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
SourceLocation getLParenLoc() const
Returns the location of '('.
Represents a type template specialization; the template must be a class template, a type alias templa...
Iterator adaptor that invents template argument location information for each of the template argumen...
SourceLocation getInnerLocStart() const
getInnerLocStart - Return SourceLocation representing start of source range ignoring outer template d...
An l-value expression is a reference to an object with independent storage.
static Designator getArray(Expr *Index, SourceLocation LBracketLoc)
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
UnqualTypeLoc getUnqualifiedLoc() const
Skips past any qualifiers, if this is qualified.
NamedDecl - This represents a decl with a name.
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Specify that this unqualified-id was parsed as an identifier.
NestedNameSpecifierLoc getQualifierLoc() const
Represents a C++ namespace alias.
void setTemplateNameLoc(SourceLocation Loc)
No keyword precedes the qualified type name.
SourceLocation getLocEnd() const
Returns ending location of directive.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
static Designator getArrayRange(Expr *Start, Expr *End, SourceLocation LBracketLoc, SourceLocation EllipsisLoc)
The receiver is a superclass.
Stmt * getAssociatedStmt() const
Returns statement associated with the directive.
The global specifier '::'. There is no stored value.
SourceLocation getLocStart() const LLVM_READONLY
const TemplateArgument & getArgument() const
TranslationUnitDecl * getTranslationUnitDecl()
SourceLocation ColonLoc
Location of ':'.
Optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
ExceptionSpecInfo ExceptionSpec
TemplateArgumentLocContainerIterator()
The symbol does not exist.
void clear()
Clears out any current state.
Represents an implicitly-generated value initialization of an object of a given type.
void setElaboratedKeywordLoc(SourceLocation Loc)
Attr - This represents one attribute.
This represents clause 'use_device_ptr' in the '#pragma omp ...' directives.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
bool isPointerType() const