14 #ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
15 #define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
36 #include "llvm/ADT/ArrayRef.h"
37 #include "llvm/Support/ErrorHandling.h"
94 template<
typename Derived>
99 class ForgetPartiallySubstitutedPackRAII {
104 ForgetPartiallySubstitutedPackRAII(Derived &Self) : Self(Self) {
105 Old = Self.ForgetPartiallySubstitutedPack();
108 ~ForgetPartiallySubstitutedPackRAII() {
109 Self.RememberPartiallySubstitutedPack(Old);
126 Derived &
getDerived() {
return static_cast<Derived&
>(*this); }
130 return static_cast<const Derived&
>(*this);
149 bool AlwaysRebuild() {
return SemaRef.ArgumentPackSubstitutionIndex != -1; }
183 OldLocation = Self.
getDerived().getBaseLocation();
184 OldEntity = Self.
getDerived().getBaseEntity();
191 Self.getDerived().setBase(OldLocation, OldEntity);
257 bool &RetainExpansion,
259 ShouldExpand =
false;
339 const Attr *TransformAttr(
const Attr *
S);
348 #define PRAGMA_SPELLING_ATTR(X) \
349 const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; }
350 #include "clang/Basic/AttrList.inc"
369 ExprResult TransformInitializer(Expr *Init,
bool NotCopyInit);
394 bool TransformExprs(Expr *
const *Inputs,
unsigned NumInputs,
bool IsCall,
395 SmallVectorImpl<Expr *> &Outputs,
396 bool *ArgChanged =
nullptr);
406 = TransformedLocalDecls.find(D);
407 if (Known != TransformedLocalDecls.end())
408 return Known->second;
436 TransformedLocalDecls[Old] = New;
444 return getDerived().TransformDecl(Loc, D);
457 return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D));
469 NamedDecl *FirstQualifierInScope =
nullptr);
504 NamedDecl *FirstQualifierInScope =
nullptr);
516 bool Uneval =
false);
539 bool Uneval =
false) {
540 return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs,
558 template<
typename InputIterator>
559 bool TransformTemplateArguments(InputIterator First,
562 bool Uneval =
false);
570 return SemaRef.Context.getTrivialTypeSourceInfo(T,
571 getDerived().getBaseLocation());
574 #define ABSTRACT_TYPELOC(CLASS, PARENT)
575 #define TYPELOC(CLASS, PARENT) \
576 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
577 #include "clang/AST/TypeLocNodes.def"
579 template<
typename Fn>
580 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
581 FunctionProtoTypeLoc TL,
582 CXXRecordDecl *ThisContext,
583 unsigned ThisTypeQuals,
584 Fn TransformExceptionSpec);
586 bool TransformExceptionSpec(SourceLocation Loc,
587 FunctionProtoType::ExceptionSpecInfo &ESI,
588 SmallVectorImpl<QualType> &Exceptions,
594 TransformTemplateSpecializationType(TypeLocBuilder &TLB,
595 TemplateSpecializationTypeLoc TL,
596 TemplateName Template);
599 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
600 DependentTemplateSpecializationTypeLoc TL,
601 TemplateName Template,
604 QualType TransformDependentTemplateSpecializationType(
605 TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
606 NestedNameSpecifierLoc QualifierLoc);
615 bool TransformFunctionTypeParams(
616 SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
617 const QualType *ParamTypes,
618 const FunctionProtoType::ExtParameterInfo *ParamInfos,
619 SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars,
620 Sema::ExtParameterInfoBuilder &PInfos);
627 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
629 Optional<unsigned> NumExpansions,
630 bool ExpectParameterPack);
632 QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);
634 StmtResult TransformCompoundStmt(CompoundStmt *
S,
bool IsStmtExpr);
635 ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *
E);
645 bool IsAddressOfOperand,
648 ExprResult TransformParenDependentScopeDeclRefExpr(
656 #define STMT(Node, Parent) \
657 LLVM_ATTRIBUTE_NOINLINE \
658 StmtResult Transform##Node(Node *S);
659 #define EXPR(Node, Parent) \
660 LLVM_ATTRIBUTE_NOINLINE \
661 ExprResult Transform##Node(Node *E);
662 #define ABSTRACT_STMT(Stmt)
663 #include "clang/AST/StmtNodes.inc"
665 #define OPENMP_CLAUSE(Name, Class) \
666 LLVM_ATTRIBUTE_NOINLINE \
667 OMPClause *Transform ## Class(Class *S);
668 #include "clang/Basic/OpenMPKinds.def"
674 QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);
680 QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);
690 QualType RebuildReferenceType(QualType ReferentType,
692 SourceLocation Sigil);
699 QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
700 SourceLocation Sigil);
706 QualType RebuildObjCObjectType(QualType BaseType,
708 SourceLocation TypeArgsLAngleLoc,
709 ArrayRef<TypeSourceInfo *> TypeArgs,
710 SourceLocation TypeArgsRAngleLoc,
711 SourceLocation ProtocolLAngleLoc,
712 ArrayRef<ObjCProtocolDecl *> Protocols,
713 ArrayRef<SourceLocation> ProtocolLocs,
714 SourceLocation ProtocolRAngleLoc);
720 QualType RebuildObjCObjectPointerType(QualType PointeeType,
721 SourceLocation Star);
730 QualType RebuildArrayType(QualType ElementType,
732 const llvm::APInt *Size,
734 unsigned IndexTypeQuals,
735 SourceRange BracketsRange);
742 QualType RebuildConstantArrayType(QualType ElementType,
744 const llvm::APInt &Size,
745 unsigned IndexTypeQuals,
746 SourceRange BracketsRange);
753 QualType RebuildIncompleteArrayType(QualType ElementType,
755 unsigned IndexTypeQuals,
756 SourceRange BracketsRange);
763 QualType RebuildVariableArrayType(QualType ElementType,
766 unsigned IndexTypeQuals,
767 SourceRange BracketsRange);
774 QualType RebuildDependentSizedArrayType(QualType ElementType,
777 unsigned IndexTypeQuals,
778 SourceRange BracketsRange);
785 QualType RebuildVectorType(QualType ElementType,
unsigned NumElements,
793 QualType RebuildExtVectorType(QualType ElementType,
unsigned NumElements,
794 SourceLocation AttributeLoc);
801 QualType RebuildDependentSizedExtVectorType(QualType ElementType,
803 SourceLocation AttributeLoc);
809 QualType RebuildFunctionProtoType(QualType T,
810 MutableArrayRef<QualType> ParamTypes,
811 const FunctionProtoType::ExtProtoInfo &EPI);
814 QualType RebuildFunctionNoProtoType(QualType ResultType);
818 QualType RebuildUnresolvedUsingType(
Decl *D);
822 return SemaRef.Context.getTypeDeclType(Typedef);
827 return SemaRef.Context.getTypeDeclType(Record);
832 return SemaRef.Context.getTypeDeclType(Enum);
864 return SemaRef.Context.getAutoType(Deduced, Keyword,
882 return SemaRef.Context.getParenType(InnerType);
894 return SemaRef.Context.getElaboratedType(Keyword,
913 SS.
Adopt(QualifierLoc);
915 = getDerived().RebuildTemplateName(SS, *Name, NameLoc,
QualType(),
923 return SemaRef.Context.getDependentTemplateSpecializationType(Keyword,
931 getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
937 return SemaRef.Context.getElaboratedType(Keyword,
953 SS.
Adopt(QualifierLoc);
957 if (!SemaRef.computeDeclContext(SS))
958 return SemaRef.Context.getDependentNameType(Keyword,
964 return SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc,
973 DeclContext *DC = SemaRef.computeDeclContext(SS,
false);
977 if (SemaRef.RequireCompleteDeclContext(SS, DC))
981 SemaRef.LookupQualifiedName(Result, DC);
993 llvm_unreachable(
"Tag lookup cannot find non-tags");
1004 SemaRef.LookupQualifiedName(Result, DC);
1011 if (isa<TypedefDecl>(SomeDecl)) Kind = 1;
1012 else if (isa<TypeAliasDecl>(SomeDecl)) Kind = 2;
1013 else if (isa<ClassTemplateDecl>(SomeDecl)) Kind = 3;
1014 SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) <<
Kind;
1015 SemaRef.Diag(SomeDecl->getLocation(), diag::note_declared_at);
1019 SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope)
1026 if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind,
false,
1028 SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id;
1029 SemaRef.Diag(Tag->getLocation(), diag::note_previous_use);
1034 QualType T = SemaRef.Context.getTypeDeclType(Tag);
1035 return SemaRef.Context.getElaboratedType(Keyword,
1048 return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc,
1105 return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
1116 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements,
1129 return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS,
1138 getSema().ActOnCaseStmtBody(S, Body);
1149 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt,
1159 return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt);
1169 return SemaRef.ActOnAttributedStmt(AttrLoc, Attrs, SubStmt);
1179 return getSema().ActOnIfStmt(IfLoc, IsConstexpr, Init, Cond, Then,
1189 return getSema().ActOnStartOfSwitchStmt(SwitchLoc, Init, Cond);
1198 return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body);
1207 return getSema().ActOnWhileStmt(WhileLoc, Cond, Body);
1217 return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
1229 return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
1230 Inc, RParenLoc, Body);
1239 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label);
1249 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target);
1257 return getSema().BuildReturnStmt(ReturnLoc, Result);
1267 return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc);
1275 bool IsVolatile,
unsigned NumOutputs,
1280 return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
1281 NumInputs, Names, Constraints, Exprs,
1282 AsmString, Clobbers, RParenLoc);
1291 StringRef AsmString,
1292 unsigned NumOutputs,
unsigned NumInputs,
1297 return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString,
1298 NumOutputs, NumInputs,
1299 Constraints, Clobbers, Exprs, EndLoc);
1307 return getSema().BuildCoreturnStmt(CoreturnLoc, Result);
1315 return getSema().BuildCoawaitExpr(CoawaitLoc, Result);
1323 return getSema().BuildCoyieldExpr(CoyieldLoc, Result);
1334 return getSema().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts,
1344 return getSema().BuildObjCExceptionDecl(TInfo, T,
1346 ExceptionDecl->getLocation(),
1358 return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
1368 return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body);
1377 return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
1390 return getSema().ActOnOpenMPExecutableDirective(
1391 Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
1404 return getSema().ActOnOpenMPIfClause(NameModifier, Condition, StartLoc,
1405 LParenLoc, NameModifierLoc, ColonLoc,
1416 return getSema().ActOnOpenMPFinalClause(Condition, StartLoc, LParenLoc,
1428 return getSema().ActOnOpenMPNumThreadsClause(NumThreads, StartLoc,
1439 return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc);
1449 return getSema().ActOnOpenMPSimdlenClause(Len, StartLoc, LParenLoc, EndLoc);
1459 return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc,
1472 return getSema().ActOnOpenMPDefaultClause(Kind, KindKwLoc,
1473 StartLoc, LParenLoc, EndLoc);
1485 return getSema().ActOnOpenMPProcBindClause(Kind, KindKwLoc,
1486 StartLoc, LParenLoc, EndLoc);
1498 return getSema().ActOnOpenMPScheduleClause(
1499 M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
1510 return getSema().ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Num);
1521 return getSema().ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc,
1533 return getSema().ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc,
1545 return getSema().ActOnOpenMPLastprivateClause(VarList, StartLoc, LParenLoc,
1557 return getSema().ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc,
1573 return getSema().ActOnOpenMPReductionClause(
1574 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1575 ReductionId, UnresolvedReductions);
1589 return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc,
1590 Modifier, ModifierLoc, ColonLoc,
1603 return getSema().ActOnOpenMPAlignedClause(VarList, Alignment, StartLoc,
1604 LParenLoc, ColonLoc, EndLoc);
1615 return getSema().ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc,
1627 return getSema().ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc,
1639 return getSema().ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc,
1652 return getSema().ActOnOpenMPDependClause(DepKind, DepLoc, ColonLoc, VarList,
1653 StartLoc, LParenLoc, EndLoc);
1663 return getSema().ActOnOpenMPDeviceClause(Device, StartLoc, LParenLoc,
1677 return getSema().ActOnOpenMPMapClause(MapTypeModifier, MapType,
1678 IsMapTypeImplicit, MapLoc, ColonLoc,
1679 VarList, StartLoc, LParenLoc, EndLoc);
1689 return getSema().ActOnOpenMPNumTeamsClause(NumTeams, StartLoc, LParenLoc,
1701 return getSema().ActOnOpenMPThreadLimitClause(ThreadLimit, StartLoc,
1712 return getSema().ActOnOpenMPPriorityClause(Priority, StartLoc, LParenLoc,
1723 return getSema().ActOnOpenMPGrainsizeClause(Grainsize, StartLoc, LParenLoc,
1734 return getSema().ActOnOpenMPNumTasksClause(NumTasks, StartLoc, LParenLoc,
1745 return getSema().ActOnOpenMPHintClause(Hint, StartLoc, LParenLoc, EndLoc);
1757 return getSema().ActOnOpenMPDistScheduleClause(
1758 Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
1769 return getSema().ActOnOpenMPToClause(VarList, StartLoc, LParenLoc, EndLoc);
1780 return getSema().ActOnOpenMPFromClause(VarList, StartLoc, LParenLoc,
1792 return getSema().ActOnOpenMPUseDevicePtrClause(VarList, StartLoc, LParenLoc,
1804 return getSema().ActOnOpenMPIsDevicePtrClause(VarList, StartLoc, LParenLoc,
1814 return getSema().ActOnObjCAtSynchronizedOperand(atLoc,
object);
1823 return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body);
1832 return getSema().ActOnObjCAutoreleasePoolStmt(AtLoc, Body);
1844 StmtResult ForEachStmt = getSema().ActOnObjCForCollectionStmt(ForLoc,
1851 return getSema().FinishObjCForCollectionStmt(ForEachStmt.
get(), Body);
1863 VarDecl *Var = getSema().BuildExceptionDeclaration(
nullptr, Declarator,
1864 StartLoc, IdLoc, Id);
1866 getSema().CurContext->addDecl(Var);
1887 return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers);
1903 if (
DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) {
1904 if (RangeStmt->isSingleDecl()) {
1905 if (
VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
1906 if (RangeVar->isInvalidDecl())
1909 Expr *RangeExpr = RangeVar->getInit();
1912 return getSema().ActOnObjCForCollectionStmt(ForLoc, LoopVar, RangeExpr,
1918 return getSema().BuildCXXForRangeStmt(ForLoc, CoawaitLoc, ColonLoc,
1920 Cond, Inc, LoopVar, RParenLoc,
1933 return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
1934 QualifierLoc, NameInfo, Nested);
1942 return getSema().FinishCXXForRangeStmt(ForRange, Body);
1947 return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler);
1952 return getSema().ActOnSEHExceptBlock(Loc, FilterExpr, Block);
1965 return getSema().BuildPredefinedExpr(Loc, IT);
1975 return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
1988 SS.
Adopt(QualifierLoc);
1992 return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD);
2001 return getSema().ActOnParenExpr(LParen, RParen, SubExpr);
2024 return getSema().BuildUnaryOp(
nullptr, OpLoc, Opc, SubExpr);
2035 return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
2048 return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R);
2060 = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind);
2075 return getSema().ActOnArraySubscriptExpr(
nullptr, LHS,
2088 return getSema().ActOnOMPArraySectionExpr(Base, LBracketLoc, LowerBound,
2089 ColonLoc, Length, RBracketLoc);
2099 Expr *ExecConfig =
nullptr) {
2100 return getSema().ActOnCallExpr(
nullptr, Callee, LParenLoc,
2101 Args, RParenLoc, ExecConfig);
2123 assert(!QualifierLoc &&
"Can't have an unnamed field with a qualifier!");
2125 "unnamed member not of record type?");
2128 getSema().PerformObjectMemberConversion(BaseResult.get(),
2131 if (BaseResult.isInvalid())
2133 Base = BaseResult.get();
2136 MemberExpr(Base, isArrow, OpLoc, Member, MemberNameInfo,
2137 cast<FieldDecl>(Member)->getType(), VK,
OK_Ordinary);
2142 SS.
Adopt(QualifierLoc);
2144 Base = BaseResult.
get();
2153 return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow,
2155 FirstQualifierInScope,
2156 R, ExplicitTemplateArgs,
2167 return getSema().BuildBinOp(
nullptr, OpLoc, Opc, LHS, RHS);
2179 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond,
2191 return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
2203 return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
2218 return getSema().BuildMemberReferenceExpr(Base, Base->
getType(),
2236 = SemaRef.ActOnInitList(LBraceLoc, Inits, RBraceLoc);
2257 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
2281 return getSema().BuildVAArgExpr(BuiltinLoc,
2293 return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs);
2303 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label);
2313 return getSema().ActOnStmtExpr(LParenLoc, SubStmt, RParenLoc);
2323 return SemaRef.ActOnChooseExpr(BuiltinLoc,
2335 Expr *ControllingExpr,
2338 return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
2339 ControllingExpr, Types, Exprs);
2363 Stmt::StmtClass Class,
2371 case Stmt::CXXStaticCastExprClass:
2372 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
2373 RAngleLoc, LParenLoc,
2374 SubExpr, RParenLoc);
2376 case Stmt::CXXDynamicCastExprClass:
2377 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
2378 RAngleLoc, LParenLoc,
2379 SubExpr, RParenLoc);
2381 case Stmt::CXXReinterpretCastExprClass:
2382 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
2383 RAngleLoc, LParenLoc,
2387 case Stmt::CXXConstCastExprClass:
2388 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
2389 RAngleLoc, LParenLoc,
2390 SubExpr, RParenLoc);
2393 llvm_unreachable(
"Invalid C++ named cast");
2408 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
2425 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
2442 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
2459 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
2473 return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc,
2486 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2499 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2511 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
2523 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
2535 getSema().CheckCXXThisCapture(ThisLoc);
2536 return new (getSema().Context)
CXXThisExpr(ThisLoc, ThisType, isImplicit);
2544 bool IsThrownVariableInScope) {
2545 return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope);
2575 return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc,
2593 Expr *Initializer) {
2594 return getSema().BuildCXXNew(StartLoc, UseGlobal,
2611 bool IsGlobalDelete,
2614 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
2626 return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc);
2638 return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc);
2649 return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc);
2662 bool IsAddressOfOperand,
2665 SS.
Adopt(QualifierLoc);
2667 if (TemplateArgs || TemplateKWLoc.
isValid())
2668 return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc, NameInfo,
2671 return getSema().BuildQualifiedDeclarationNameExpr(
2672 SS, NameInfo, IsAddressOfOperand,
nullptr, RecoveryTSI);
2684 return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL,
2697 bool HadMultipleCandidates,
2698 bool ListInitialization,
2699 bool StdInitListInitialization,
2700 bool RequiresZeroInit,
2704 if (getSema().CompleteConstructorCall(Constructor, Args, Loc,
2708 return getSema().BuildCXXConstructExpr(Loc, T, Constructor,
2711 HadMultipleCandidates,
2713 StdInitListInitialization,
2714 RequiresZeroInit, ConstructKind,
2722 bool ConstructsVBase,
2723 bool InheritedFromVBase) {
2725 Loc, T, Constructor, ConstructsVBase, InheritedFromVBase);
2736 return getSema().BuildCXXTypeConstructExpr(TSInfo,
2750 return getSema().BuildCXXTypeConstructExpr(TSInfo,
2770 SS.
Adopt(QualifierLoc);
2772 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
2773 OperatorLoc, IsArrow,
2775 FirstQualifierInScope,
2777 TemplateArgs,
nullptr);
2793 SS.
Adopt(QualifierLoc);
2795 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
2796 OperatorLoc, IsArrow,
2798 FirstQualifierInScope,
2799 R, TemplateArgs,
nullptr);
2807 return SemaRef.BuildCXXNoexceptExpr(Range.
getBegin(), Arg, Range.
getEnd());
2818 RParenLoc, Length, PartialArgs);
2826 return getSema().BuildObjCBoxedExpr(SR, ValueExpr);
2834 Expr **Elements,
unsigned NumElements) {
2835 return getSema().BuildObjCArrayLiteral(Range,
2843 return getSema().BuildObjCSubscriptExpression(RB, Base, Key,
2844 getterMethod, setterMethod);
2853 return getSema().BuildObjCDictionaryLiteral(Range, Elements);
2863 return SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo, RParenLoc);
2874 return SemaRef.BuildClassMessage(ReceiverTypeInfo,
2877 Sel, Method, LBracLoc, SelectorLocs,
2889 return SemaRef.BuildInstanceMessage(Receiver,
2892 Sel, Method, LBracLoc, SelectorLocs,
2908 Sel, Method, LBracLoc, SelectorLocs,
2910 : SemaRef.BuildClassMessage(
nullptr,
2913 Sel, Method, LBracLoc, SelectorLocs,
2925 bool IsArrow,
bool IsFreeIvar) {
2929 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->
getType(),
2947 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->
getType(),
2970 PropertyLoc, Base));
2981 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->
getType(),
2999 = SemaRef.Context.Idents.get(
"__builtin_shufflevector");
3002 assert(!Lookup.
empty() &&
"No __builtin_shufflevector?");
3007 SemaRef.Context.BuiltinFnTy,
3009 QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType());
3010 Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy,
3011 CK_BuiltinFnToFnPtr).get();
3015 SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(),
3019 return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.
get()));
3026 return SemaRef.SemaConvertVectorExpr(SrcExpr, DstTInfo,
3027 BuiltinLoc, RParenLoc);
3042 EllipsisLoc, NumExpansions);
3063 llvm_unreachable(
"Pack expansion pattern has no parameter packs");
3085 return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions);
3096 return getSema().BuildCXXFoldExpr(LParenLoc, LHS, Operator, EllipsisLoc,
3106 return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator);
3121 return new (SemaRef.Context)
AtomicExpr(BuiltinLoc, SubExprs, RetTy, Op,
3141 template<
typename Derived>
3146 switch (S->getStmtClass()) {
3147 case Stmt::NoStmtClass:
break;
3150 #define STMT(Node, Parent) \
3151 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
3152 #define ABSTRACT_STMT(Node)
3153 #define EXPR(Node, Parent)
3154 #include "clang/AST/StmtNodes.inc"
3157 #define STMT(Node, Parent)
3158 #define ABSTRACT_STMT(Stmt)
3159 #define EXPR(Node, Parent) case Stmt::Node##Class:
3160 #include "clang/AST/StmtNodes.inc"
3162 ExprResult E = getDerived().TransformExpr(cast<Expr>(S));
3166 return getSema().ActOnExprStmt(E);
3173 template<
typename Derived>
3181 #define OPENMP_CLAUSE(Name, Class) \
3182 case OMPC_ ## Name : \
3183 return getDerived().Transform ## Class(cast<Class>(S));
3184 #include "clang/Basic/OpenMPKinds.def"
3191 template<
typename Derived>
3196 switch (E->getStmtClass()) {
3197 case Stmt::NoStmtClass:
break;
3198 #define STMT(Node, Parent) case Stmt::Node##Class: break;
3199 #define ABSTRACT_STMT(Stmt)
3200 #define EXPR(Node, Parent) \
3201 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
3202 #include "clang/AST/StmtNodes.inc"
3208 template<
typename Derived>
3217 Init = ExprTemp->getSubExpr();
3220 Init = MTE->GetTemporaryExpr();
3223 Init = Binder->getSubExpr();
3226 Init = ICE->getSubExprAsWritten();
3229 dyn_cast<CXXStdInitializerListExpr>(Init))
3230 return TransformInitializer(ILE->getSubExpr(), NotCopyInit);
3236 if (!NotCopyInit && !(Construct && Construct->isListInitialization()))
3237 return getDerived().TransformExpr(Init);
3242 return getDerived().RebuildParenListExpr(Parens.
getBegin(),
None,
3247 if (isa<ImplicitValueInitExpr>(Init))
3253 if (!Construct || isa<CXXTemporaryObjectExpr>(Construct))
3254 return getDerived().TransformExpr(Init);
3258 if (Construct && Construct->isStdInitListInitialization())
3259 return TransformInitializer(Construct->getArg(0), NotCopyInit);
3262 bool ArgChanged =
false;
3263 if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(),
3264 true, NewArgs, &ArgChanged))
3268 if (Construct->isListInitialization())
3269 return getDerived().RebuildInitList(Construct->getLocStart(), NewArgs,
3270 Construct->getLocEnd(),
3271 Construct->getType());
3274 SourceRange Parens = Construct->getParenOrBraceRange();
3278 assert(NewArgs.empty() &&
3279 "no parens or braces but have direct init with arguments?");
3282 return getDerived().RebuildParenListExpr(Parens.
getBegin(), NewArgs,
3286 template<
typename Derived>
3292 for (
unsigned I = 0;
I != NumInputs; ++
I) {
3294 if (IsCall && getDerived().DropCallArgument(Inputs[
I])) {
3302 Expr *Pattern = Expansion->getPattern();
3305 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
3306 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
3311 bool RetainExpansion =
false;
3314 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
3315 Pattern->getSourceRange(),
3317 Expand, RetainExpansion,
3326 ExprResult OutPattern = getDerived().TransformExpr(Pattern);
3330 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.
get(),
3331 Expansion->getEllipsisLoc(),
3338 Outputs.push_back(Out.
get());
3344 if (ArgChanged) *ArgChanged =
true;
3348 for (
unsigned I = 0; I != *NumExpansions; ++
I) {
3350 ExprResult Out = getDerived().TransformExpr(Pattern);
3355 Out = getDerived().RebuildPackExpansion(
3356 Out.
get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
3361 Outputs.push_back(Out.
get());
3366 if (RetainExpansion) {
3367 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
3369 ExprResult Out = getDerived().TransformExpr(Pattern);
3373 Out = getDerived().RebuildPackExpansion(
3374 Out.
get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
3378 Outputs.push_back(Out.
get());
3385 IsCall ? getDerived().TransformInitializer(Inputs[I],
false)
3386 : getDerived().TransformExpr(Inputs[I]);
3390 if (Result.
get() != Inputs[
I] && ArgChanged)
3393 Outputs.push_back(Result.
get());
3399 template <
typename Derived>
3403 VarDecl *ConditionVar = cast_or_null<VarDecl>(
3404 getDerived().TransformDefinition(Var->getLocation(), Var));
3409 return getSema().ActOnConditionVariable(ConditionVar, Loc, Kind);
3413 ExprResult CondExpr = getDerived().TransformExpr(Expr);
3418 return getSema().ActOnCondition(
nullptr, Loc, CondExpr.
get(),
Kind);
3424 template<
typename Derived>
3433 Qualifiers.push_back(Qualifier);
3436 while (!Qualifiers.empty()) {
3442 if (SemaRef.BuildCXXNestedNameSpecifier(
nullptr,
3446 ObjectType,
false, SS,
3447 FirstQualifierInScope,
false))
3454 = cast_or_null<NamespaceDecl>(
3455 getDerived().TransformDecl(
3464 = cast_or_null<NamespaceAliasDecl>(
3480 cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
3489 FirstQualifierInScope, SS);
3495 (SemaRef.getLangOpts().CPlusPlus11 &&
3498 "Can't get cv-qualifiers here");
3501 diag::warn_cxx98_compat_enum_nested_name_spec);
3510 SemaRef.Diag(TL.
getBeginLoc(), diag::err_nested_name_spec_non_tag)
3511 << TL.
getType() << SS.getRange();
3518 FirstQualifierInScope =
nullptr;
3524 !getDerived().AlwaysRebuild())
3537 template<
typename Derived>
3561 NewTInfo = getDerived().TransformType(OldTInfo);
3564 NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->
getType());
3572 NewCanTy = SemaRef.Context.getCanonicalType(NewT);
3576 = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.
getNameKind(),
3585 llvm_unreachable(
"Unknown name kind.");
3588 template<
typename Derived>
3597 assert(Template &&
"qualified template name must refer to a template");
3600 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
3605 if (!getDerived().AlwaysRebuild() &&
3607 TransTemplate == Template)
3610 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
3618 FirstQualifierInScope =
nullptr;
3621 if (!getDerived().AlwaysRebuild() &&
3626 if (DTN->isIdentifier()) {
3627 return getDerived().RebuildTemplateName(SS,
3628 *DTN->getIdentifier(),
3631 FirstQualifierInScope);
3634 return getDerived().RebuildTemplateName(SS, DTN->getOperator(), NameLoc,
3640 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
3645 if (!getDerived().AlwaysRebuild() &&
3646 TransTemplate == Template)
3655 = cast_or_null<TemplateTemplateParmDecl>(
3656 getDerived().TransformDecl(NameLoc, SubstPack->getParameterPack()));
3660 if (!getDerived().AlwaysRebuild() &&
3661 TransParam == SubstPack->getParameterPack())
3664 return getDerived().RebuildTemplateName(TransParam,
3665 SubstPack->getArgumentPack());
3669 llvm_unreachable(
"overloaded function decl survived to here");
3672 template<
typename Derived>
3679 llvm_unreachable(
"null template argument in TreeTransform");
3684 SemaRef.Context.getTrivialTypeSourceInfo(Arg.
getAsType(), Loc));
3693 Builder.
MakeTrivial(SemaRef.Context, DTN->getQualifier(), Loc);
3695 Builder.
MakeTrivial(SemaRef.Context, QTN->getQualifier(), Loc);
3722 template<
typename Derived>
3733 llvm_unreachable(
"Unexpected TemplateArgument");
3740 DI = getDerived().TransformType(DI);
3741 if (!DI)
return true;
3750 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
3756 SS.
Adopt(QualifierLoc);
3758 = getDerived().TransformTemplateName(SS, Arg.
getAsTemplate(),
3769 llvm_unreachable(
"Caller should expand pack expansions");
3779 ExprResult E = getDerived().TransformExpr(InputExpr);
3780 E = SemaRef.ActOnConstantExpression(E);
3793 template<
typename Derived,
typename InputIterator>
3801 typedef typename std::iterator_traits<InputIterator>::difference_type
3818 : Self(Self), Iter(Iter) { }
3833 Self.InventTemplateArgumentLoc(*Iter, Result);
3841 return X.Iter == Y.Iter;
3846 return X.Iter != Y.Iter;
3850 template<
typename Derived>
3851 template<
typename InputIterator>
3855 for (; First !=
Last; ++First) {
3868 if (TransformTemplateArguments(PackLocIterator(*
this,
3870 PackLocIterator(*
this,
3884 = getSema().getTemplateArgumentPackExpansionPattern(
3885 In, Ellipsis, OrigNumExpansions);
3888 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
3889 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
3894 bool RetainExpansion =
false;
3896 if (getDerived().TryExpandParameterPacks(Ellipsis,
3910 if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))
3913 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,
3924 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
3927 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
3931 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
3942 if (RetainExpansion) {
3943 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
3945 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
3948 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
3960 if (getDerived().TransformTemplateArgument(In, Out, Uneval))
3974 template<
typename Derived>
3976 if (getDerived().AlreadyTransformed(T))
3981 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
3982 getDerived().getBaseLocation());
3992 template<
typename Derived>
3996 getDerived().getBaseEntity());
3997 if (getDerived().AlreadyTransformed(DI->
getType()))
4012 template<
typename Derived>
4016 #define ABSTRACT_TYPELOC(CLASS, PARENT)
4017 #define TYPELOC(CLASS, PARENT) \
4018 case TypeLoc::CLASS: \
4019 return getDerived().Transform##CLASS##Type(TLB, \
4020 T.castAs<CLASS##TypeLoc>());
4021 #include "clang/AST/TypeLocNodes.def"
4024 llvm_unreachable(
"unhandled type loc!");
4032 template<
typename Derived>
4059 = dyn_cast<SubstTemplateTypeParmType>(Result)) {
4066 Result = SemaRef.Context.getSubstTemplateTypeParmType(
4067 SubstTypeParam->getReplacedParameter(),
4070 }
else if ((AutoTy = dyn_cast<AutoType>(Result)) && AutoTy->
isDeduced()) {
4073 Qualifiers Qs = Deduced.getQualifiers();
4075 Deduced = SemaRef.Context.getQualifiedType(Deduced.getUnqualifiedType(),
4077 Result = SemaRef.Context.getAutoType(Deduced, AutoTy->
getKeyword(),
4084 SemaRef.Diag(R.getBegin(), diag::err_attr_objc_ownership_redundant)
4091 if (!Quals.
empty()) {
4092 Result = SemaRef.BuildQualifiedType(Result, T.
getBeginLoc(), Quals);
4095 TLB.
push<QualifiedTypeLoc>(Result);
4102 template<
typename Derived>
4104 TreeTransform<Derived>::TransformTypeInObjectScope(TypeLoc TL,
4105 QualType ObjectType,
4106 NamedDecl *UnqualLookup,
4108 if (getDerived().AlreadyTransformed(TL.getType()))
4111 TypeSourceInfo *TSI =
4112 TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
4114 return TSI->getTypeLoc();
4118 template<
typename Derived>
4120 TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
4121 QualType ObjectType,
4122 NamedDecl *UnqualLookup,
4124 if (getDerived().AlreadyTransformed(TSInfo->getType()))
4127 return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType,
4131 template <
typename Derived>
4132 TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope(
4133 TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup,
4136 assert(!getDerived().AlreadyTransformed(T));
4141 if (isa<TemplateSpecializationType>(T)) {
4142 TemplateSpecializationTypeLoc SpecTL =
4143 TL.castAs<TemplateSpecializationTypeLoc>();
4145 TemplateName Template
4146 = getDerived().TransformTemplateName(SS,
4147 SpecTL.getTypePtr()->getTemplateName(),
4148 SpecTL.getTemplateNameLoc(),
4149 ObjectType, UnqualLookup);
4150 if (Template.isNull())
4153 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL,
4155 }
else if (isa<DependentTemplateSpecializationType>(T)) {
4156 DependentTemplateSpecializationTypeLoc SpecTL =
4157 TL.castAs<DependentTemplateSpecializationTypeLoc>();
4159 TemplateName Template
4160 = getDerived().RebuildTemplateName(SS,
4161 *SpecTL.getTypePtr()->getIdentifier(),
4162 SpecTL.getTemplateNameLoc(),
4163 ObjectType, UnqualLookup);
4164 if (Template.isNull())
4167 Result = getDerived().TransformDependentTemplateSpecializationType(TLB,
4173 Result = getDerived().TransformType(TLB, TL);
4176 if (Result.isNull())
4179 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
4182 template <
class TyLoc>
static inline
4184 TyLoc NewT = TLB.
push<TyLoc>(T.getType());
4185 NewT.setNameLoc(T.getNameLoc());
4189 template<
typename Derived>
4190 QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
4192 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType());
4193 NewT.setBuiltinLoc(T.getBuiltinLoc());
4194 if (T.needsExtraLocalData())
4195 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs();
4199 template<
typename Derived>
4200 QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
4206 template <
typename Derived>
4207 QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB,
4208 AdjustedTypeLoc TL) {
4210 return getDerived().TransformType(TLB, TL.getOriginalLoc());
4213 template<
typename Derived>
4214 QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB,
4215 DecayedTypeLoc TL) {
4216 QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc());
4217 if (OriginalType.isNull())
4220 QualType Result = TL.getType();
4221 if (getDerived().AlwaysRebuild() ||
4222 OriginalType != TL.getOriginalLoc().getType())
4223 Result = SemaRef.Context.getDecayedType(OriginalType);
4224 TLB.push<DecayedTypeLoc>(Result);
4229 template<
typename Derived>
4230 QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
4231 PointerTypeLoc TL) {
4232 QualType PointeeType
4233 = getDerived().TransformType(TLB, TL.getPointeeLoc());
4234 if (PointeeType.isNull())
4237 QualType Result = TL.getType();
4238 if (PointeeType->getAs<ObjCObjectType>()) {
4243 Result = SemaRef.Context.getObjCObjectPointerType(PointeeType);
4245 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
4246 NewT.setStarLoc(TL.getStarLoc());
4250 if (getDerived().AlwaysRebuild() ||
4251 PointeeType != TL.getPointeeLoc().getType()) {
4252 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
4253 if (Result.isNull())
4259 TLB.TypeWasModifiedSafely(Result->getPointeeType());
4261 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result);
4262 NewT.setSigilLoc(TL.getSigilLoc());
4266 template<
typename Derived>
4268 TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
4269 BlockPointerTypeLoc TL) {
4270 QualType PointeeType
4271 = getDerived().TransformType(TLB, TL.getPointeeLoc());
4272 if (PointeeType.isNull())
4275 QualType Result = TL.getType();
4276 if (getDerived().AlwaysRebuild() ||
4277 PointeeType != TL.getPointeeLoc().getType()) {
4278 Result = getDerived().RebuildBlockPointerType(PointeeType,
4280 if (Result.isNull())
4284 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result);
4285 NewT.setSigilLoc(TL.getSigilLoc());
4293 template<
typename Derived>
4301 if (PointeeType.
isNull())
4305 if (getDerived().AlwaysRebuild() ||
4307 Result = getDerived().RebuildReferenceType(PointeeType,
4321 if (isa<LValueReferenceType>(Result))
4330 template<
typename Derived>
4334 return TransformReferenceType(TLB, TL);
4337 template<
typename Derived>
4339 TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
4340 RValueReferenceTypeLoc TL) {
4341 return TransformReferenceType(TLB, TL);
4344 template<
typename Derived>
4346 TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
4347 MemberPointerTypeLoc TL) {
4348 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
4349 if (PointeeType.isNull())
4352 TypeSourceInfo* OldClsTInfo = TL.getClassTInfo();
4353 TypeSourceInfo *NewClsTInfo =
nullptr;
4355 NewClsTInfo = getDerived().TransformType(OldClsTInfo);
4360 const MemberPointerType *T = TL.getTypePtr();
4361 QualType OldClsType = QualType(T->getClass(), 0);
4362 QualType NewClsType;
4364 NewClsType = NewClsTInfo->getType();
4366 NewClsType = getDerived().TransformType(OldClsType);
4367 if (NewClsType.isNull())
4371 QualType Result = TL.getType();
4372 if (getDerived().AlwaysRebuild() ||
4373 PointeeType != T->getPointeeType() ||
4374 NewClsType != OldClsType) {
4375 Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType,
4377 if (Result.isNull())
4383 const MemberPointerType *MPT = Result->getAs<MemberPointerType>();
4384 if (MPT && PointeeType != MPT->getPointeeType()) {
4385 assert(isa<AdjustedType>(MPT->getPointeeType()));
4386 TLB.push<AdjustedTypeLoc>(MPT->getPointeeType());
4389 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
4390 NewTL.setSigilLoc(TL.getSigilLoc());
4391 NewTL.setClassTInfo(NewClsTInfo);
4396 template<
typename Derived>
4398 TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
4399 ConstantArrayTypeLoc TL) {
4400 const ConstantArrayType *T = TL.getTypePtr();
4401 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4402 if (ElementType.isNull())
4405 QualType Result = TL.getType();
4406 if (getDerived().AlwaysRebuild() ||
4407 ElementType != T->getElementType()) {
4408 Result = getDerived().RebuildConstantArrayType(ElementType,
4409 T->getSizeModifier(),
4411 T->getIndexTypeCVRQualifiers(),
4412 TL.getBracketsRange());
4413 if (Result.isNull())
4421 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4422 NewTL.setLBracketLoc(TL.getLBracketLoc());
4423 NewTL.setRBracketLoc(TL.getRBracketLoc());
4425 Expr *Size = TL.getSizeExpr();
4427 EnterExpressionEvaluationContext Unevaluated(SemaRef,
4429 Size = getDerived().TransformExpr(Size).template getAs<Expr>();
4430 Size = SemaRef.ActOnConstantExpression(Size).get();
4432 NewTL.setSizeExpr(Size);
4437 template<
typename Derived>
4438 QualType TreeTransform<Derived>::TransformIncompleteArrayType(
4439 TypeLocBuilder &TLB,
4440 IncompleteArrayTypeLoc TL) {
4441 const IncompleteArrayType *T = TL.getTypePtr();
4442 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4443 if (ElementType.isNull())
4446 QualType Result = TL.getType();
4447 if (getDerived().AlwaysRebuild() ||
4448 ElementType != T->getElementType()) {
4449 Result = getDerived().RebuildIncompleteArrayType(ElementType,
4450 T->getSizeModifier(),
4451 T->getIndexTypeCVRQualifiers(),
4452 TL.getBracketsRange());
4453 if (Result.isNull())
4457 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
4458 NewTL.setLBracketLoc(TL.getLBracketLoc());
4459 NewTL.setRBracketLoc(TL.getRBracketLoc());
4460 NewTL.setSizeExpr(
nullptr);
4465 template<
typename Derived>
4467 TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
4468 VariableArrayTypeLoc TL) {
4469 const VariableArrayType *T = TL.getTypePtr();
4470 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4471 if (ElementType.isNull())
4475 = getDerived().TransformExpr(T->getSizeExpr());
4476 if (SizeResult.isInvalid())
4479 Expr *Size = SizeResult.
get();
4481 QualType Result = TL.
getType();
4482 if (getDerived().AlwaysRebuild() ||
4483 ElementType != T->getElementType() ||
4484 Size != T->getSizeExpr()) {
4485 Result = getDerived().RebuildVariableArrayType(ElementType,
4486 T->getSizeModifier(),
4488 T->getIndexTypeCVRQualifiers(),
4489 TL.getBracketsRange());
4490 if (Result.isNull())
4496 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4497 NewTL.setLBracketLoc(TL.getLBracketLoc());
4498 NewTL.setRBracketLoc(TL.getRBracketLoc());
4499 NewTL.setSizeExpr(Size);
4504 template<
typename Derived>
4506 TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
4507 DependentSizedArrayTypeLoc TL) {
4508 const DependentSizedArrayType *T = TL.
getTypePtr();
4509 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4510 if (ElementType.isNull())
4514 EnterExpressionEvaluationContext Unevaluated(SemaRef,
4518 Expr *origSize = TL.getSizeExpr();
4519 if (!origSize) origSize = T->getSizeExpr();
4522 = getDerived().TransformExpr(origSize);
4523 sizeResult = SemaRef.ActOnConstantExpression(sizeResult);
4524 if (sizeResult.isInvalid())
4527 Expr *size = sizeResult.
get();
4529 QualType Result = TL.
getType();
4530 if (getDerived().AlwaysRebuild() ||
4531 ElementType != T->getElementType() ||
4533 Result = getDerived().RebuildDependentSizedArrayType(ElementType,
4534 T->getSizeModifier(),
4536 T->getIndexTypeCVRQualifiers(),
4537 TL.getBracketsRange());
4538 if (Result.isNull())
4544 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4545 NewTL.setLBracketLoc(TL.getLBracketLoc());
4546 NewTL.setRBracketLoc(TL.getRBracketLoc());
4547 NewTL.setSizeExpr(size);
4552 template<
typename Derived>
4553 QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
4554 TypeLocBuilder &TLB,
4555 DependentSizedExtVectorTypeLoc TL) {
4556 const DependentSizedExtVectorType *T = TL.
getTypePtr();
4559 QualType ElementType = getDerived().TransformType(T->getElementType());
4560 if (ElementType.isNull())
4564 EnterExpressionEvaluationContext Unevaluated(SemaRef,
4567 ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
4568 Size = SemaRef.ActOnConstantExpression(Size);
4569 if (Size.isInvalid())
4572 QualType Result = TL.getType();
4573 if (getDerived().AlwaysRebuild() ||
4574 ElementType != T->getElementType() ||
4575 Size.get() != T->getSizeExpr()) {
4576 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
4578 T->getAttributeLoc());
4579 if (Result.isNull())
4584 if (isa<DependentSizedExtVectorType>(Result)) {
4585 DependentSizedExtVectorTypeLoc NewTL
4586 = TLB.push<DependentSizedExtVectorTypeLoc>(Result);
4587 NewTL.setNameLoc(TL.getNameLoc());
4589 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
4590 NewTL.setNameLoc(TL.getNameLoc());
4596 template<
typename Derived>
4597 QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
4599 const VectorType *T = TL.getTypePtr();
4600 QualType ElementType = getDerived().TransformType(T->getElementType());
4601 if (ElementType.isNull())
4604 QualType Result = TL.getType();
4605 if (getDerived().AlwaysRebuild() ||
4606 ElementType != T->getElementType()) {
4607 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(),
4608 T->getVectorKind());
4609 if (Result.isNull())
4613 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
4614 NewTL.setNameLoc(TL.getNameLoc());
4619 template<
typename Derived>
4620 QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
4621 ExtVectorTypeLoc TL) {
4622 const VectorType *T = TL.getTypePtr();
4623 QualType ElementType = getDerived().TransformType(T->getElementType());
4624 if (ElementType.isNull())
4627 QualType Result = TL.getType();
4628 if (getDerived().AlwaysRebuild() ||
4629 ElementType != T->getElementType()) {
4630 Result = getDerived().RebuildExtVectorType(ElementType,
4631 T->getNumElements(),
4633 if (Result.isNull())
4637 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
4638 NewTL.setNameLoc(TL.getNameLoc());
4643 template <
typename Derived>
4646 bool ExpectParameterPack) {
4650 if (NumExpansions && isa<PackExpansionType>(OldDI->
getType())) {
4660 QualType Result = getDerived().TransformType(TLB,
4665 Result = RebuildPackExpansionType(Result,
4675 NewDI = TLB.getTypeSourceInfo(SemaRef.Context, Result);
4677 NewDI = getDerived().TransformType(OldDI);
4681 if (NewDI == OldDI && indexAdjustment == 0)
4685 OldParm->getDeclContext(),
4687 OldParm->getLocation(),
4698 template <
typename Derived>
4706 int indexAdjustment = 0;
4708 unsigned NumParams = Params.size();
4709 for (
unsigned i = 0; i != NumParams; ++i) {
4711 assert(OldParm->getFunctionScopeIndex() == i);
4715 if (OldParm->isParameterPack()) {
4720 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc();
4723 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
4724 assert(Unexpanded.size() > 0 &&
"Could not find parameter packs!");
4727 bool ShouldExpand =
false;
4728 bool RetainExpansion =
false;
4731 NumExpansions = OrigNumExpansions;
4732 if (getDerived().TryExpandParameterPacks(ExpansionTL.
getEllipsisLoc(),
4733 Pattern.getSourceRange(),
4744 getDerived().ExpandingFunctionParameterPack(OldParm);
4745 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
4748 = getDerived().TransformFunctionTypeParam(OldParm,
4756 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
4757 OutParamTypes.push_back(NewParm->
getType());
4759 PVars->push_back(NewParm);
4764 if (RetainExpansion) {
4765 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4767 = getDerived().TransformFunctionTypeParam(OldParm,
4775 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
4776 OutParamTypes.push_back(NewParm->
getType());
4778 PVars->push_back(NewParm);
4794 NewParm = getDerived().TransformFunctionTypeParam(OldParm,
4799 NewParm = getDerived().TransformFunctionTypeParam(
4800 OldParm, indexAdjustment,
None,
false);
4807 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
4808 OutParamTypes.push_back(NewParm->
getType());
4810 PVars->push_back(NewParm);
4817 bool IsPackExpansion =
false;
4821 = dyn_cast<PackExpansionType>(OldType)) {
4823 QualType Pattern = Expansion->getPattern();
4825 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
4828 bool ShouldExpand =
false;
4829 bool RetainExpansion =
false;
4830 if (getDerived().TryExpandParameterPacks(Loc,
SourceRange(),
4841 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
4843 QualType NewType = getDerived().TransformType(Pattern);
4849 getSema().getASTContext().getPackExpansionType(NewType,
None);
4856 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
4857 OutParamTypes.push_back(NewType);
4859 PVars->push_back(
nullptr);
4868 if (RetainExpansion) {
4869 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4870 QualType NewType = getDerived().TransformType(Pattern);
4875 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
4876 OutParamTypes.push_back(NewType);
4878 PVars->push_back(
nullptr);
4883 OldType = Expansion->getPattern();
4884 IsPackExpansion =
true;
4886 NewType = getDerived().TransformType(OldType);
4888 NewType = getDerived().TransformType(OldType);
4894 if (IsPackExpansion)
4895 NewType = getSema().Context.getPackExpansionType(NewType,
4899 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
4900 OutParamTypes.push_back(NewType);
4902 PVars->push_back(
nullptr);
4907 for (
unsigned i = 0, e = PVars->size(); i != e; ++i)
4909 assert(parm->getFunctionScopeIndex() == i);
4916 template<
typename Derived>
4923 TLB, TL,
nullptr, 0,
4926 ExceptionStorage, Changed);
4930 template<
typename Derived>
template<
typename Fn>
4933 unsigned ThisTypeQuals, Fn TransformExceptionSpec) {
4950 if (getDerived().TransformFunctionTypeParams(
4954 ParamTypes, &ParamDecls, ExtParamInfos))
4966 ResultType = getDerived().TransformType(TLB, TL.
getReturnLoc());
4972 ResultType = getDerived().TransformType(TLB, TL.
getReturnLoc());
4976 if (getDerived().TransformFunctionTypeParams(
4980 ParamTypes, &ParamDecls, ExtParamInfos))
4986 bool EPIChanged =
false;
4991 if (
auto NewExtParamInfos =
4995 != llvm::makeArrayRef(NewExtParamInfos, ParamTypes.size())) {
5005 if (getDerived().AlwaysRebuild() || ResultType != T->
getReturnType() ||
5006 T->
getParamTypes() != llvm::makeArrayRef(ParamTypes) || EPIChanged) {
5007 Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI);
5017 for (
unsigned i = 0, e = NewTL.
getNumParams(); i != e; ++i)
5023 template<
typename Derived>
5038 NoexceptExpr = getSema().CheckBooleanCondition(Loc, NoexceptExpr.
get());
5043 NoexceptExpr = getSema().VerifyIntegerConstantExpression(
5044 NoexceptExpr.
get(),
nullptr,
5045 diag::err_noexcept_needs_constant_expression,
5067 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
5069 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
5074 bool Expand =
false;
5075 bool RetainExpansion =
false;
5079 if (getDerived().TryExpandParameterPacks(
5081 RetainExpansion, NumExpansions))
5089 QualType U = getDerived().TransformType(PackExpansion->getPattern());
5093 U = SemaRef.Context.getPackExpansionType(U, NumExpansions);
5094 Exceptions.push_back(U);
5100 for (
unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
5103 QualType U = getDerived().TransformType(PackExpansion->getPattern());
5104 if (U.
isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
5107 Exceptions.push_back(U);
5110 QualType U = getDerived().TransformType(T);
5111 if (U.
isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
5116 Exceptions.push_back(U);
5124 template<
typename Derived>
5134 if (getDerived().AlwaysRebuild() || ResultType != T->
getReturnType())
5135 Result = getDerived().RebuildFunctionNoProtoType(ResultType);
5146 template<
typename Derived> QualType
5147 TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB,
5148 UnresolvedUsingTypeLoc TL) {
5149 const UnresolvedUsingType *T = TL.getTypePtr();
5150 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl());
5154 QualType Result = TL.getType();
5155 if (getDerived().AlwaysRebuild() || D != T->getDecl()) {
5156 Result = getDerived().RebuildUnresolvedUsingType(D);
5157 if (Result.isNull())
5163 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result);
5164 NewTL.setNameLoc(TL.getNameLoc());
5169 template<
typename Derived>
5170 QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
5171 TypedefTypeLoc TL) {
5173 TypedefNameDecl *Typedef
5174 = cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5179 QualType Result = TL.getType();
5180 if (getDerived().AlwaysRebuild() ||
5181 Typedef != T->getDecl()) {
5182 Result = getDerived().RebuildTypedefType(Typedef);
5183 if (Result.isNull())
5187 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result);
5188 NewTL.setNameLoc(TL.getNameLoc());
5193 template<
typename Derived>
5194 QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
5195 TypeOfExprTypeLoc TL) {
5200 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
5204 E = SemaRef.HandleExprEvaluationContextForTypeof(E.get());
5208 QualType Result = TL.getType();
5209 if (getDerived().AlwaysRebuild() ||
5210 E.get() != TL.getUnderlyingExpr()) {
5211 Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc());
5212 if (Result.isNull())
5217 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result);
5218 NewTL.setTypeofLoc(TL.getTypeofLoc());
5219 NewTL.setLParenLoc(TL.getLParenLoc());
5220 NewTL.setRParenLoc(TL.getRParenLoc());
5225 template<
typename Derived>
5226 QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
5228 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo();
5229 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);
5233 QualType Result = TL.getType();
5234 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {
5235 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType());
5236 if (Result.isNull())
5240 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result);
5241 NewTL.setTypeofLoc(TL.getTypeofLoc());
5242 NewTL.setLParenLoc(TL.getLParenLoc());
5243 NewTL.setRParenLoc(TL.getRParenLoc());
5244 NewTL.setUnderlyingTInfo(New_Under_TI);
5249 template<
typename Derived>
5250 QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
5251 DecltypeTypeLoc TL) {
5252 const DecltypeType *T = TL.getTypePtr();
5258 ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
5262 E = getSema().ActOnDecltypeExpression(E.get());
5266 QualType Result = TL.getType();
5267 if (getDerived().AlwaysRebuild() ||
5268 E.get() != T->getUnderlyingExpr()) {
5269 Result = getDerived().RebuildDecltypeType(E.get(), TL.getNameLoc());
5270 if (Result.isNull())
5275 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
5276 NewTL.setNameLoc(TL.getNameLoc());
5281 template<
typename Derived>
5282 QualType TreeTransform<Derived>::TransformUnaryTransformType(
5283 TypeLocBuilder &TLB,
5284 UnaryTransformTypeLoc TL) {
5285 QualType Result = TL.
getType();
5286 if (Result->isDependentType()) {
5287 const UnaryTransformType *T = TL.
getTypePtr();
5289 getDerived().TransformType(TL.getUnderlyingTInfo())->getType();
5290 Result = getDerived().RebuildUnaryTransformType(NewBase,
5293 if (Result.isNull())
5297 UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result);
5298 NewTL.setKWLoc(TL.getKWLoc());
5299 NewTL.setParensRange(TL.getParensRange());
5300 NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo());
5304 template<
typename Derived>
5305 QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
5307 const AutoType *T = TL.getTypePtr();
5308 QualType OldDeduced = T->getDeducedType();
5309 QualType NewDeduced;
5310 if (!OldDeduced.isNull()) {
5311 NewDeduced = getDerived().TransformType(OldDeduced);
5312 if (NewDeduced.isNull())
5316 QualType Result = TL.getType();
5317 if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
5318 T->isDependentType()) {
5319 Result = getDerived().RebuildAutoType(NewDeduced, T->getKeyword());
5320 if (Result.isNull())
5324 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
5325 NewTL.setNameLoc(TL.getNameLoc());
5330 template<
typename Derived>
5331 QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,
5333 const RecordType *T = TL.getTypePtr();
5335 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5340 QualType Result = TL.getType();
5341 if (getDerived().AlwaysRebuild() ||
5342 Record != T->getDecl()) {
5343 Result = getDerived().RebuildRecordType(Record);
5344 if (Result.isNull())
5348 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
5349 NewTL.setNameLoc(TL.getNameLoc());
5354 template<
typename Derived>
5355 QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
5357 const EnumType *T = TL.getTypePtr();
5359 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5364 QualType Result = TL.getType();
5365 if (getDerived().AlwaysRebuild() ||
5366 Enum != T->getDecl()) {
5367 Result = getDerived().RebuildEnumType(Enum);
5368 if (Result.isNull())
5372 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result);
5373 NewTL.setNameLoc(TL.getNameLoc());
5378 template<
typename Derived>
5379 QualType TreeTransform<Derived>::TransformInjectedClassNameType(
5380 TypeLocBuilder &TLB,
5381 InjectedClassNameTypeLoc TL) {
5382 Decl *D = getDerived().TransformDecl(TL.getNameLoc(),
5383 TL.getTypePtr()->getDecl());
5384 if (!D)
return QualType();
5386 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D));
5387 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc());
5391 template<
typename Derived>
5392 QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
5393 TypeLocBuilder &TLB,
5394 TemplateTypeParmTypeLoc TL) {
5398 template<
typename Derived>
5399 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
5400 TypeLocBuilder &TLB,
5401 SubstTemplateTypeParmTypeLoc TL) {
5402 const SubstTemplateTypeParmType *T = TL.getTypePtr();
5407 TemporaryBase Rebase(*
this, TL.getNameLoc(), DeclarationName());
5408 QualType Replacement = getDerived().TransformType(T->getReplacementType());
5409 if (Replacement.isNull())
5415 = SemaRef.Context.getSubstTemplateTypeParmType(T->getReplacedParameter(),
5419 SubstTemplateTypeParmTypeLoc NewTL
5420 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
5421 NewTL.setNameLoc(TL.getNameLoc());
5426 template<
typename Derived>
5427 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
5428 TypeLocBuilder &TLB,
5429 SubstTemplateTypeParmPackTypeLoc TL) {
5433 template<
typename Derived>
5443 = getDerived().TransformTemplateName(SS, T->getTemplateName(),
5448 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template);
5451 template<
typename Derived>
5459 if (getDerived().AlwaysRebuild() ||
5461 Result = getDerived().RebuildAtomicType(ValueType, TL.
getKWLoc());
5466 AtomicTypeLoc NewTL = TLB.
push<AtomicTypeLoc>(Result);
5474 template <
typename Derived>
5475 QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB,
5477 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
5478 if (ValueType.isNull())
5481 QualType Result = TL.getType();
5482 if (getDerived().AlwaysRebuild() || ValueType != TL.getValueLoc().getType()) {
5483 Result = getDerived().RebuildPipeType(ValueType, TL.getKWLoc());
5484 if (Result.isNull())
5488 PipeTypeLoc NewTL = TLB.push<PipeTypeLoc>(Result);
5489 NewTL.setKWLoc(TL.getKWLoc());
5499 template<
typename ArgLocContainer>
5501 ArgLocContainer *Container;
5526 : Container(&Container), Index(Index) { }
5540 return Container->getArgLoc(Index);
5544 return pointer(Container->getArgLoc(Index));
5549 return X.Container == Y.Container && X.Index == Y.Index;
5559 template <
typename Derived>
5561 TypeLocBuilder &TLB,
5562 TemplateSpecializationTypeLoc TL,
5563 TemplateName Template) {
5564 TemplateArgumentListInfo NewTemplateArgs;
5565 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
5566 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
5567 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>
5569 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5570 ArgIterator(TL, TL.getNumArgs()),
5577 getDerived().RebuildTemplateSpecializationType(Template,
5578 TL.getTemplateNameLoc(),
5581 if (!Result.isNull()) {
5586 if (isa<DependentTemplateSpecializationType>(Result)) {
5587 DependentTemplateSpecializationTypeLoc NewTL
5588 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
5589 NewTL.setElaboratedKeywordLoc(SourceLocation());
5590 NewTL.setQualifierLoc(NestedNameSpecifierLoc());
5591 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5592 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5593 NewTL.setLAngleLoc(TL.getLAngleLoc());
5594 NewTL.setRAngleLoc(TL.getRAngleLoc());
5595 for (
unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
5596 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
5600 TemplateSpecializationTypeLoc NewTL
5601 = TLB.push<TemplateSpecializationTypeLoc>(Result);
5602 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5603 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5604 NewTL.setLAngleLoc(TL.getLAngleLoc());
5605 NewTL.setRAngleLoc(TL.getRAngleLoc());
5606 for (
unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
5607 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
5613 template <
typename Derived>
5624 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5633 = getSema().Context.getDependentTemplateSpecializationType(
5635 DTN->getQualifier(),
5636 DTN->getIdentifier(),
5647 for (
unsigned i = 0, e = NewTemplateArgs.
size(); i != e; ++i)
5653 = getDerived().RebuildTemplateSpecializationType(Template,
5665 for (
unsigned i = 0, e = NewTemplateArgs.
size(); i != e; ++i)
5672 template<
typename Derived>
5687 QualType NamedT = getDerived().TransformType(TLB, TL.
getNamedTypeLoc());
5688 if (NamedT.isNull())
5698 TemplateName Template = TST->getTemplateName();
5699 if (TypeAliasTemplateDecl *TAT = dyn_cast_or_null<TypeAliasTemplateDecl>(
5700 Template.getAsTemplateDecl())) {
5702 diag::err_tag_reference_non_tag) << 4;
5703 SemaRef.Diag(TAT->getLocation(), diag::note_declared_at);
5708 QualType Result = TL.
getType();
5709 if (getDerived().AlwaysRebuild() ||
5714 QualifierLoc, NamedT);
5715 if (Result.isNull())
5719 ElaboratedTypeLoc NewTL = TLB.
push<ElaboratedTypeLoc>(Result);
5721 NewTL.setQualifierLoc(QualifierLoc);
5725 template<
typename Derived>
5726 QualType TreeTransform<Derived>::TransformAttributedType(
5727 TypeLocBuilder &TLB,
5728 AttributedTypeLoc TL) {
5730 QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc());
5731 if (modifiedType.isNull())
5734 QualType result = TL.getType();
5737 if (getDerived().AlwaysRebuild() ||
5738 modifiedType != oldType->getModifiedType()) {
5741 QualType equivalentType
5742 = getDerived().TransformType(oldType->getEquivalentType());
5743 if (equivalentType.isNull())
5748 if (
auto nullability = oldType->getImmediateNullability()) {
5749 if (!modifiedType->canHaveNullability()) {
5750 SemaRef.Diag(TL.getAttrNameLoc(), diag::err_nullability_nonpointer)
5756 result = SemaRef.Context.getAttributedType(oldType->getAttrKind(),
5761 AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result);
5762 newTL.setAttrNameLoc(TL.getAttrNameLoc());
5763 if (TL.hasAttrOperand())
5764 newTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5765 if (TL.hasAttrExprOperand())
5766 newTL.setAttrExprOperand(TL.getAttrExprOperand());
5767 else if (TL.hasAttrEnumOperand())
5768 newTL.setAttrEnumOperandLoc(TL.getAttrEnumOperandLoc());
5773 template<
typename Derived>
5775 TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB,
5777 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
5781 QualType Result = TL.getType();
5782 if (getDerived().AlwaysRebuild() ||
5783 Inner != TL.getInnerLoc().getType()) {
5784 Result = getDerived().RebuildParenType(Inner);
5785 if (Result.isNull())
5789 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result);
5790 NewTL.setLParenLoc(TL.getLParenLoc());
5791 NewTL.setRParenLoc(TL.getRParenLoc());
5795 template<
typename Derived>
5796 QualType TreeTransform<Derived>::TransformDependentNameType(TypeLocBuilder &TLB,
5797 DependentNameTypeLoc TL) {
5798 const DependentNameType *T = TL.getTypePtr();
5800 NestedNameSpecifierLoc QualifierLoc
5801 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
5806 = getDerived().RebuildDependentNameType(T->getKeyword(),
5807 TL.getElaboratedKeywordLoc(),
5811 if (Result.isNull())
5814 if (
const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) {
5815 QualType NamedT = ElabT->getNamedType();
5816 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc());
5818 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
5819 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5820 NewTL.setQualifierLoc(QualifierLoc);
5822 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result);
5823 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5824 NewTL.setQualifierLoc(QualifierLoc);
5825 NewTL.setNameLoc(TL.getNameLoc());
5830 template<
typename Derived>
5833 DependentTemplateSpecializationTypeLoc TL) {
5834 NestedNameSpecifierLoc QualifierLoc;
5835 if (TL.getQualifierLoc()) {
5837 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
5843 .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc);
5846 template<
typename Derived>
5859 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5865 = getDerived().RebuildDependentTemplateSpecializationType(T->getKeyword(),
5873 if (
const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) {
5874 QualType NamedT = ElabT->getNamedType();
5883 for (
unsigned I = 0, E = NewTemplateArgs.
size();
I !=
E; ++
I)
5890 }
else if (isa<DependentTemplateSpecializationType>(Result)) {
5899 for (
unsigned I = 0, E = NewTemplateArgs.
size();
I !=
E; ++
I)
5908 for (
unsigned I = 0, E = NewTemplateArgs.
size();
I !=
E; ++
I)
5914 template<
typename Derived>
5923 if (getDerived().AlwaysRebuild() ||
5925 Result = getDerived().RebuildPackExpansionType(Pattern,
5933 PackExpansionTypeLoc NewT = TLB.
push<PackExpansionTypeLoc>(Result);
5938 template<
typename Derived>
5940 TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
5941 ObjCInterfaceTypeLoc TL) {
5943 TLB.pushFullCopy(TL);
5944 return TL.getType();
5947 template<
typename Derived>
5949 TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
5950 ObjCObjectTypeLoc TL) {
5952 QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc());
5953 if (BaseType.isNull())
5956 bool AnyChanged = BaseType != TL.getBaseLoc().getType();
5959 SmallVector<TypeSourceInfo *, 4> NewTypeArgInfos;
5960 for (
unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) {
5961 TypeSourceInfo *TypeArgInfo = TL.getTypeArgTInfo(i);
5962 TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc();
5963 QualType TypeArg = TypeArgInfo->getType();
5964 if (
auto PackExpansionLoc = TypeArgLoc.getAs<PackExpansionTypeLoc>()) {
5968 const auto *PackExpansion = PackExpansionLoc.getType()
5969 ->
castAs<PackExpansionType>();
5970 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
5971 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
5973 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
5977 TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc();
5978 bool Expand =
false;
5979 bool RetainExpansion =
false;
5980 Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
5981 if (getDerived().TryExpandParameterPacks(
5982 PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(),
5983 Unexpanded, Expand, RetainExpansion, NumExpansions))
5990 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
5992 TypeLocBuilder TypeArgBuilder;
5993 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
5994 QualType NewPatternType = getDerived().TransformType(TypeArgBuilder,
5996 if (NewPatternType.isNull())
5999 QualType NewExpansionType = SemaRef.Context.getPackExpansionType(
6000 NewPatternType, NumExpansions);
6001 auto NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(NewExpansionType);
6002 NewExpansionLoc.setEllipsisLoc(PackExpansionLoc.getEllipsisLoc());
6003 NewTypeArgInfos.push_back(
6004 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewExpansionType));
6010 for (
unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
6011 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);
6013 TypeLocBuilder TypeArgBuilder;
6014 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
6016 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder,
6018 if (NewTypeArg.isNull())
6021 NewTypeArgInfos.push_back(
6022 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
6028 TypeLocBuilder TypeArgBuilder;
6029 TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize());
6030 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder, TypeArgLoc);
6031 if (NewTypeArg.isNull())
6035 if (NewTypeArg == TypeArg) {
6036 NewTypeArgInfos.push_back(TypeArgInfo);
6040 NewTypeArgInfos.push_back(
6041 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
6045 QualType Result = TL.getType();
6046 if (getDerived().AlwaysRebuild() || AnyChanged) {
6048 Result = getDerived().RebuildObjCObjectType(
6051 TL.getTypeArgsLAngleLoc(),
6053 TL.getTypeArgsRAngleLoc(),
6054 TL.getProtocolLAngleLoc(),
6055 llvm::makeArrayRef(TL.getTypePtr()->qual_begin(),
6056 TL.getNumProtocols()),
6057 TL.getProtocolLocs(),
6058 TL.getProtocolRAngleLoc());
6060 if (Result.isNull())
6064 ObjCObjectTypeLoc NewT = TLB.push<ObjCObjectTypeLoc>(Result);
6065 NewT.setHasBaseTypeAsWritten(
true);
6066 NewT.setTypeArgsLAngleLoc(TL.getTypeArgsLAngleLoc());
6067 for (
unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)
6068 NewT.setTypeArgTInfo(i, NewTypeArgInfos[i]);
6069 NewT.setTypeArgsRAngleLoc(TL.getTypeArgsRAngleLoc());
6070 NewT.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
6071 for (
unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
6072 NewT.setProtocolLoc(i, TL.getProtocolLoc(i));
6073 NewT.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
6077 template<
typename Derived>
6079 TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
6080 ObjCObjectPointerTypeLoc TL) {
6081 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
6082 if (PointeeType.isNull())
6085 QualType Result = TL.getType();
6086 if (getDerived().AlwaysRebuild() ||
6087 PointeeType != TL.getPointeeLoc().getType()) {
6088 Result = getDerived().RebuildObjCObjectPointerType(PointeeType,
6090 if (Result.isNull())
6094 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
6095 NewT.setStarLoc(TL.getStarLoc());
6102 template<
typename Derived>
6104 TreeTransform<Derived>::TransformNullStmt(NullStmt *
S) {
6108 template<
typename Derived>
6111 return getDerived().TransformCompoundStmt(S,
false);
6114 template<
typename Derived>
6120 bool SubStmtInvalid =
false;
6121 bool SubStmtChanged =
false;
6123 for (
auto *B : S->
body()) {
6124 StmtResult Result = getDerived().TransformStmt(B);
6128 if (isa<DeclStmt>(B))
6132 SubStmtInvalid =
true;
6136 SubStmtChanged = SubStmtChanged || Result.
get() != B;
6137 Statements.push_back(Result.
getAs<
Stmt>());
6143 if (!getDerived().AlwaysRebuild() &&
6147 return getDerived().RebuildCompoundStmt(S->
getLBracLoc(),
6153 template<
typename Derived>
6155 TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
6158 EnterExpressionEvaluationContext Unevaluated(SemaRef,
6162 LHS = getDerived().TransformExpr(S->getLHS());
6163 LHS = SemaRef.ActOnConstantExpression(LHS);
6164 if (LHS.isInvalid())
6168 RHS = getDerived().TransformExpr(S->getRHS());
6169 RHS = SemaRef.ActOnConstantExpression(RHS);
6170 if (RHS.isInvalid())
6177 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
6179 S->getEllipsisLoc(),
6182 if (Case.isInvalid())
6186 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6187 if (SubStmt.isInvalid())
6191 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get());
6194 template<
typename Derived>
6196 TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
6198 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6199 if (SubStmt.isInvalid())
6203 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
6207 template<
typename Derived>
6209 TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) {
6210 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6211 if (SubStmt.isInvalid())
6214 Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(),
6221 return getDerived().RebuildLabelStmt(S->getIdentLoc(),
6222 cast<LabelDecl>(LD), SourceLocation(),
6226 template <
typename Derived>
6234 #define PRAGMA_SPELLING_ATTR(X) \
6236 return getDerived().Transform##X##Attr(cast<X##Attr>(R));
6237 #include "clang/Basic/AttrList.inc"
6243 template <
typename Derived>
6245 bool AttrsChanged =
false;
6250 const Attr *R = getDerived().TransformAttr(
I);
6251 AttrsChanged |= (
I != R);
6256 if (SubStmt.isInvalid())
6259 if (SubStmt.get() == S->
getSubStmt() && !AttrsChanged)
6262 return getDerived().RebuildAttributedStmt(S->
getAttrLoc(), Attrs,
6266 template<
typename Derived>
6268 TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
6270 StmtResult Init = getDerived().TransformStmt(S->getInit());
6271 if (Init.isInvalid())
6275 Sema::ConditionResult Cond = getDerived().TransformCondition(
6276 S->getIfLoc(), S->getConditionVariable(), S->getCond(),
6279 if (Cond.isInvalid())
6284 if (S->isConstexpr())
6285 ConstexprConditionValue = Cond.getKnownValue();
6289 if (!ConstexprConditionValue || *ConstexprConditionValue) {
6290 Then = getDerived().TransformStmt(S->getThen());
6291 if (Then.isInvalid())
6294 Then =
new (getSema().Context) NullStmt(S->getThen()->getLocStart());
6299 if (!ConstexprConditionValue || !*ConstexprConditionValue) {
6300 Else = getDerived().TransformStmt(S->getElse());
6301 if (Else.isInvalid())
6305 if (!getDerived().AlwaysRebuild() &&
6306 Init.get() == S->getInit() &&
6307 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
6308 Then.get() == S->getThen() &&
6309 Else.get() == S->getElse())
6312 return getDerived().RebuildIfStmt(S->getIfLoc(), S->isConstexpr(), Cond,
6313 Init.get(), Then.get(), S->getElseLoc(),
6317 template<
typename Derived>
6319 TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
6321 StmtResult Init = getDerived().TransformStmt(S->getInit());
6322 if (Init.isInvalid())
6326 Sema::ConditionResult Cond = getDerived().TransformCondition(
6327 S->getSwitchLoc(), S->getConditionVariable(), S->getCond(),
6329 if (Cond.isInvalid())
6334 = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(),
6335 S->getInit(), Cond);
6336 if (Switch.isInvalid())
6340 StmtResult Body = getDerived().TransformStmt(S->getBody());
6341 if (Body.isInvalid())
6345 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(),
6349 template<
typename Derived>
6351 TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
6353 Sema::ConditionResult Cond = getDerived().TransformCondition(
6354 S->getWhileLoc(), S->getConditionVariable(), S->getCond(),
6356 if (Cond.isInvalid())
6360 StmtResult Body = getDerived().TransformStmt(S->getBody());
6361 if (Body.isInvalid())
6364 if (!getDerived().AlwaysRebuild() &&
6365 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
6366 Body.get() == S->getBody())
6369 return getDerived().RebuildWhileStmt(S->getWhileLoc(), Cond, Body.get());
6372 template<
typename Derived>
6374 TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
6376 StmtResult Body = getDerived().TransformStmt(S->getBody());
6377 if (Body.isInvalid())
6381 ExprResult Cond = getDerived().TransformExpr(S->getCond());
6382 if (Cond.isInvalid())
6385 if (!getDerived().AlwaysRebuild() &&
6386 Cond.get() == S->getCond() &&
6387 Body.get() == S->getBody())
6390 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(),
6391 S->getWhileLoc(), Cond.get(),
6395 template<
typename Derived>
6397 TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
6399 StmtResult Init = getDerived().TransformStmt(S->getInit());
6400 if (Init.isInvalid())
6405 if (getSema().getLangOpts().OpenMP && Init.isUsable())
6406 getSema().ActOnOpenMPLoopInitialization(S->getForLoc(), Init.get());
6409 Sema::ConditionResult Cond = getDerived().TransformCondition(
6410 S->getForLoc(), S->getConditionVariable(), S->getCond(),
6412 if (Cond.isInvalid())
6416 ExprResult Inc = getDerived().TransformExpr(S->getInc());
6417 if (Inc.isInvalid())
6420 Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(Inc.get()));
6421 if (S->getInc() && !FullInc.get())
6425 StmtResult Body = getDerived().TransformStmt(S->getBody());
6426 if (Body.isInvalid())
6429 if (!getDerived().AlwaysRebuild() &&
6430 Init.get() == S->getInit() &&
6431 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
6432 Inc.get() == S->getInc() &&
6433 Body.get() == S->getBody())
6436 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
6437 Init.get(), Cond, FullInc,
6438 S->getRParenLoc(), Body.get());
6441 template<
typename Derived>
6443 TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
6444 Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(),
6450 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
6451 cast<LabelDecl>(LD));
6454 template<
typename Derived>
6456 TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
6457 ExprResult Target = getDerived().TransformExpr(S->getTarget());
6458 if (Target.isInvalid())
6460 Target = SemaRef.MaybeCreateExprWithCleanups(Target.get());
6462 if (!getDerived().AlwaysRebuild() &&
6463 Target.get() == S->getTarget())
6466 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
6470 template<
typename Derived>
6472 TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
6476 template<
typename Derived>
6478 TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
6482 template<
typename Derived>
6484 TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
6485 ExprResult Result = getDerived().TransformInitializer(S->getRetValue(),
6487 if (Result.isInvalid())
6492 return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get());
6495 template<
typename Derived>
6497 TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
6498 bool DeclChanged =
false;
6499 SmallVector<Decl *, 4> Decls;
6500 for (
auto *D : S->decls()) {
6501 Decl *Transformed = getDerived().TransformDefinition(D->getLocation(), D);
6505 if (Transformed != D)
6508 Decls.push_back(Transformed);
6511 if (!getDerived().AlwaysRebuild() && !DeclChanged)
6514 return getDerived().RebuildDeclStmt(Decls, S->getStartLoc(), S->getEndLoc());
6517 template<
typename Derived>
6519 TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) {
6521 SmallVector<Expr*, 8> Constraints;
6522 SmallVector<Expr*, 8> Exprs;
6523 SmallVector<IdentifierInfo *, 4>
Names;
6526 SmallVector<Expr*, 8> Clobbers;
6528 bool ExprsChanged =
false;
6531 for (
unsigned I = 0, E = S->getNumOutputs();
I !=
E; ++
I) {
6532 Names.push_back(S->getOutputIdentifier(
I));
6535 Constraints.push_back(S->getOutputConstraintLiteral(
I));
6538 Expr *OutputExpr = S->getOutputExpr(
I);
6539 ExprResult Result = getDerived().TransformExpr(OutputExpr);
6540 if (Result.isInvalid())
6543 ExprsChanged |= Result.
get() != OutputExpr;
6545 Exprs.push_back(Result.get());
6549 for (
unsigned I = 0, E = S->getNumInputs();
I !=
E; ++
I) {
6550 Names.push_back(S->getInputIdentifier(
I));
6553 Constraints.push_back(S->getInputConstraintLiteral(
I));
6556 Expr *InputExpr = S->getInputExpr(
I);
6557 ExprResult Result = getDerived().TransformExpr(InputExpr);
6558 if (Result.isInvalid())
6561 ExprsChanged |= Result.
get() != InputExpr;
6563 Exprs.push_back(Result.get());
6566 if (!getDerived().AlwaysRebuild() && !ExprsChanged)
6570 for (
unsigned I = 0, E = S->getNumClobbers();
I !=
E; ++
I)
6571 Clobbers.push_back(S->getClobberStringLiteral(
I));
6574 AsmString = S->getAsmString();
6575 return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(),
6576 S->isVolatile(), S->getNumOutputs(),
6577 S->getNumInputs(), Names.data(),
6578 Constraints, Exprs, AsmString.get(),
6579 Clobbers, S->getRParenLoc());
6582 template<
typename Derived>
6584 TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
6585 ArrayRef<Token> AsmToks =
6586 llvm::makeArrayRef(S->getAsmToks(), S->getNumAsmToks());
6588 bool HadError =
false, HadChange =
false;
6590 ArrayRef<Expr*> SrcExprs = S->getAllExprs();
6591 SmallVector<Expr*, 8> TransformedExprs;
6592 TransformedExprs.reserve(SrcExprs.size());
6593 for (
unsigned i = 0, e = SrcExprs.size(); i != e; ++i) {
6594 ExprResult Result = getDerived().TransformExpr(SrcExprs[i]);
6595 if (!Result.isUsable()) {
6598 HadChange |= (Result.get() != SrcExprs[i]);
6599 TransformedExprs.push_back(Result.get());
6604 if (!HadChange && !getDerived().AlwaysRebuild())
6607 return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(),
6608 AsmToks, S->getAsmString(),
6609 S->getNumOutputs(), S->getNumInputs(),
6610 S->getAllConstraints(), S->getClobbers(),
6611 TransformedExprs, S->getEndLoc());
6616 template<
typename Derived>
6618 TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) {
6620 return getDerived().TransformStmt(S->getBody());
6623 template<
typename Derived>
6625 TreeTransform<Derived>::TransformCoreturnStmt(CoreturnStmt *S) {
6626 ExprResult Result = getDerived().TransformInitializer(S->getOperand(),
6628 if (Result.isInvalid())
6633 return getDerived().RebuildCoreturnStmt(S->getKeywordLoc(), Result.get());
6636 template<
typename Derived>
6638 TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *E) {
6639 ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
6641 if (Result.isInvalid())
6646 return getDerived().RebuildCoawaitExpr(E->getKeywordLoc(), Result.get());
6649 template<
typename Derived>
6651 TreeTransform<Derived>::TransformCoyieldExpr(CoyieldExpr *E) {
6652 ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
6654 if (Result.isInvalid())
6659 return getDerived().RebuildCoyieldExpr(E->getKeywordLoc(), Result.get());
6664 template<
typename Derived>
6666 TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
6668 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
6669 if (TryBody.isInvalid())
6673 bool AnyCatchChanged =
false;
6674 SmallVector<Stmt*, 8> CatchStmts;
6675 for (
unsigned I = 0, N = S->getNumCatchStmts();
I != N; ++
I) {
6676 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(
I));
6677 if (Catch.isInvalid())
6679 if (Catch.get() != S->getCatchStmt(
I))
6680 AnyCatchChanged =
true;
6681 CatchStmts.push_back(Catch.get());
6686 if (S->getFinallyStmt()) {
6687 Finally = getDerived().TransformStmt(S->getFinallyStmt());
6688 if (Finally.isInvalid())
6693 if (!getDerived().AlwaysRebuild() &&
6694 TryBody.get() == S->getTryBody() &&
6696 Finally.get() == S->getFinallyStmt())
6700 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(),
6701 CatchStmts, Finally.get());
6704 template<
typename Derived>
6706 TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
6708 VarDecl *Var =
nullptr;
6709 if (VarDecl *FromVar = S->getCatchParamDecl()) {
6710 TypeSourceInfo *TSInfo =
nullptr;
6711 if (FromVar->getTypeSourceInfo()) {
6712 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
6719 T = TSInfo->getType();
6721 T = getDerived().TransformType(FromVar->getType());
6726 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T);
6731 StmtResult Body = getDerived().TransformStmt(S->getCatchBody());
6732 if (Body.isInvalid())
6735 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
6740 template<
typename Derived>
6742 TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
6744 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
6745 if (Body.isInvalid())
6749 if (!getDerived().AlwaysRebuild() &&
6750 Body.get() == S->getFinallyBody())
6754 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
6758 template<
typename Derived>
6760 TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
6762 if (S->getThrowExpr()) {
6763 Operand = getDerived().TransformExpr(S->getThrowExpr());
6764 if (Operand.isInvalid())
6768 if (!getDerived().AlwaysRebuild() &&
6769 Operand.get() == S->getThrowExpr())
6772 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get());
6775 template<
typename Derived>
6777 TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
6778 ObjCAtSynchronizedStmt *S) {
6780 ExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
6781 if (Object.isInvalid())
6784 getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(),
6786 if (Object.isInvalid())
6790 StmtResult Body = getDerived().TransformStmt(S->getSynchBody());
6791 if (Body.isInvalid())
6795 if (!getDerived().AlwaysRebuild() &&
6796 Object.get() == S->getSynchExpr() &&
6797 Body.get() == S->getSynchBody())
6801 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
6802 Object.get(), Body.get());
6805 template<
typename Derived>
6807 TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt(
6808 ObjCAutoreleasePoolStmt *S) {
6810 StmtResult Body = getDerived().TransformStmt(S->getSubStmt());
6811 if (Body.isInvalid())
6815 if (!getDerived().AlwaysRebuild() &&
6816 Body.get() == S->getSubStmt())
6820 return getDerived().RebuildObjCAutoreleasePoolStmt(
6821 S->getAtLoc(), Body.get());
6824 template<
typename Derived>
6826 TreeTransform<Derived>::TransformObjCForCollectionStmt(
6827 ObjCForCollectionStmt *S) {
6829 StmtResult Element = getDerived().TransformStmt(S->getElement());
6830 if (Element.isInvalid())
6834 ExprResult Collection = getDerived().TransformExpr(S->getCollection());
6835 if (Collection.isInvalid())
6839 StmtResult Body = getDerived().TransformStmt(S->getBody());
6840 if (Body.isInvalid())
6844 if (!getDerived().AlwaysRebuild() &&
6845 Element.get() == S->getElement() &&
6846 Collection.get() == S->getCollection() &&
6847 Body.get() == S->getBody())
6851 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
6858 template <
typename Derived>
6859 StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
6861 VarDecl *Var =
nullptr;
6862 if (VarDecl *ExceptionDecl = S->getExceptionDecl()) {
6864 getDerived().TransformType(ExceptionDecl->getTypeSourceInfo());
6868 Var = getDerived().RebuildExceptionDecl(
6869 ExceptionDecl, T, ExceptionDecl->getInnerLocStart(),
6870 ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier());
6871 if (!Var || Var->isInvalidDecl())
6876 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
6877 if (Handler.isInvalid())
6880 if (!getDerived().AlwaysRebuild() && !Var &&
6881 Handler.get() == S->getHandlerBlock())
6884 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get());
6887 template <
typename Derived>
6888 StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
6890 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
6891 if (TryBlock.isInvalid())
6895 bool HandlerChanged =
false;
6896 SmallVector<Stmt *, 8> Handlers;
6897 for (
unsigned I = 0, N = S->getNumHandlers();
I != N; ++
I) {
6898 StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(
I));
6899 if (Handler.isInvalid())
6902 HandlerChanged = HandlerChanged || Handler.
get() != S->getHandler(
I);
6903 Handlers.push_back(Handler.getAs<
Stmt>());
6906 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
6910 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(),
6914 template<
typename Derived>
6916 TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) {
6917 StmtResult Range = getDerived().TransformStmt(S->getRangeStmt());
6918 if (Range.isInvalid())
6921 StmtResult Begin = getDerived().TransformStmt(S->getBeginStmt());
6922 if (Begin.isInvalid())
6924 StmtResult End = getDerived().TransformStmt(S->getEndStmt());
6925 if (End.isInvalid())
6928 ExprResult Cond = getDerived().TransformExpr(S->getCond());
6929 if (Cond.isInvalid())
6932 Cond = SemaRef.CheckBooleanCondition(S->getColonLoc(), Cond.get());
6933 if (Cond.isInvalid())
6936 Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.get());
6938 ExprResult Inc = getDerived().TransformExpr(S->getInc());
6939 if (Inc.isInvalid())
6942 Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.get());
6944 StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt());
6945 if (LoopVar.isInvalid())
6949 if (getDerived().AlwaysRebuild() ||
6950 Range.get() != S->getRangeStmt() ||
6951 Begin.get() != S->getBeginStmt() ||
6952 End.get() != S->getEndStmt() ||
6953 Cond.get() != S->getCond() ||
6954 Inc.get() != S->getInc() ||
6955 LoopVar.get() != S->getLoopVarStmt()) {
6956 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
6958 S->getColonLoc(), Range.get(),
6959 Begin.get(), End.get(),
6961 Inc.get(), LoopVar.get(),
6963 if (NewStmt.isInvalid())
6967 StmtResult Body = getDerived().TransformStmt(S->getBody());
6968 if (Body.isInvalid())
6973 if (Body.get() != S->getBody() && NewStmt.get() ==
S) {
6974 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
6976 S->getColonLoc(), Range.get(),
6977 Begin.get(), End.get(),
6979 Inc.get(), LoopVar.get(),
6981 if (NewStmt.isInvalid())
6985 if (NewStmt.get() ==
S)
6988 return FinishCXXForRangeStmt(NewStmt.get(), Body.get());
6991 template<
typename Derived>
6993 TreeTransform<Derived>::TransformMSDependentExistsStmt(
6994 MSDependentExistsStmt *S) {
6996 NestedNameSpecifierLoc QualifierLoc;
6997 if (S->getQualifierLoc()) {
6999 = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc());
7005 DeclarationNameInfo NameInfo = S->getNameInfo();
7006 if (NameInfo.getName()) {
7007 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
7008 if (!NameInfo.getName())
7013 if (!getDerived().AlwaysRebuild() &&
7014 QualifierLoc == S->getQualifierLoc() &&
7015 NameInfo.getName() == S->getNameInfo().getName())
7020 SS.Adopt(QualifierLoc);
7021 bool Dependent =
false;
7022 switch (getSema().CheckMicrosoftIfExistsSymbol(
nullptr, SS, NameInfo)) {
7024 if (S->isIfExists())
7027 return new (getSema().Context) NullStmt(S->getKeywordLoc());
7030 if (S->isIfNotExists())
7033 return new (getSema().Context) NullStmt(S->getKeywordLoc());
7044 StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt());
7045 if (SubStmt.isInvalid())
7053 return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(),
7060 template<
typename Derived>
7062 TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *E) {
7063 NestedNameSpecifierLoc QualifierLoc;
7064 if (E->getQualifierLoc()) {
7066 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
7071 MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>(
7072 getDerived().TransformDecl(E->getMemberLoc(), E->getPropertyDecl()));
7077 if (Base.isInvalid())
7080 return new (SemaRef.getASTContext())
7081 MSPropertyRefExpr(Base.get(), PD, E->isArrow(),
7082 SemaRef.getASTContext().PseudoObjectTy,
VK_LValue,
7083 QualifierLoc, E->getMemberLoc());
7086 template <
typename Derived>
7087 ExprResult TreeTransform<Derived>::TransformMSPropertySubscriptExpr(
7088 MSPropertySubscriptExpr *E) {
7089 auto BaseRes = getDerived().TransformExpr(E->getBase());
7090 if (BaseRes.isInvalid())
7092 auto IdxRes = getDerived().TransformExpr(E->getIdx());
7093 if (IdxRes.isInvalid())
7096 if (!getDerived().AlwaysRebuild() &&
7097 BaseRes.get() == E->getBase() &&
7098 IdxRes.get() == E->getIdx())
7101 return getDerived().RebuildArraySubscriptExpr(
7102 BaseRes.get(), SourceLocation(), IdxRes.get(), E->getRBracketLoc());
7105 template <
typename Derived>
7106 StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) {
7107 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
7108 if (TryBlock.isInvalid())
7111 StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler());
7112 if (Handler.isInvalid())
7115 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
7116 Handler.get() == S->getHandler())
7119 return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(),
7120 TryBlock.get(), Handler.get());
7123 template <
typename Derived>
7124 StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) {
7125 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
7126 if (Block.isInvalid())
7129 return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.get());
7132 template <
typename Derived>
7133 StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) {
7134 ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr());
7135 if (FilterExpr.isInvalid())
7138 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
7139 if (Block.isInvalid())
7142 return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(),
7146 template <
typename Derived>
7148 if (isa<SEHFinallyStmt>(Handler))
7149 return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler));
7151 return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler));
7154 template<
typename Derived>
7163 template <
typename Derived>
7170 TClauses.reserve(Clauses.size());
7174 getDerived().getSema().StartOpenMPClause((*I)->getClauseKind());
7175 OMPClause *Clause = getDerived().TransformOMPClause(*
I);
7176 getDerived().getSema().EndOpenMPClause();
7178 TClauses.push_back(Clause);
7180 TClauses.push_back(
nullptr);
7190 Body = getDerived().TransformStmt(
7194 getDerived().getSema().ActOnOpenMPRegionEnd(Body, TClauses);
7199 if (TClauses.size() != Clauses.size()) {
7206 DirName = cast<OMPCriticalDirective>(D)->getDirectiveName();
7207 DirName = getDerived().TransformDeclarationNameInfo(DirName);
7211 CancelRegion = cast<OMPCancellationPointDirective>(D)->getCancelRegion();
7213 CancelRegion = cast<OMPCancelDirective>(D)->getCancelRegion();
7216 return getDerived().RebuildOMPExecutableDirective(
7221 template <
typename Derived>
7225 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel, DirName,
nullptr,
7227 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7228 getDerived().getSema().EndOpenMPDSABlock(Res.
get());
7232 template <
typename Derived>
7234 TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *D) {
7235 DeclarationNameInfo DirName;
7236 getDerived().getSema().StartOpenMPDSABlock(OMPD_simd, DirName,
nullptr,
7238 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7239 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7243 template <
typename Derived>
7245 TreeTransform<Derived>::TransformOMPForDirective(OMPForDirective *D) {
7246 DeclarationNameInfo DirName;
7247 getDerived().getSema().StartOpenMPDSABlock(OMPD_for, DirName,
nullptr,
7249 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7250 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7254 template <
typename Derived>
7256 TreeTransform<Derived>::TransformOMPForSimdDirective(OMPForSimdDirective *D) {
7257 DeclarationNameInfo DirName;
7258 getDerived().getSema().StartOpenMPDSABlock(OMPD_for_simd, DirName,
nullptr,
7260 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7261 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7265 template <
typename Derived>
7267 TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *D) {
7268 DeclarationNameInfo DirName;
7269 getDerived().getSema().StartOpenMPDSABlock(OMPD_sections, DirName,
nullptr,
7271 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7272 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7276 template <
typename Derived>
7278 TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *D) {
7279 DeclarationNameInfo DirName;
7280 getDerived().getSema().StartOpenMPDSABlock(OMPD_section, DirName,
nullptr,
7282 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7283 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7287 template <
typename Derived>
7289 TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *D) {
7290 DeclarationNameInfo DirName;
7291 getDerived().getSema().StartOpenMPDSABlock(OMPD_single, DirName,
nullptr,
7293 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7294 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7298 template <
typename Derived>
7300 TreeTransform<Derived>::TransformOMPMasterDirective(OMPMasterDirective *D) {
7301 DeclarationNameInfo DirName;
7302 getDerived().getSema().StartOpenMPDSABlock(OMPD_master, DirName,
nullptr,
7304 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7305 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7309 template <
typename Derived>
7311 TreeTransform<Derived>::TransformOMPCriticalDirective(OMPCriticalDirective *D) {
7312 getDerived().getSema().StartOpenMPDSABlock(
7313 OMPD_critical, D->getDirectiveName(),
nullptr, D->getLocStart());
7314 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7315 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7319 template <
typename Derived>
7320 StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective(
7321 OMPParallelForDirective *D) {
7322 DeclarationNameInfo DirName;
7323 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for, DirName,
7324 nullptr, D->getLocStart());
7325 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7326 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7330 template <
typename Derived>
7331 StmtResult TreeTransform<Derived>::TransformOMPParallelForSimdDirective(
7332 OMPParallelForSimdDirective *D) {
7333 DeclarationNameInfo DirName;
7334 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for_simd, DirName,
7335 nullptr, D->getLocStart());
7336 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7337 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7341 template <
typename Derived>
7342 StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective(
7343 OMPParallelSectionsDirective *D) {
7344 DeclarationNameInfo DirName;
7345 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_sections, DirName,
7346 nullptr, D->getLocStart());
7347 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7348 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7352 template <
typename Derived>
7354 TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *D) {
7355 DeclarationNameInfo DirName;
7356 getDerived().getSema().StartOpenMPDSABlock(OMPD_task, DirName,
nullptr,
7358 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7359 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7363 template <
typename Derived>
7364 StmtResult TreeTransform<Derived>::TransformOMPTaskyieldDirective(
7365 OMPTaskyieldDirective *D) {
7366 DeclarationNameInfo DirName;
7367 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskyield, DirName,
nullptr,
7369 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7370 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7374 template <
typename Derived>
7376 TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *D) {
7377 DeclarationNameInfo DirName;
7378 getDerived().getSema().StartOpenMPDSABlock(OMPD_barrier, DirName,
nullptr,
7380 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7381 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7385 template <
typename Derived>
7387 TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
7388 DeclarationNameInfo DirName;
7389 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskwait, DirName,
nullptr,
7391 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7392 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7396 template <
typename Derived>
7397 StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective(
7398 OMPTaskgroupDirective *D) {
7399 DeclarationNameInfo DirName;
7400 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskgroup, DirName,
nullptr,
7402 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7403 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7407 template <
typename Derived>
7409 TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *D) {
7410 DeclarationNameInfo DirName;
7411 getDerived().getSema().StartOpenMPDSABlock(OMPD_flush, DirName,
nullptr,
7413 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7414 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7418 template <
typename Derived>
7420 TreeTransform<Derived>::TransformOMPOrderedDirective(OMPOrderedDirective *D) {
7421 DeclarationNameInfo DirName;
7422 getDerived().getSema().StartOpenMPDSABlock(OMPD_ordered, DirName,
nullptr,
7424 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7425 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7429 template <
typename Derived>
7431 TreeTransform<Derived>::TransformOMPAtomicDirective(OMPAtomicDirective *D) {
7432 DeclarationNameInfo DirName;
7433 getDerived().getSema().StartOpenMPDSABlock(OMPD_atomic, DirName,
nullptr,
7435 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7436 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7440 template <
typename Derived>
7442 TreeTransform<Derived>::TransformOMPTargetDirective(OMPTargetDirective *D) {
7443 DeclarationNameInfo DirName;
7444 getDerived().getSema().StartOpenMPDSABlock(OMPD_target, DirName,
nullptr,
7446 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7447 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7451 template <
typename Derived>
7452 StmtResult TreeTransform<Derived>::TransformOMPTargetDataDirective(
7453 OMPTargetDataDirective *D) {
7454 DeclarationNameInfo DirName;
7455 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_data, DirName,
nullptr,
7457 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7458 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7462 template <
typename Derived>
7463 StmtResult TreeTransform<Derived>::TransformOMPTargetEnterDataDirective(
7464 OMPTargetEnterDataDirective *D) {
7465 DeclarationNameInfo DirName;
7466 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_enter_data, DirName,
7467 nullptr, D->getLocStart());
7468 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7469 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7473 template <
typename Derived>
7474 StmtResult TreeTransform<Derived>::TransformOMPTargetExitDataDirective(
7475 OMPTargetExitDataDirective *D) {
7476 DeclarationNameInfo DirName;
7477 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_exit_data, DirName,
7478 nullptr, D->getLocStart());
7479 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7480 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7484 template <
typename Derived>
7485 StmtResult TreeTransform<Derived>::TransformOMPTargetParallelDirective(
7486 OMPTargetParallelDirective *D) {
7487 DeclarationNameInfo DirName;
7488 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel, DirName,
7489 nullptr, D->getLocStart());
7490 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7491 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7495 template <
typename Derived>
7496 StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForDirective(
7497 OMPTargetParallelForDirective *D) {
7498 DeclarationNameInfo DirName;
7499 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel_for, DirName,
7500 nullptr, D->getLocStart());
7501 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7502 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7506 template <
typename Derived>
7507 StmtResult TreeTransform<Derived>::TransformOMPTargetUpdateDirective(
7508 OMPTargetUpdateDirective *D) {
7509 DeclarationNameInfo DirName;
7510 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_update, DirName,
7511 nullptr, D->getLocStart());
7512 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7513 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7517 template <
typename Derived>
7519 TreeTransform<Derived>::TransformOMPTeamsDirective(OMPTeamsDirective *D) {
7520 DeclarationNameInfo DirName;
7521 getDerived().getSema().StartOpenMPDSABlock(OMPD_teams, DirName,
nullptr,
7523 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7524 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7528 template <
typename Derived>
7529 StmtResult TreeTransform<Derived>::TransformOMPCancellationPointDirective(
7530 OMPCancellationPointDirective *D) {
7531 DeclarationNameInfo DirName;
7532 getDerived().getSema().StartOpenMPDSABlock(OMPD_cancellation_point, DirName,
7533 nullptr, D->getLocStart());
7534 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7535 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7539 template <
typename Derived>
7541 TreeTransform<Derived>::TransformOMPCancelDirective(OMPCancelDirective *D) {
7542 DeclarationNameInfo DirName;
7543 getDerived().getSema().StartOpenMPDSABlock(OMPD_cancel, DirName,
nullptr,
7545 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7546 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7550 template <
typename Derived>
7552 TreeTransform<Derived>::TransformOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
7553 DeclarationNameInfo DirName;
7554 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop, DirName,
nullptr,
7556 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7557 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7561 template <
typename Derived>
7562 StmtResult TreeTransform<Derived>::TransformOMPTaskLoopSimdDirective(
7563 OMPTaskLoopSimdDirective *D) {
7564 DeclarationNameInfo DirName;
7565 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop_simd, DirName,
7566 nullptr, D->getLocStart());
7567 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7568 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7572 template <
typename Derived>
7573 StmtResult TreeTransform<Derived>::TransformOMPDistributeDirective(
7574 OMPDistributeDirective *D) {
7575 DeclarationNameInfo DirName;
7576 getDerived().getSema().StartOpenMPDSABlock(OMPD_distribute, DirName,
nullptr,
7578 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7579 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7583 template <
typename Derived>
7584 StmtResult TreeTransform<Derived>::TransformOMPDistributeParallelForDirective(
7585 OMPDistributeParallelForDirective *D) {
7586 DeclarationNameInfo DirName;
7587 getDerived().getSema().StartOpenMPDSABlock(
7588 OMPD_distribute_parallel_for, DirName,
nullptr, D->getLocStart());
7589 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7590 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7594 template <
typename Derived>
7596 TreeTransform<Derived>::TransformOMPDistributeParallelForSimdDirective(
7597 OMPDistributeParallelForSimdDirective *D) {
7598 DeclarationNameInfo DirName;
7599 getDerived().getSema().StartOpenMPDSABlock(
7600 OMPD_distribute_parallel_for_simd, DirName,
nullptr, D->getLocStart());
7601 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7602 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7606 template <
typename Derived>
7607 StmtResult TreeTransform<Derived>::TransformOMPDistributeSimdDirective(
7608 OMPDistributeSimdDirective *D) {
7609 DeclarationNameInfo DirName;
7610 getDerived().getSema().StartOpenMPDSABlock(OMPD_distribute_simd, DirName,
7611 nullptr, D->getLocStart());
7612 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7613 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7617 template <
typename Derived>
7618 StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForSimdDirective(
7619 OMPTargetParallelForSimdDirective *D) {
7620 DeclarationNameInfo DirName;
7621 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel_for_simd,
7624 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7625 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7632 template <
typename Derived>
7633 OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *C) {
7634 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
7635 if (Cond.isInvalid())
7637 return getDerived().RebuildOMPIfClause(
7638 C->getNameModifier(), Cond.get(), C->getLocStart(), C->getLParenLoc(),
7639 C->getNameModifierLoc(), C->getColonLoc(), C->getLocEnd());
7642 template <
typename Derived>
7643 OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *C) {
7644 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
7645 if (Cond.isInvalid())
7647 return getDerived().RebuildOMPFinalClause(Cond.get(), C->getLocStart(),
7648 C->getLParenLoc(), C->getLocEnd());
7651 template <
typename Derived>
7653 TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *C) {
7654 ExprResult NumThreads = getDerived().TransformExpr(C->getNumThreads());
7655 if (NumThreads.isInvalid())
7657 return getDerived().RebuildOMPNumThreadsClause(
7658 NumThreads.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7661 template <
typename Derived>
7663 TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *C) {
7664 ExprResult E = getDerived().TransformExpr(C->getSafelen());
7667 return getDerived().RebuildOMPSafelenClause(
7668 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7671 template <
typename Derived>
7673 TreeTransform<Derived>::TransformOMPSimdlenClause(OMPSimdlenClause *C) {
7674 ExprResult E = getDerived().TransformExpr(C->getSimdlen());
7677 return getDerived().RebuildOMPSimdlenClause(
7678 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7681 template <
typename Derived>
7683 TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) {
7684 ExprResult E = getDerived().TransformExpr(C->getNumForLoops());
7687 return getDerived().RebuildOMPCollapseClause(
7688 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7691 template <
typename Derived>
7693 TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *C) {
7694 return getDerived().RebuildOMPDefaultClause(
7695 C->getDefaultKind(), C->getDefaultKindKwLoc(), C->getLocStart(),
7696 C->getLParenLoc(), C->getLocEnd());
7699 template <
typename Derived>
7701 TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *C) {
7702 return getDerived().RebuildOMPProcBindClause(
7703 C->getProcBindKind(), C->getProcBindKindKwLoc(), C->getLocStart(),
7704 C->getLParenLoc(), C->getLocEnd());
7707 template <
typename Derived>
7709 TreeTransform<Derived>::TransformOMPScheduleClause(OMPScheduleClause *C) {
7710 ExprResult E = getDerived().TransformExpr(C->getChunkSize());
7713 return getDerived().RebuildOMPScheduleClause(
7714 C->getFirstScheduleModifier(), C->getSecondScheduleModifier(),
7715 C->getScheduleKind(), E.get(), C->getLocStart(), C->getLParenLoc(),
7716 C->getFirstScheduleModifierLoc(), C->getSecondScheduleModifierLoc(),
7717 C->getScheduleKindLoc(), C->getCommaLoc(), C->getLocEnd());
7720 template <
typename Derived>
7722 TreeTransform<Derived>::TransformOMPOrderedClause(OMPOrderedClause *C) {
7724 if (
auto *Num = C->getNumForLoops()) {
7725 E = getDerived().TransformExpr(Num);
7729 return getDerived().RebuildOMPOrderedClause(C->getLocStart(), C->getLocEnd(),
7730 C->getLParenLoc(), E.get());
7733 template <
typename Derived>
7735 TreeTransform<Derived>::TransformOMPNowaitClause(OMPNowaitClause *C) {
7740 template <
typename Derived>
7742 TreeTransform<Derived>::TransformOMPUntiedClause(OMPUntiedClause *C) {
7747 template <
typename Derived>
7749 TreeTransform<Derived>::TransformOMPMergeableClause(OMPMergeableClause *C) {
7754 template <
typename Derived>
7755 OMPClause *TreeTransform<Derived>::TransformOMPReadClause(OMPReadClause *C) {
7760 template <
typename Derived>
7761 OMPClause *TreeTransform<Derived>::TransformOMPWriteClause(OMPWriteClause *C) {
7766 template <
typename Derived>
7768 TreeTransform<Derived>::TransformOMPUpdateClause(OMPUpdateClause *C) {
7773 template <
typename Derived>
7775 TreeTransform<Derived>::TransformOMPCaptureClause(OMPCaptureClause *C) {
7780 template <
typename Derived>
7782 TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *C) {
7787 template <
typename Derived>
7794 template <
typename Derived>
7800 template <
typename Derived>
7807 template <
typename Derived>
7809 TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) {
7811 Vars.reserve(C->varlist_size());
7812 for (
auto *VE : C->varlists()) {
7813 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7814 if (EVar.isInvalid())
7816 Vars.push_back(EVar.get());
7818 return getDerived().RebuildOMPPrivateClause(
7819 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7822 template <
typename Derived>
7823 OMPClause *TreeTransform<Derived>::TransformOMPFirstprivateClause(
7824 OMPFirstprivateClause *C) {
7826 Vars.reserve(C->varlist_size());
7827 for (
auto *VE : C->varlists()) {
7828 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7829 if (EVar.isInvalid())
7831 Vars.push_back(EVar.get());
7833 return getDerived().RebuildOMPFirstprivateClause(
7834 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7837 template <
typename Derived>
7839 TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *C) {
7841 Vars.reserve(C->varlist_size());
7842 for (
auto *VE : C->varlists()) {
7843 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7844 if (EVar.isInvalid())
7846 Vars.push_back(EVar.get());
7848 return getDerived().RebuildOMPLastprivateClause(
7849 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7852 template <
typename Derived>
7854 TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *C) {
7856 Vars.reserve(C->varlist_size());
7857 for (
auto *VE : C->varlists()) {
7858 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7859 if (EVar.isInvalid())
7861 Vars.push_back(EVar.get());
7863 return getDerived().RebuildOMPSharedClause(Vars, C->getLocStart(),
7864 C->getLParenLoc(), C->getLocEnd());
7867 template <
typename Derived>
7869 TreeTransform<Derived>::TransformOMPReductionClause(OMPReductionClause *C) {
7871 Vars.reserve(C->varlist_size());
7872 for (
auto *VE : C->varlists()) {
7873 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7874 if (EVar.isInvalid())
7876 Vars.push_back(EVar.get());
7878 CXXScopeSpec ReductionIdScopeSpec;
7879 ReductionIdScopeSpec.Adopt(C->getQualifierLoc());
7881 DeclarationNameInfo NameInfo = C->getNameInfo();
7882 if (NameInfo.getName()) {
7883 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
7884 if (!NameInfo.getName())
7890 for (
auto *E : C->reduction_ops()) {
7893 auto *ULE = cast<UnresolvedLookupExpr>(
E);
7894 UnresolvedSet<8> Decls;
7895 for (
auto *D : ULE->decls()) {
7897 cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
7898 Decls.addDecl(InstD, InstD->getAccess());
7900 UnresolvedReductions.push_back(
7902 SemaRef.Context,
nullptr,
7903 ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context),
7904 NameInfo,
true, ULE->isOverloaded(),
7905 Decls.begin(), Decls.end()));
7907 UnresolvedReductions.push_back(
nullptr);
7909 return getDerived().RebuildOMPReductionClause(
7910 Vars, C->getLocStart(), C->getLParenLoc(), C->getColonLoc(),
7911 C->getLocEnd(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
7914 template <
typename Derived>
7916 TreeTransform<Derived>::TransformOMPLinearClause(
OMPLinearClause *C) {
7918 Vars.reserve(C->varlist_size());
7919 for (
auto *VE : C->varlists()) {
7920 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7921 if (EVar.isInvalid())
7923 Vars.push_back(EVar.get());
7926 if (Step.isInvalid())
7928 return getDerived().RebuildOMPLinearClause(
7929 Vars, Step.get(), C->getLocStart(), C->getLParenLoc(), C->getModifier(),
7930 C->getModifierLoc(), C->getColonLoc(), C->getLocEnd());
7933 template <
typename Derived>
7937 Vars.reserve(C->varlist_size());
7938 for (
auto *VE : C->varlists()) {
7939 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7940 if (EVar.isInvalid())
7942 Vars.push_back(EVar.get());
7945 if (Alignment.isInvalid())
7947 return getDerived().RebuildOMPAlignedClause(
7948 Vars, Alignment.get(), C->getLocStart(), C->getLParenLoc(),
7952 template <
typename Derived>
7954 TreeTransform<Derived>::TransformOMPCopyinClause(
OMPCopyinClause *C) {
7956 Vars.reserve(C->varlist_size());
7957 for (
auto *VE : C->varlists()) {
7958 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7959 if (EVar.isInvalid())
7961 Vars.push_back(EVar.get());
7963 return getDerived().RebuildOMPCopyinClause(Vars, C->getLocStart(),
7964 C->getLParenLoc(), C->getLocEnd());
7967 template <
typename Derived>
7971 Vars.reserve(C->varlist_size());
7972 for (
auto *VE : C->varlists()) {
7973 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7974 if (EVar.isInvalid())
7976 Vars.push_back(EVar.get());
7978 return getDerived().RebuildOMPCopyprivateClause(
7979 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7982 template <
typename Derived>
7985 Vars.reserve(C->varlist_size());
7986 for (
auto *VE : C->varlists()) {
7987 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7988 if (EVar.isInvalid())
7990 Vars.push_back(EVar.get());
7992 return getDerived().RebuildOMPFlushClause(Vars, C->getLocStart(),
7993 C->getLParenLoc(), C->getLocEnd());
7996 template <
typename Derived>
7998 TreeTransform<Derived>::TransformOMPDependClause(
OMPDependClause *C) {
8000 Vars.reserve(C->varlist_size());
8001 for (
auto *VE : C->varlists()) {
8002 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8003 if (EVar.isInvalid())
8005 Vars.push_back(EVar.get());
8007 return getDerived().RebuildOMPDependClause(
8009 C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8012 template <
typename Derived>
8014 TreeTransform<Derived>::TransformOMPDeviceClause(
OMPDeviceClause *C) {
8018 return getDerived().RebuildOMPDeviceClause(
8019 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
8022 template <
typename Derived>
8025 Vars.reserve(C->varlist_size());
8026 for (
auto *VE : C->varlists()) {
8027 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8028 if (EVar.isInvalid())
8030 Vars.push_back(EVar.get());
8032 return getDerived().RebuildOMPMapClause(
8035 C->getLParenLoc(), C->getLocEnd());
8038 template <
typename Derived>
8044 return getDerived().RebuildOMPNumTeamsClause(
8045 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
8048 template <
typename Derived>
8054 return getDerived().RebuildOMPThreadLimitClause(
8055 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
8058 template <
typename Derived>
8064 return getDerived().RebuildOMPPriorityClause(
8065 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
8068 template <
typename Derived>
8074 return getDerived().RebuildOMPGrainsizeClause(
8075 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
8078 template <
typename Derived>
8084 return getDerived().RebuildOMPNumTasksClause(
8085 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
8088 template <
typename Derived>
8093 return getDerived().RebuildOMPHintClause(E.get(), C->getLocStart(),
8097 template <
typename Derived>
8098 OMPClause *TreeTransform<Derived>::TransformOMPDistScheduleClause(
8103 return getDerived().RebuildOMPDistScheduleClause(
8108 template <
typename Derived>
8114 template <
typename Derived>
8117 Vars.reserve(C->varlist_size());
8118 for (
auto *VE : C->varlists()) {
8119 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8120 if (EVar.isInvalid())
8122 Vars.push_back(EVar.get());
8124 return getDerived().RebuildOMPToClause(Vars, C->getLocStart(),
8125 C->getLParenLoc(), C->getLocEnd());
8128 template <
typename Derived>
8131 Vars.reserve(C->varlist_size());
8132 for (
auto *VE : C->varlists()) {
8133 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8134 if (EVar.isInvalid())
8136 Vars.push_back(EVar.get());
8138 return getDerived().RebuildOMPFromClause(Vars, C->getLocStart(),
8139 C->getLParenLoc(), C->getLocEnd());
8142 template <
typename Derived>
8143 OMPClause *TreeTransform<Derived>::TransformOMPUseDevicePtrClause(
8146 Vars.reserve(C->varlist_size());
8147 for (
auto *VE : C->varlists()) {
8148 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8149 if (EVar.isInvalid())
8151 Vars.push_back(EVar.get());
8153 return getDerived().RebuildOMPUseDevicePtrClause(
8154 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8157 template <
typename Derived>
8161 Vars.reserve(C->varlist_size());
8162 for (
auto *VE : C->varlists()) {
8163 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8164 if (EVar.isInvalid())
8166 Vars.push_back(EVar.get());
8168 return getDerived().RebuildOMPIsDevicePtrClause(
8169 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8175 template<
typename Derived>
8177 TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) {
8178 if (!E->isTypeDependent())
8181 return getDerived().RebuildPredefinedExpr(E->getLocation(),
8185 template<
typename Derived>
8187 TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) {
8188 NestedNameSpecifierLoc QualifierLoc;
8189 if (E->getQualifierLoc()) {
8191 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
8197 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
8202 DeclarationNameInfo NameInfo = E->getNameInfo();
8203 if (NameInfo.getName()) {
8204 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
8205 if (!NameInfo.getName())
8209 if (!getDerived().AlwaysRebuild() &&
8210 QualifierLoc == E->getQualifierLoc() &&
8211 ND == E->getDecl() &&
8212 NameInfo.getName() == E->getDecl()->getDeclName() &&
8213 !E->hasExplicitTemplateArgs()) {
8217 SemaRef.MarkDeclRefReferenced(E);
8222 TemplateArgumentListInfo TransArgs, *TemplateArgs =
nullptr;
8223 if (E->hasExplicitTemplateArgs()) {
8224 TemplateArgs = &TransArgs;
8225 TransArgs.setLAngleLoc(E->getLAngleLoc());
8226 TransArgs.setRAngleLoc(E->getRAngleLoc());
8227 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
8228 E->getNumTemplateArgs(),
8233 return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo,
8237 template<
typename Derived>
8239 TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) {
8243 template<
typename Derived>
8245 TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) {
8249 template<
typename Derived>
8251 TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) {
8255 template<
typename Derived>
8257 TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) {
8261 template<
typename Derived>
8263 TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) {
8267 template<
typename Derived>
8269 TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) {
8270 if (FunctionDecl *FD = E->getDirectCallee())
8271 SemaRef.MarkFunctionReferenced(E->getLocStart(), FD);
8272 return SemaRef.MaybeBindToTemporary(E);
8275 template<
typename Derived>
8277 TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) {
8279 getDerived().TransformExpr(E->getControllingExpr());
8280 if (ControllingExpr.isInvalid())
8283 SmallVector<Expr *, 4> AssocExprs;
8284 SmallVector<TypeSourceInfo *, 4> AssocTypes;
8285 for (
unsigned i = 0; i != E->getNumAssocs(); ++i) {
8286 TypeSourceInfo *TS = E->getAssocTypeSourceInfo(i);
8288 TypeSourceInfo *AssocType = getDerived().TransformType(TS);
8291 AssocTypes.push_back(AssocType);
8293 AssocTypes.push_back(
nullptr);
8296 ExprResult AssocExpr = getDerived().TransformExpr(E->getAssocExpr(i));
8297 if (AssocExpr.isInvalid())
8299 AssocExprs.push_back(AssocExpr.get());
8302 return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(),
8305 ControllingExpr.get(),
8310 template<
typename Derived>
8312 TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
8313 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
8314 if (SubExpr.isInvalid())
8317 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
8320 return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(),
8327 template<
typename Derived>
8331 return getDerived().TransformDependentScopeDeclRefExpr(DRE,
true,
nullptr);
8333 return getDerived().TransformExpr(E);
8336 template<
typename Derived>
8341 SubExpr = TransformAddressOfOperand(E->
getSubExpr());
8347 if (!getDerived().AlwaysRebuild() && SubExpr.
get() == E->
getSubExpr())
8355 template<
typename Derived>
8357 TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) {
8359 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
8369 bool ExprChanged =
false;
8370 typedef Sema::OffsetOfComponent Component;
8371 SmallVector<Component, 4> Components;
8372 for (
unsigned I = 0, N = E->getNumComponents();
I != N; ++
I) {
8373 const OffsetOfNode &ON = E->getComponent(
I);
8375 Comp.isBrackets =
true;
8376 Comp.LocStart = ON.getSourceRange().getBegin();
8377 Comp.LocEnd = ON.getSourceRange().getEnd();
8378 switch (ON.getKind()) {
8380 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex());
8381 ExprResult Index = getDerived().TransformExpr(FromIndex);
8382 if (Index.isInvalid())
8385 ExprChanged = ExprChanged || Index.
get() != FromIndex;
8386 Comp.isBrackets =
true;
8387 Comp.U.E = Index.get();
8393 Comp.isBrackets =
false;
8394 Comp.U.IdentInfo = ON.getFieldName();
8395 if (!Comp.U.IdentInfo)
8405 Components.push_back(Comp);
8409 if (!getDerived().AlwaysRebuild() &&
8410 Type == E->getTypeSourceInfo() &&
8415 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type,
8416 Components, E->getRParenLoc());
8419 template<
typename Derived>
8421 TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) {
8422 assert((!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) &&
8423 "opaque value expression requires transformation");
8427 template<
typename Derived>
8429 TreeTransform<Derived>::TransformTypoExpr(TypoExpr *E) {
8433 template<
typename Derived>
8435 TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) {
8442 Expr *newSyntacticForm = SemaRef.recreateSyntacticForm(E);
8443 ExprResult result = getDerived().TransformExpr(newSyntacticForm);
8444 if (result.isInvalid())
return ExprError();
8449 if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject))
8450 result = SemaRef.checkPseudoObjectRValue(result.get());
8455 template<
typename Derived>
8457 TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr(
8458 UnaryExprOrTypeTraitExpr *E) {
8459 if (E->isArgumentType()) {
8460 TypeSourceInfo *OldT = E->getArgumentTypeInfo();
8462 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
8466 if (!getDerived().AlwaysRebuild() && OldT == NewT)
8469 return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(),
8471 E->getSourceRange());
8482 TypeSourceInfo *RecoveryTSI =
nullptr;
8484 auto *PE = dyn_cast<ParenExpr>(E->getArgumentExpr());
8486 PE ? dyn_cast<DependentScopeDeclRefExpr>(PE->getSubExpr()) :
nullptr)
8487 SubExpr = getDerived().TransformParenDependentScopeDeclRefExpr(
8488 PE, DRE,
false, &RecoveryTSI);
8490 SubExpr = getDerived().TransformExpr(E->getArgumentExpr());
8493 return getDerived().RebuildUnaryExprOrTypeTrait(
8494 RecoveryTSI, E->getOperatorLoc(), E->getKind(), E->getSourceRange());
8495 }
else if (SubExpr.isInvalid())
8498 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
8501 return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(),
8502 E->getOperatorLoc(),
8504 E->getSourceRange());
8507 template<
typename Derived>
8509 TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
8510 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
8511 if (LHS.isInvalid())
8514 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
8515 if (RHS.isInvalid())
8519 if (!getDerived().AlwaysRebuild() &&
8520 LHS.get() == E->getLHS() &&
8521 RHS.get() == E->getRHS())
8524 return getDerived().RebuildArraySubscriptExpr(LHS.get(),
8525 E->getLHS()->getLocStart(),
8527 E->getRBracketLoc());
8530 template <
typename Derived>
8532 TreeTransform<Derived>::TransformOMPArraySectionExpr(OMPArraySectionExpr *E) {
8533 ExprResult Base = getDerived().TransformExpr(E->getBase());
8534 if (Base.isInvalid())
8538 if (E->getLowerBound()) {
8539 LowerBound = getDerived().TransformExpr(E->getLowerBound());
8540 if (LowerBound.isInvalid())
8545 if (E->getLength()) {
8546 Length = getDerived().TransformExpr(E->getLength());
8547 if (Length.isInvalid())
8551 if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
8552 LowerBound.get() == E->getLowerBound() && Length.get() == E->getLength())
8555 return getDerived().RebuildOMPArraySectionExpr(
8556 Base.get(), E->getBase()->getLocEnd(), LowerBound.get(), E->getColonLoc(),
8557 Length.get(), E->getRBracketLoc());
8560 template<
typename Derived>
8562 TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
8564 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
8565 if (Callee.isInvalid())
8569 bool ArgChanged =
false;
8570 SmallVector<Expr*, 8> Args;
8571 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(),
true, Args,
8575 if (!getDerived().AlwaysRebuild() &&
8576 Callee.get() == E->getCallee() &&
8578 return SemaRef.MaybeBindToTemporary(E);
8581 SourceLocation FakeLParenLoc
8583 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
8588 template<
typename Derived>
8590 TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
8591 ExprResult Base = getDerived().TransformExpr(E->getBase());
8592 if (Base.isInvalid())
8595 NestedNameSpecifierLoc QualifierLoc;
8596 if (E->hasQualifier()) {
8598 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
8603 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
8606 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
8607 E->getMemberDecl()));
8611 NamedDecl *FoundDecl = E->getFoundDecl();
8612 if (FoundDecl == E->getMemberDecl()) {
8615 FoundDecl = cast_or_null<NamedDecl>(
8616 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl));
8621 if (!getDerived().AlwaysRebuild() &&
8622 Base.get() == E->getBase() &&
8623 QualifierLoc == E->getQualifierLoc() &&
8624 Member == E->getMemberDecl() &&
8625 FoundDecl == E->getFoundDecl() &&
8626 !E->hasExplicitTemplateArgs()) {
8630 SemaRef.MarkMemberReferenced(E);
8635 TemplateArgumentListInfo TransArgs;
8636 if (E->hasExplicitTemplateArgs()) {
8637 TransArgs.setLAngleLoc(E->getLAngleLoc());
8638 TransArgs.setRAngleLoc(E->getRAngleLoc());
8639 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
8640 E->getNumTemplateArgs(),
8646 SourceLocation FakeOperatorLoc =
8647 SemaRef.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd());
8653 NamedDecl *FirstQualifierInScope =
nullptr;
8655 return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc,
8659 E->getMemberNameInfo(),
8662 (E->hasExplicitTemplateArgs()
8663 ? &TransArgs :
nullptr),
8664 FirstQualifierInScope);
8667 template<
typename Derived>
8669 TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
8670 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
8671 if (LHS.isInvalid())
8674 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
8675 if (RHS.isInvalid())
8678 if (!getDerived().AlwaysRebuild() &&
8679 LHS.get() == E->getLHS() &&
8680 RHS.get() == E->getRHS())
8683 Sema::FPContractStateRAII FPContractState(getSema());
8684 getSema().FPFeatures.fp_contract = E->isFPContractable();
8686 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
8687 LHS.get(), RHS.get());
8690 template<
typename Derived>
8692 TreeTransform<Derived>::TransformCompoundAssignOperator(
8693 CompoundAssignOperator *E) {
8694 return getDerived().TransformBinaryOperator(E);
8697 template<
typename Derived>
8699 TransformBinaryConditionalOperator(BinaryConditionalOperator *e) {
8703 ExprResult commonExpr = getDerived().TransformExpr(e->getCommon());
8704 if (commonExpr.isInvalid())
8707 ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr());
8708 if (rhs.isInvalid())
8711 if (!getDerived().AlwaysRebuild() &&
8712 commonExpr.get() == e->getCommon() &&
8713 rhs.get() == e->getFalseExpr())
8716 return getDerived().RebuildConditionalOperator(commonExpr.get(),
8717 e->getQuestionLoc(),
8723 template<
typename Derived>
8725 TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) {
8726 ExprResult Cond = getDerived().TransformExpr(E->getCond());
8727 if (Cond.isInvalid())
8730 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
8731 if (LHS.isInvalid())
8734 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
8735 if (RHS.isInvalid())
8738 if (!getDerived().AlwaysRebuild() &&
8739 Cond.get() == E->getCond() &&
8740 LHS.get() == E->getLHS() &&
8741 RHS.get() == E->getRHS())
8744 return getDerived().RebuildConditionalOperator(Cond.get(),
8745 E->getQuestionLoc(),
8751 template<
typename Derived>
8753 TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) {
8756 return getDerived().TransformExpr(E->getSubExprAsWritten());
8759 template<
typename Derived>
8761 TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
8762 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
8767 = getDerived().TransformExpr(E->getSubExprAsWritten());
8768 if (SubExpr.isInvalid())
8771 if (!getDerived().AlwaysRebuild() &&
8772 Type == E->getTypeInfoAsWritten() &&
8773 SubExpr.get() == E->getSubExpr())
8776 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
8782 template<
typename Derived>
8784 TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) {
8785 TypeSourceInfo *OldT = E->getTypeSourceInfo();
8786 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
8790 ExprResult Init = getDerived().TransformExpr(E->getInitializer());
8791 if (Init.isInvalid())
8794 if (!getDerived().AlwaysRebuild() &&
8796 Init.get() == E->getInitializer())
8797 return SemaRef.MaybeBindToTemporary(E);
8803 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT,
8804 E->getInitializer()->getLocEnd(),
8808 template<
typename Derived>
8810 TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) {
8811 ExprResult Base = getDerived().TransformExpr(E->getBase());
8812 if (Base.isInvalid())
8815 if (!getDerived().AlwaysRebuild() &&
8816 Base.get() == E->getBase())
8820 SourceLocation FakeOperatorLoc =
8821 SemaRef.getLocForEndOfToken(E->getBase()->getLocEnd());
8822 return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc,
8823 E->getAccessorLoc(),
8827 template<
typename Derived>
8829 TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) {
8830 if (InitListExpr *Syntactic = E->getSyntacticForm())
8833 bool InitChanged =
false;
8835 SmallVector<Expr*, 4>
Inits;
8836 if (getDerived().TransformExprs(E->getInits(), E->getNumInits(),
false,
8837 Inits, &InitChanged))
8840 if (!getDerived().AlwaysRebuild() && !InitChanged) {
8847 return getDerived().RebuildInitList(E->getLBraceLoc(),
Inits,
8848 E->getRBraceLoc(), E->getType());
8851 template<
typename Derived>
8853 TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) {
8857 ExprResult Init = getDerived().TransformExpr(E->getInit());
8858 if (Init.isInvalid())
8862 SmallVector<Expr*, 4> ArrayExprs;
8863 bool ExprChanged =
false;
8864 for (
const DesignatedInitExpr::Designator &D : E->designators()) {
8865 if (D.isFieldDesignator()) {
8872 if (D.isArrayDesignator()) {
8873 ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(D));
8874 if (Index.isInvalid())
8877 Desig.AddDesignator(
8880 ExprChanged = ExprChanged || Init.
get() != E->getArrayIndex(D);
8881 ArrayExprs.push_back(Index.get());
8885 assert(D.isArrayRangeDesignator() &&
"New kind of designator?");
8887 = getDerived().TransformExpr(E->getArrayRangeStart(D));
8888 if (Start.isInvalid())
8891 ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(D));
8892 if (End.isInvalid())
8898 D.getEllipsisLoc()));
8900 ExprChanged = ExprChanged || Start.
get() != E->getArrayRangeStart(D) ||
8901 End.get() != E->getArrayRangeEnd(D);
8903 ArrayExprs.push_back(Start.get());
8904 ArrayExprs.push_back(End.get());
8907 if (!getDerived().AlwaysRebuild() &&
8908 Init.get() == E->getInit() &&
8912 return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs,
8913 E->getEqualOrColonLoc(),
8914 E->usesGNUSyntax(), Init.get());
8919 template<
typename Derived>
8921 TreeTransform<Derived>::TransformDesignatedInitUpdateExpr(
8922 DesignatedInitUpdateExpr *E) {
8923 llvm_unreachable(
"Unexpected DesignatedInitUpdateExpr in syntactic form of "
8928 template<
typename Derived>
8930 TreeTransform<Derived>::TransformNoInitExpr(
8932 llvm_unreachable(
"Unexpected NoInitExpr in syntactic form of initializer");
8936 template<
typename Derived>
8938 TreeTransform<Derived>::TransformImplicitValueInitExpr(
8939 ImplicitValueInitExpr *E) {
8940 TemporaryBase Rebase(*
this, E->getLocStart(), DeclarationName());
8944 QualType T = getDerived().TransformType(E->getType());
8948 if (!getDerived().AlwaysRebuild() &&
8952 return getDerived().RebuildImplicitValueInitExpr(T);
8955 template<
typename Derived>
8957 TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) {
8958 TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo());
8962 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
8963 if (SubExpr.isInvalid())
8966 if (!getDerived().AlwaysRebuild() &&
8967 TInfo == E->getWrittenTypeInfo() &&
8968 SubExpr.get() == E->getSubExpr())
8971 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(),
8972 TInfo, E->getRParenLoc());
8975 template<
typename Derived>
8977 TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) {
8978 bool ArgumentChanged =
false;
8979 SmallVector<Expr*, 4>
Inits;
8980 if (TransformExprs(E->getExprs(), E->getNumExprs(),
true,
Inits,
8984 return getDerived().RebuildParenListExpr(E->getLParenLoc(),
8994 template<
typename Derived>
8996 TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) {
8997 Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(),
9002 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
9003 cast<LabelDecl>(LD));
9006 template<
typename Derived>
9008 TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) {
9009 SemaRef.ActOnStartStmtExpr();
9011 = getDerived().TransformCompoundStmt(E->getSubStmt(),
true);
9012 if (SubStmt.isInvalid()) {
9013 SemaRef.ActOnStmtExprError();
9017 if (!getDerived().AlwaysRebuild() &&
9018 SubStmt.get() == E->getSubStmt()) {
9020 SemaRef.ActOnStmtExprError();
9021 return SemaRef.MaybeBindToTemporary(E);
9024 return getDerived().RebuildStmtExpr(E->getLParenLoc(),
9029 template<
typename Derived>
9031 TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) {
9032 ExprResult Cond = getDerived().TransformExpr(E->getCond());
9033 if (Cond.isInvalid())
9036 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
9037 if (LHS.isInvalid())
9040 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
9041 if (RHS.isInvalid())
9044 if (!getDerived().AlwaysRebuild() &&
9045 Cond.get() == E->getCond() &&
9046 LHS.get() == E->getLHS() &&
9047 RHS.get() == E->getRHS())
9050 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(),
9051 Cond.get(), LHS.get(), RHS.get(),
9055 template<
typename Derived>
9057 TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) {
9061 template<
typename Derived>
9063 TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
9064 switch (E->getOperator()) {
9068 case OO_Array_Delete:
9069 llvm_unreachable(
"new and delete operators cannot use CXXOperatorCallExpr");
9073 assert(E->getNumArgs() >= 1 &&
"Object call is missing arguments");
9076 ExprResult Object = getDerived().TransformExpr(E->getArg(0));
9077 if (Object.isInvalid())
9081 SourceLocation FakeLParenLoc = SemaRef.getLocForEndOfToken(
9082 static_cast<Expr *>(Object.get())->getLocEnd());
9085 SmallVector<Expr*, 8> Args;
9086 if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1,
true,
9090 return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc,
9095 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
9097 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
9098 #include "clang/Basic/OperatorKinds.def"
9103 case OO_Conditional:
9104 llvm_unreachable(
"conditional operator is not actually overloadable");
9108 llvm_unreachable(
"not an overloaded operator?");
9111 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
9112 if (Callee.isInvalid())
9116 if (E->getOperator() == OO_Amp)
9117 First = getDerived().TransformAddressOfOperand(E->getArg(0));
9119 First = getDerived().TransformExpr(E->getArg(0));
9120 if (First.isInvalid())
9124 if (E->getNumArgs() == 2) {
9125 Second = getDerived().TransformExpr(E->getArg(1));
9126 if (Second.isInvalid())
9130 if (!getDerived().AlwaysRebuild() &&
9131 Callee.get() == E->getCallee() &&
9132 First.get() == E->getArg(0) &&
9133 (E->getNumArgs() != 2 || Second.get() == E->getArg(1)))
9134 return SemaRef.MaybeBindToTemporary(E);
9136 Sema::FPContractStateRAII FPContractState(getSema());
9137 getSema().FPFeatures.fp_contract = E->isFPContractable();
9139 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(),
9140 E->getOperatorLoc(),
9146 template<
typename Derived>
9148 TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) {
9149 return getDerived().TransformCallExpr(E);
9152 template<
typename Derived>
9154 TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
9156 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
9157 if (Callee.isInvalid())
9161 ExprResult EC = getDerived().TransformCallExpr(E->getConfig());
9166 bool ArgChanged =
false;
9167 SmallVector<Expr*, 8> Args;
9168 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(),
true, Args,
9172 if (!getDerived().AlwaysRebuild() &&
9173 Callee.get() == E->getCallee() &&
9175 return SemaRef.MaybeBindToTemporary(E);
9178 SourceLocation FakeLParenLoc
9180 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
9182 E->getRParenLoc(), EC.get());
9185 template<
typename Derived>
9197 if (!getDerived().AlwaysRebuild() &&
9201 return getDerived().RebuildCXXNamedCastExpr(
9208 template<
typename Derived>
9214 template<
typename Derived>
9216 TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
9217 return getDerived().TransformCXXNamedCastExpr(E);
9220 template<
typename Derived>
9222 TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
9223 CXXReinterpretCastExpr *E) {
9224 return getDerived().TransformCXXNamedCastExpr(E);
9227 template<
typename Derived>
9229 TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) {
9230 return getDerived().TransformCXXNamedCastExpr(E);
9233 template<
typename Derived>
9235 TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
9236 CXXFunctionalCastExpr *E) {
9237 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
9242 = getDerived().TransformExpr(E->getSubExprAsWritten());
9243 if (SubExpr.isInvalid())
9246 if (!getDerived().AlwaysRebuild() &&
9247 Type == E->getTypeInfoAsWritten() &&
9248 SubExpr.get() == E->getSubExpr())
9251 return getDerived().RebuildCXXFunctionalCastExpr(Type,
9257 template<
typename Derived>
9259 TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) {
9260 if (E->isTypeOperand()) {
9261 TypeSourceInfo *TInfo
9262 = getDerived().TransformType(E->getTypeOperandSourceInfo());
9266 if (!getDerived().AlwaysRebuild() &&
9267 TInfo == E->getTypeOperandSourceInfo())
9270 return getDerived().RebuildCXXTypeidExpr(E->getType(),
9283 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
9284 if (SubExpr.isInvalid())
9287 if (!getDerived().AlwaysRebuild() &&
9288 SubExpr.get() == E->getExprOperand())
9291 return getDerived().RebuildCXXTypeidExpr(E->getType(),
9297 template<
typename Derived>
9299 TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) {
9300 if (E->isTypeOperand()) {
9301 TypeSourceInfo *TInfo
9302 = getDerived().TransformType(E->getTypeOperandSourceInfo());
9306 if (!getDerived().AlwaysRebuild() &&
9307 TInfo == E->getTypeOperandSourceInfo())
9310 return getDerived().RebuildCXXUuidofExpr(E->getType(),
9318 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
9319 if (SubExpr.isInvalid())
9322 if (!getDerived().AlwaysRebuild() &&
9323 SubExpr.get() == E->getExprOperand())
9326 return getDerived().RebuildCXXUuidofExpr(E->getType(),
9332 template<
typename Derived>
9334 TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
9338 template<
typename Derived>
9340 TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
9341 CXXNullPtrLiteralExpr *E) {
9345 template<
typename Derived>
9347 TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) {
9348 QualType T = getSema().getCurrentThisType();
9350 if (!getDerived().AlwaysRebuild() && T == E->getType()) {
9352 getSema().CheckCXXThisCapture(E->getLocStart());
9356 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit());
9359 template<
typename Derived>
9361 TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) {
9362 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
9363 if (SubExpr.isInvalid())
9366 if (!getDerived().AlwaysRebuild() &&
9367 SubExpr.get() == E->getSubExpr())
9370 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(),
9371 E->isThrownVariableInScope());
9374 template<
typename Derived>
9376 TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
9378 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(),
9383 if (!getDerived().AlwaysRebuild() &&
9384 Param == E->getParam())
9387 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param);
9390 template<
typename Derived>
9392 TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
9394 = cast_or_null<FieldDecl>(getDerived().TransformDecl(E->getLocStart(),
9399 if (!getDerived().AlwaysRebuild() && Field == E->getField())
9402 return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field);
9405 template<
typename Derived>
9407 TreeTransform<Derived>::TransformCXXScalarValueInitExpr(
9408 CXXScalarValueInitExpr *E) {
9409 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
9413 if (!getDerived().AlwaysRebuild() &&
9414 T == E->getTypeSourceInfo())
9417 return getDerived().RebuildCXXScalarValueInitExpr(T,
9418 T->getTypeLoc().getEndLoc(),
9422 template<
typename Derived>
9424 TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) {
9426 TypeSourceInfo *AllocTypeInfo
9427 = getDerived().TransformType(E->getAllocatedTypeSourceInfo());
9432 ExprResult ArraySize = getDerived().TransformExpr(E->getArraySize());
9433 if (ArraySize.isInvalid())
9437 bool ArgumentChanged =
false;
9438 SmallVector<Expr*, 8> PlacementArgs;
9439 if (getDerived().TransformExprs(E->getPlacementArgs(),
9440 E->getNumPlacementArgs(),
true,
9441 PlacementArgs, &ArgumentChanged))
9445 Expr *OldInit = E->getInitializer();
9448 NewInit = getDerived().TransformInitializer(OldInit,
true);
9449 if (NewInit.isInvalid())
9453 FunctionDecl *OperatorNew =
nullptr;
9454 if (E->getOperatorNew()) {
9455 OperatorNew = cast_or_null<FunctionDecl>(
9456 getDerived().TransformDecl(E->getLocStart(),
9457 E->getOperatorNew()));
9462 FunctionDecl *OperatorDelete =
nullptr;
9463 if (E->getOperatorDelete()) {
9464 OperatorDelete = cast_or_null<FunctionDecl>(
9465 getDerived().TransformDecl(E->getLocStart(),
9466 E->getOperatorDelete()));
9467 if (!OperatorDelete)
9471 if (!getDerived().AlwaysRebuild() &&
9472 AllocTypeInfo == E->getAllocatedTypeSourceInfo() &&
9473 ArraySize.get() == E->getArraySize() &&
9474 NewInit.get() == OldInit &&
9475 OperatorNew == E->getOperatorNew() &&
9476 OperatorDelete == E->getOperatorDelete() &&
9481 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorNew);
9483 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete);
9485 if (E->isArray() && !E->getAllocatedType()->isDependentType()) {
9486 QualType ElementType
9487 = SemaRef.Context.getBaseElementType(E->getAllocatedType());
9488 if (
const RecordType *RecordT = ElementType->getAs<RecordType>()) {
9489 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordT->getDecl());
9490 if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(Record)) {
9491 SemaRef.MarkFunctionReferenced(E->getLocStart(),
Destructor);
9499 QualType AllocType = AllocTypeInfo->getType();
9500 if (!ArraySize.get()) {
9506 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType);
9509 }
else if (
const ConstantArrayType *ConsArrayT
9510 = dyn_cast<ConstantArrayType>(ArrayT)) {
9512 SemaRef.Context.getSizeType(),
9514 AllocType = ConsArrayT->getElementType();
9515 }
else if (
const DependentSizedArrayType *DepArrayT
9516 = dyn_cast<DependentSizedArrayType>(ArrayT)) {
9517 if (DepArrayT->getSizeExpr()) {
9518 ArraySize = DepArrayT->getSizeExpr();
9519 AllocType = DepArrayT->getElementType();
9524 return getDerived().RebuildCXXNewExpr(E->getLocStart(),
9529 E->getTypeIdParens(),
9533 E->getDirectInitRange(),
9537 template<
typename Derived>
9539 TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) {
9540 ExprResult Operand = getDerived().TransformExpr(E->getArgument());
9541 if (Operand.isInvalid())
9545 FunctionDecl *OperatorDelete =
nullptr;
9546 if (E->getOperatorDelete()) {
9547 OperatorDelete = cast_or_null<FunctionDecl>(
9548 getDerived().TransformDecl(E->getLocStart(),
9549 E->getOperatorDelete()));
9550 if (!OperatorDelete)
9554 if (!getDerived().AlwaysRebuild() &&
9555 Operand.get() == E->getArgument() &&
9556 OperatorDelete == E->getOperatorDelete()) {
9560 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete);
9562 if (!E->getArgument()->isTypeDependent()) {
9563 QualType Destroyed = SemaRef.Context.getBaseElementType(
9564 E->getDestroyedType());
9565 if (
const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
9566 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
9567 SemaRef.MarkFunctionReferenced(E->getLocStart(),
9568 SemaRef.LookupDestructor(Record));
9575 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(),
9576 E->isGlobalDelete(),
9581 template<
typename Derived>
9583 TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
9584 CXXPseudoDestructorExpr *E) {
9585 ExprResult Base = getDerived().TransformExpr(E->getBase());
9586 if (Base.isInvalid())
9590 bool MayBePseudoDestructor =
false;
9591 Base = SemaRef.ActOnStartCXXMemberReference(
nullptr, Base.get(),
9592 E->getOperatorLoc(),
9593 E->isArrow()? tok::arrow : tok::period,
9595 MayBePseudoDestructor);
9596 if (Base.isInvalid())
9599 QualType ObjectType = ObjectTypePtr.
get();
9600 NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc();
9603 = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType);
9608 SS.Adopt(QualifierLoc);
9610 PseudoDestructorTypeStorage Destroyed;
9611 if (E->getDestroyedTypeInfo()) {
9612 TypeSourceInfo *DestroyedTypeInfo
9613 = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(),
9614 ObjectType,
nullptr, SS);
9615 if (!DestroyedTypeInfo)
9617 Destroyed = DestroyedTypeInfo;
9618 }
else if (!ObjectType.isNull() && ObjectType->isDependentType()) {
9621 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(),
9622 E->getDestroyedTypeLoc());
9625 ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(),
9626 *E->getDestroyedTypeIdentifier(),
9627 E->getDestroyedTypeLoc(),
9635 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T),
9636 E->getDestroyedTypeLoc());
9639 TypeSourceInfo *ScopeTypeInfo =
nullptr;
9640 if (E->getScopeTypeInfo()) {
9641 CXXScopeSpec EmptySS;
9642 ScopeTypeInfo = getDerived().TransformTypeInObjectScope(
9643 E->getScopeTypeInfo(), ObjectType,
nullptr, EmptySS);
9648 return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(),
9649 E->getOperatorLoc(),
9653 E->getColonColonLoc(),
9658 template<
typename Derived>
9660 TreeTransform<Derived>::TransformUnresolvedLookupExpr(
9661 UnresolvedLookupExpr *Old) {
9662 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(),
9667 E = Old->decls_end();
I !=
E; ++
I) {
9668 NamedDecl *InstD =
static_cast<NamedDecl*
>(
9669 getDerived().TransformDecl(Old->getNameLoc(),
9674 if (isa<UsingShadowDecl>(*
I))
9683 if (isa<UsingDecl>(InstD)) {
9684 UsingDecl *UD = cast<UsingDecl>(InstD);
9685 for (
auto *
I : UD->shadows())
9699 if (Old->getQualifierLoc()) {
9700 NestedNameSpecifierLoc QualifierLoc
9701 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
9705 SS.Adopt(QualifierLoc);
9708 if (Old->getNamingClass()) {
9709 CXXRecordDecl *NamingClass
9710 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
9712 Old->getNamingClass()));
9718 R.setNamingClass(NamingClass);
9721 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
9725 if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid()) {
9726 NamedDecl *D = R.getAsSingle<NamedDecl>();
9730 if (D && D->isCXXInstanceMember()) {
9731 return SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, R,
9736 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL());
9741 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc());
9742 if (Old->hasExplicitTemplateArgs() &&
9743 getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
9744 Old->getNumTemplateArgs(),
9750 return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R,
9751 Old->requiresADL(), &TransArgs);
9754 template<
typename Derived>
9756 TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) {
9757 bool ArgChanged =
false;
9758 SmallVector<TypeSourceInfo *, 4> Args;
9759 for (
unsigned I = 0, N = E->getNumArgs();
I != N; ++
I) {
9760 TypeSourceInfo *From = E->getArg(
I);
9761 TypeLoc FromTL = From->getTypeLoc();
9762 if (!FromTL.getAs<PackExpansionTypeLoc>()) {
9764 TLB.reserve(FromTL.getFullDataSize());
9765 QualType To = getDerived().TransformType(TLB, FromTL);
9769 if (To == From->getType())
9770 Args.push_back(From);
9772 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
9781 PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>();
9782 TypeLoc PatternTL = ExpansionTL.getPatternLoc();
9783 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
9784 SemaRef.collectUnexpandedParameterPacks(PatternTL, Unexpanded);
9789 bool RetainExpansion =
false;
9790 Optional<unsigned> OrigNumExpansions =
9791 ExpansionTL.getTypePtr()->getNumExpansions();
9792 Optional<unsigned> NumExpansions = OrigNumExpansions;
9793 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
9794 PatternTL.getSourceRange(),
9796 Expand, RetainExpansion,
9804 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
9807 TLB.reserve(From->getTypeLoc().getFullDataSize());
9809 QualType To = getDerived().TransformType(TLB, PatternTL);
9813 To = getDerived().RebuildPackExpansionType(To,
9814 PatternTL.getSourceRange(),
9815 ExpansionTL.getEllipsisLoc(),
9820 PackExpansionTypeLoc ToExpansionTL
9821 = TLB.push<PackExpansionTypeLoc>(To);
9822 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
9823 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
9829 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
9830 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef,
I);
9832 TLB.reserve(PatternTL.getFullDataSize());
9833 QualType To = getDerived().TransformType(TLB, PatternTL);
9837 if (To->containsUnexpandedParameterPack()) {
9838 To = getDerived().RebuildPackExpansionType(To,
9839 PatternTL.getSourceRange(),
9840 ExpansionTL.getEllipsisLoc(),
9845 PackExpansionTypeLoc ToExpansionTL
9846 = TLB.push<PackExpansionTypeLoc>(To);
9847 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
9850 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
9853 if (!RetainExpansion)
9858 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
9861 TLB.reserve(From->getTypeLoc().getFullDataSize());
9863 QualType To = getDerived().TransformType(TLB, PatternTL);
9867 To = getDerived().RebuildPackExpansionType(To,
9868 PatternTL.getSourceRange(),
9869 ExpansionTL.getEllipsisLoc(),
9874 PackExpansionTypeLoc ToExpansionTL
9875 = TLB.push<PackExpansionTypeLoc>(To);
9876 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
9877 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
9880 if (!getDerived().AlwaysRebuild() && !ArgChanged)
9883 return getDerived().RebuildTypeTrait(E->getTrait(),
9889 template<
typename Derived>
9891 TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
9892 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo());
9896 if (!getDerived().AlwaysRebuild() &&
9897 T == E->getQueriedTypeSourceInfo())
9903 SubExpr = getDerived().TransformExpr(E->getDimensionExpression());
9904 if (SubExpr.isInvalid())
9907 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getDimensionExpression())
9911 return getDerived().RebuildArrayTypeTrait(E->getTrait(),
9918 template<
typename Derived>
9920 TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) {
9924 SubExpr = getDerived().TransformExpr(E->getQueriedExpression());
9925 if (SubExpr.isInvalid())
9928 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression())
9932 return getDerived().RebuildExpressionTrait(
9933 E->getTrait(), E->getLocStart(), SubExpr.get(), E->getLocEnd());
9936 template <
typename Derived>
9940 ExprResult NewDRE = getDerived().TransformDependentScopeDeclRefExpr(
9941 DRE, AddrTaken, RecoveryTSI);
9948 if (!getDerived().AlwaysRebuild() && NewDRE.
get() == DRE)
9950 return getDerived().RebuildParenExpr(NewDRE.
get(), PE->
getLParen(),
9954 template <
typename Derived>
9957 return TransformDependentScopeDeclRefExpr(E,
false,
9961 template<
typename Derived>
9965 bool IsAddressOfOperand,
9979 = getDerived().TransformDeclarationNameInfo(E->
getNameInfo());
9984 if (!getDerived().AlwaysRebuild() &&
9991 return getDerived().RebuildDependentScopeDeclRefExpr(
9992 QualifierLoc, TemplateKWLoc, NameInfo,
nullptr,
9993 IsAddressOfOperand, RecoveryTSI);
10002 return getDerived().RebuildDependentScopeDeclRefExpr(
10003 QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand,
10007 template<
typename Derived>
10009 TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) {
10013 if ((E->getNumArgs() == 1 ||
10014 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) &&
10015 (!getDerived().DropCallArgument(E->getArg(0))) &&
10016 !E->isListInitialization())
10017 return getDerived().TransformExpr(E->getArg(0));
10019 TemporaryBase Rebase(*
this, E->getLocStart(), DeclarationName());
10021 QualType T = getDerived().TransformType(E->getType());
10026 = cast_or_null<CXXConstructorDecl>(
10027 getDerived().TransformDecl(E->getLocStart(),
10028 E->getConstructor()));
10032 bool ArgumentChanged =
false;
10033 SmallVector<Expr*, 8> Args;
10034 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(),
true, Args,
10038 if (!getDerived().AlwaysRebuild() &&
10039 T == E->getType() &&
10040 Constructor == E->getConstructor() &&
10041 !ArgumentChanged) {
10044 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor);
10048 return getDerived().RebuildCXXConstructExpr(T, E->getLocStart(),
10050 E->isElidable(), Args,
10051 E->hadMultipleCandidates(),
10052 E->isListInitialization(),
10053 E->isStdInitListInitialization(),
10054 E->requiresZeroInitialization(),
10055 E->getConstructionKind(),
10056 E->getParenOrBraceRange());
10059 template<
typename Derived>
10060 ExprResult TreeTransform<Derived>::TransformCXXInheritedCtorInitExpr(
10061 CXXInheritedCtorInitExpr *E) {
10062 QualType T = getDerived().TransformType(E->getType());
10066 CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
10067 getDerived().TransformDecl(E->getLocStart(), E->getConstructor()));
10071 if (!getDerived().AlwaysRebuild() &&
10072 T == E->getType() &&
10073 Constructor == E->getConstructor()) {
10076 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor);
10080 return getDerived().RebuildCXXInheritedCtorInitExpr(
10081 T, E->getLocation(), Constructor,
10082 E->constructsVBase(), E->inheritedFromVBase());
10089 template<
typename Derived>
10091 TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
10092 return getDerived().TransformExpr(E->getSubExpr());
10100 template<
typename Derived>
10102 TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) {
10103 return getDerived().TransformExpr(E->getSubExpr());
10106 template<
typename Derived>
10108 TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
10109 CXXTemporaryObjectExpr *E) {
10110 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
10114 CXXConstructorDecl *Constructor
10115 = cast_or_null<CXXConstructorDecl>(
10116 getDerived().TransformDecl(E->getLocStart(),
10117 E->getConstructor()));
10121 bool ArgumentChanged =
false;
10122 SmallVector<Expr*, 8> Args;
10123 Args.reserve(E->getNumArgs());
10124 if (TransformExprs(E->getArgs(), E->getNumArgs(),
true, Args,
10128 if (!getDerived().AlwaysRebuild() &&
10129 T == E->getTypeSourceInfo() &&
10130 Constructor == E->getConstructor() &&
10131 !ArgumentChanged) {
10133 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor);
10134 return SemaRef.MaybeBindToTemporary(E);
10138 return getDerived().RebuildCXXTemporaryObjectExpr(T,
10139 T->getTypeLoc().getEndLoc(),
10144 template<
typename Derived>
10146 TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
10149 typedef std::pair<ExprResult, QualType> InitCaptureInfoTy;
10150 SmallVector<InitCaptureInfoTy, 8> InitCaptureExprsAndTypes;
10151 InitCaptureExprsAndTypes.resize(E->explicit_capture_end() -
10152 E->explicit_capture_begin());
10154 CEnd = E->capture_end();
10156 if (!E->isInitCapture(C))
10158 EnterExpressionEvaluationContext EEEC(getSema(),
10160 ExprResult NewExprInitResult = getDerived().TransformInitializer(
10161 C->getCapturedVar()->getInit(),
10164 if (NewExprInitResult.isInvalid())
10166 Expr *NewExprInit = NewExprInitResult.
get();
10168 VarDecl *OldVD = C->getCapturedVar();
10169 QualType NewInitCaptureType =
10170 getSema().buildLambdaInitCaptureInitialization(
10171 C->getLocation(), OldVD->getType()->isReferenceType(),
10172 OldVD->getIdentifier(),
10173 C->getCapturedVar()->getInitStyle() !=
VarDecl::CInit, NewExprInit);
10174 NewExprInitResult = NewExprInit;
10175 InitCaptureExprsAndTypes[C - E->capture_begin()] =
10176 std::make_pair(NewExprInitResult, NewInitCaptureType);
10181 auto TPL = getDerived().TransformTemplateParameterList(
10182 E->getTemplateParameterList());
10188 TypeSourceInfo *NewCallOpTSI =
nullptr;
10190 TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo();
10191 FunctionProtoTypeLoc OldCallOpFPTL =
10192 OldCallOpTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>();
10194 TypeLocBuilder NewCallOpTLBuilder;
10195 SmallVector<QualType, 4> ExceptionStorage;
10196 TreeTransform *This =
this;
10197 QualType NewCallOpType = TransformFunctionProtoType(
10198 NewCallOpTLBuilder, OldCallOpFPTL,
nullptr, 0,
10199 [&](FunctionProtoType::ExceptionSpecInfo &ESI,
bool &Changed) {
10200 return This->TransformExceptionSpec(OldCallOpFPTL.getBeginLoc(), ESI,
10201 ExceptionStorage, Changed);
10203 if (NewCallOpType.isNull())
10205 NewCallOpTSI = NewCallOpTLBuilder.getTypeSourceInfo(getSema().
Context,
10209 LambdaScopeInfo *LSI = getSema().PushLambdaScope();
10210 Sema::FunctionScopeRAII FuncScopeCleanup(getSema());
10211 LSI->GLTemplateParameterList = TPL;
10214 CXXRecordDecl *
Class
10215 = getSema().createLambdaClosureType(E->getIntroducerRange(),
10218 E->getCaptureDefault());
10219 getDerived().transformedLocalDecl(E->getLambdaClass(), Class);
10222 CXXMethodDecl *NewCallOperator = getSema().startLambdaDefinition(
10223 Class, E->getIntroducerRange(), NewCallOpTSI,
10224 E->getCallOperator()->getLocEnd(),
10225 NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams());
10226 LSI->CallOperator = NewCallOperator;
10228 getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
10229 getDerived().transformedLocalDecl(E->getCallOperator(), NewCallOperator);
10232 Sema::ContextRAII SavedContext(getSema(), NewCallOperator,
10236 getSema().buildLambdaScope(LSI, NewCallOperator,
10237 E->getIntroducerRange(),
10238 E->getCaptureDefault(),
10239 E->getCaptureDefaultLoc(),
10240 E->hasExplicitParameters(),
10241 E->hasExplicitResultType(),
10247 bool FinishedExplicitCaptures =
false;
10249 CEnd = E->capture_end();
10253 if (!FinishedExplicitCaptures && C->isImplicit()) {
10254 getSema().finishLambdaExplicitCaptures(LSI);
10255 FinishedExplicitCaptures =
true;
10259 if (C->capturesThis()) {
10260 getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(),
10267 if (C->capturesVLAType())
10271 if (E->isInitCapture(C)) {
10272 InitCaptureInfoTy InitExprTypePair =
10273 InitCaptureExprsAndTypes[C - E->capture_begin()];
10275 QualType InitQualType = InitExprTypePair.second;
10276 if (Init.isInvalid() || InitQualType.isNull()) {
10280 VarDecl *OldVD = C->getCapturedVar();
10281 VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl(
10282 OldVD->getLocation(), InitExprTypePair.second, OldVD->getIdentifier(),
10283 OldVD->getInitStyle(), Init.get());
10287 getDerived().transformedLocalDecl(OldVD, NewVD);
10289 getSema().buildInitCaptureField(LSI, NewVD);
10293 assert(C->capturesVariable() &&
"unexpected kind of lambda capture");
10301 SourceLocation EllipsisLoc;
10302 if (C->isPackExpansion()) {
10304 bool ShouldExpand =
false;
10305 bool RetainExpansion =
false;
10306 Optional<unsigned> NumExpansions;
10307 if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(),
10310 ShouldExpand, RetainExpansion,
10316 if (ShouldExpand) {
10320 VarDecl *Pack = C->getCapturedVar();
10321 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
10322 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(),
I);
10323 VarDecl *CapturedVar
10324 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
10326 if (!CapturedVar) {
10332 getSema().tryCaptureVariable(CapturedVar, C->getLocation(),
Kind);
10340 EllipsisLoc = C->getEllipsisLoc();
10344 VarDecl *CapturedVar
10345 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
10346 C->getCapturedVar()));
10347 if (!CapturedVar || CapturedVar->isInvalidDecl()) {
10353 getSema().tryCaptureVariable(CapturedVar, C->getLocation(),
Kind,
10356 if (!FinishedExplicitCaptures)
10357 getSema().finishLambdaExplicitCaptures(LSI);
10365 Invalid ?
StmtError() : getDerived().TransformStmt(E->getBody());
10368 FuncScopeCleanup.disable();
10370 if (Body.isInvalid()) {
10371 SavedContext.pop();
10372 getSema().ActOnLambdaError(E->getLocStart(),
nullptr,
10380 auto LSICopy = *LSI;
10381 getSema().ActOnFinishFunctionBody(NewCallOperator, Body.get(),
10383 SavedContext.pop();
10385 return getSema().BuildLambdaExpr(E->getLocStart(), Body.get()->getLocEnd(),
10389 template<
typename Derived>
10391 TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
10392 CXXUnresolvedConstructExpr *E) {
10393 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
10397 bool ArgumentChanged =
false;
10398 SmallVector<Expr*, 8> Args;
10399 Args.reserve(E->arg_size());
10400 if (getDerived().TransformExprs(E->arg_begin(), E->arg_size(),
true, Args,
10404 if (!getDerived().AlwaysRebuild() &&
10405 T == E->getTypeSourceInfo() &&
10410 return getDerived().RebuildCXXUnresolvedConstructExpr(T,
10413 E->getRParenLoc());
10416 template<
typename Derived>
10418 TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
10419 CXXDependentScopeMemberExpr *E) {
10424 QualType ObjectType;
10425 if (!E->isImplicitAccess()) {
10426 OldBase = E->getBase();
10427 Base = getDerived().TransformExpr(OldBase);
10428 if (Base.isInvalid())
10433 bool MayBePseudoDestructor =
false;
10434 Base = SemaRef.ActOnStartCXXMemberReference(
nullptr, Base.get(),
10435 E->getOperatorLoc(),
10436 E->isArrow()? tok::arrow : tok::period,
10438 MayBePseudoDestructor);
10439 if (Base.isInvalid())
10442 ObjectType = ObjectTy.
get();
10443 BaseType = ((Expr*) Base.get())->getType();
10446 BaseType = getDerived().TransformType(E->getBaseType());
10447 ObjectType = BaseType->getAs<PointerType>()->getPointeeType();
10452 NamedDecl *FirstQualifierInScope
10453 = getDerived().TransformFirstQualifierInScope(
10454 E->getFirstQualifierFoundInScope(),
10455 E->getQualifierLoc().getBeginLoc());
10457 NestedNameSpecifierLoc QualifierLoc;
10458 if (E->getQualifier()) {
10460 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(),
10462 FirstQualifierInScope);
10467 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
10473 DeclarationNameInfo NameInfo
10474 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo());
10475 if (!NameInfo.getName())
10478 if (!E->hasExplicitTemplateArgs()) {
10481 if (!getDerived().AlwaysRebuild() &&
10482 Base.get() == OldBase &&
10483 BaseType == E->getBaseType() &&
10484 QualifierLoc == E->getQualifierLoc() &&
10485 NameInfo.getName() == E->getMember() &&
10486 FirstQualifierInScope == E->getFirstQualifierFoundInScope())
10489 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
10492 E->getOperatorLoc(),
10495 FirstQualifierInScope,
10500 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
10501 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
10502 E->getNumTemplateArgs(),
10506 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
10509 E->getOperatorLoc(),
10512 FirstQualifierInScope,
10517 template<
typename Derived>
10519 TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) {
10523 if (!Old->isImplicitAccess()) {
10524 Base = getDerived().TransformExpr(Old->getBase());
10525 if (Base.isInvalid())
10527 Base = getSema().PerformMemberExprBaseConversion(Base.get(),
10529 if (Base.isInvalid())
10533 BaseType = getDerived().TransformType(Old->getBaseType());
10536 NestedNameSpecifierLoc QualifierLoc;
10537 if (Old->getQualifierLoc()) {
10539 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
10544 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
10546 LookupResult R(SemaRef, Old->getMemberNameInfo(),
10551 E = Old->decls_end();
I !=
E; ++
I) {
10552 NamedDecl *InstD =
static_cast<NamedDecl*
>(
10553 getDerived().TransformDecl(Old->getMemberLoc(),
10558 if (isa<UsingShadowDecl>(*
I))
10567 if (isa<UsingDecl>(InstD)) {
10568 UsingDecl *UD = cast<UsingDecl>(InstD);
10569 for (
auto *
I : UD->shadows())
10580 if (Old->getNamingClass()) {
10581 CXXRecordDecl *NamingClass
10582 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
10583 Old->getMemberLoc(),
10584 Old->getNamingClass()));
10588 R.setNamingClass(NamingClass);
10591 TemplateArgumentListInfo TransArgs;
10592 if (Old->hasExplicitTemplateArgs()) {
10593 TransArgs.setLAngleLoc(Old->getLAngleLoc());
10594 TransArgs.setRAngleLoc(Old->getRAngleLoc());
10595 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
10596 Old->getNumTemplateArgs(),
10605 NamedDecl *FirstQualifierInScope =
nullptr;
10607 return getDerived().RebuildUnresolvedMemberExpr(Base.get(),
10609 Old->getOperatorLoc(),
10613 FirstQualifierInScope,
10615 (Old->hasExplicitTemplateArgs()
10616 ? &TransArgs :
nullptr));
10619 template<
typename Derived>
10621 TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) {
10623 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand());
10624 if (SubExpr.isInvalid())
10627 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand())
10630 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get());
10633 template<
typename Derived>
10635 TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) {
10636 ExprResult Pattern = getDerived().TransformExpr(E->getPattern());
10637 if (Pattern.isInvalid())
10640 if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern())
10643 return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(),
10644 E->getNumExpansions());
10647 template<
typename Derived>
10649 TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) {
10652 if (!E->isValueDependent())
10657 ArrayRef<TemplateArgument> PackArgs;
10658 TemplateArgument ArgStorage;
10661 if (E->isPartiallySubstituted()) {
10662 PackArgs = E->getPartialArguments();
10663 }
else if (E->isValueDependent()) {
10665 bool ShouldExpand =
false;
10666 bool RetainExpansion =
false;
10667 Optional<unsigned> NumExpansions;
10668 if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(),
10670 ShouldExpand, RetainExpansion,
10676 if (ShouldExpand) {
10677 auto *Pack = E->getPack();
10678 if (
auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Pack)) {
10679 ArgStorage = getSema().Context.getPackExpansionType(
10681 }
else if (
auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Pack)) {
10682 ArgStorage = TemplateArgument(TemplateName(TTPD), None);
10684 auto *VD = cast<ValueDecl>(Pack);
10685 ExprResult DRE = getSema().BuildDeclRefExpr(VD, VD->getType(),
10687 if (DRE.isInvalid())
10689 ArgStorage =
new (getSema().Context) PackExpansionExpr(
10690 getSema().Context.DependentTy, DRE.get(), E->getPackLoc(),
None);
10692 PackArgs = ArgStorage;
10697 if (!PackArgs.size()) {
10698 auto *Pack = cast_or_null<NamedDecl>(
10699 getDerived().TransformDecl(E->getPackLoc(), E->getPack()));
10702 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), Pack,
10707 TemplateArgumentListInfo TransformedPackArgs(E->getPackLoc(),
10710 TemporaryBase Rebase(*
this, E->getPackLoc(), getBaseEntity());
10711 typedef TemplateArgumentLocInventIterator<
10712 Derived,
const TemplateArgument*> PackLocIterator;
10713 if (TransformTemplateArguments(PackLocIterator(*
this, PackArgs.begin()),
10714 PackLocIterator(*
this, PackArgs.end()),
10715 TransformedPackArgs,
true))
10719 SmallVector<TemplateArgument, 8> Args;
10720 bool PartialSubstitution =
false;
10721 for (
auto &Loc : TransformedPackArgs.arguments()) {
10722 Args.push_back(Loc.getArgument());
10723 if (Loc.getArgument().isPackExpansion())
10724 PartialSubstitution =
true;
10727 if (PartialSubstitution)
10728 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
10730 E->getRParenLoc(),
None, Args);
10732 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
10733 E->getPackLoc(), E->getRParenLoc(),
10734 Args.size(),
None);
10737 template<
typename Derived>
10739 TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr(
10740 SubstNonTypeTemplateParmPackExpr *E) {
10745 template<
typename Derived>
10747 TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr(
10748 SubstNonTypeTemplateParmExpr *E) {
10753 template<
typename Derived>
10755 TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
10760 template<
typename Derived>
10762 TreeTransform<Derived>::TransformMaterializeTemporaryExpr(
10763 MaterializeTemporaryExpr *E) {
10764 return getDerived().TransformExpr(E->GetTemporaryExpr());
10767 template<
typename Derived>
10769 TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) {
10770 Expr *Pattern = E->getPattern();
10772 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
10773 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
10774 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
10778 bool Expand =
true;
10779 bool RetainExpansion =
false;
10780 Optional<unsigned> NumExpansions;
10781 if (getDerived().TryExpandParameterPacks(E->getEllipsisLoc(),
10782 Pattern->getSourceRange(),
10784 Expand, RetainExpansion,
10791 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
10794 E->getLHS() ? getDerived().TransformExpr(E->getLHS()) :
ExprResult();
10795 if (LHS.isInvalid())
10799 E->getRHS() ? getDerived().TransformExpr(E->getRHS()) :
ExprResult();
10800 if (RHS.isInvalid())
10803 if (!getDerived().AlwaysRebuild() &&
10804 LHS.get() == E->getLHS() && RHS.get() == E->getRHS())
10807 return getDerived().RebuildCXXFoldExpr(
10808 E->getLocStart(), LHS.get(), E->getOperator(), E->getEllipsisLoc(),
10809 RHS.get(), E->getLocEnd());
10814 ExprResult Result = getDerived().TransformExpr(E->getInit());
10815 if (Result.isInvalid())
10817 bool LeftFold = E->isLeftFold();
10821 if (!LeftFold && RetainExpansion) {
10822 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
10824 ExprResult Out = getDerived().TransformExpr(Pattern);
10825 if (Out.isInvalid())
10828 Result = getDerived().RebuildCXXFoldExpr(
10829 E->getLocStart(), Out.get(), E->getOperator(), E->getEllipsisLoc(),
10830 Result.get(), E->getLocEnd());
10831 if (Result.isInvalid())
10835 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
10836 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(
10837 getSema(), LeftFold ?
I : *NumExpansions -
I - 1);
10838 ExprResult Out = getDerived().TransformExpr(Pattern);
10839 if (Out.isInvalid())
10842 if (Out.get()->containsUnexpandedParameterPack()) {
10844 Result = getDerived().RebuildCXXFoldExpr(
10846 LeftFold ? Result.get() : Out.get(),
10847 E->getOperator(), E->getEllipsisLoc(),
10848 LeftFold ? Out.get() : Result.get(),
10850 }
else if (Result.isUsable()) {
10852 Result = getDerived().RebuildBinaryOperator(
10853 E->getEllipsisLoc(), E->getOperator(),
10854 LeftFold ? Result.get() : Out.get(),
10855 LeftFold ? Out.get() : Result.get());
10859 if (Result.isInvalid())
10865 if (LeftFold && RetainExpansion) {
10866 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
10868 ExprResult Out = getDerived().TransformExpr(Pattern);
10869 if (Out.isInvalid())
10872 Result = getDerived().RebuildCXXFoldExpr(
10873 E->getLocStart(), Result.get(),
10874 E->getOperator(), E->getEllipsisLoc(),
10875 Out.get(), E->getLocEnd());
10876 if (Result.isInvalid())
10882 if (Result.isUnset())
10883 return getDerived().RebuildEmptyCXXFoldExpr(E->getEllipsisLoc(),
10889 template<
typename Derived>
10891 TreeTransform<Derived>::TransformCXXStdInitializerListExpr(
10892 CXXStdInitializerListExpr *E) {
10893 return getDerived().TransformExpr(E->getSubExpr());
10896 template<
typename Derived>
10898 TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) {
10899 return SemaRef.MaybeBindToTemporary(E);
10902 template<
typename Derived>
10904 TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
10908 template<
typename Derived>
10910 TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) {
10911 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
10912 if (SubExpr.isInvalid())
10915 if (!getDerived().AlwaysRebuild() &&
10916 SubExpr.get() == E->getSubExpr())
10919 return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get());
10922 template<
typename Derived>
10924 TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *E) {
10926 SmallVector<Expr *, 8> Elements;
10927 bool ArgChanged =
false;
10928 if (getDerived().TransformExprs(E->getElements(), E->getNumElements(),
10929 false, Elements, &ArgChanged))
10932 if (!getDerived().AlwaysRebuild() && !ArgChanged)
10933 return SemaRef.MaybeBindToTemporary(E);
10935 return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(),
10940 template<
typename Derived>
10942 TreeTransform<Derived>::TransformObjCDictionaryLiteral(
10943 ObjCDictionaryLiteral *E) {
10945 SmallVector<ObjCDictionaryElement, 8> Elements;
10946 bool ArgChanged =
false;
10947 for (
unsigned I = 0, N = E->getNumElements();
I != N; ++
I) {
10948 ObjCDictionaryElement OrigElement = E->getKeyValueElement(
I);
10950 if (OrigElement.isPackExpansion()) {
10952 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
10953 getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded);
10954 getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded);
10955 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
10959 bool Expand =
true;
10960 bool RetainExpansion =
false;
10961 Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions;
10962 Optional<unsigned> NumExpansions = OrigNumExpansions;
10963 SourceRange PatternRange(OrigElement.Key->getLocStart(),
10964 OrigElement.Value->getLocEnd());
10965 if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc,
10968 Expand, RetainExpansion,
10976 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
10977 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
10978 if (Key.isInvalid())
10981 if (Key.get() != OrigElement.Key)
10985 if (Value.isInvalid())
10988 if (Value.get() != OrigElement.Value)
10991 ObjCDictionaryElement Expansion = {
10992 Key.
get(), Value.get(), OrigElement.EllipsisLoc, NumExpansions
10994 Elements.push_back(Expansion);
11004 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
11005 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(),
I);
11006 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
11007 if (Key.isInvalid())
11010 ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
11011 if (Value.isInvalid())
11014 ObjCDictionaryElement Element = {
11015 Key.
get(), Value.get(), SourceLocation(), NumExpansions
11021 if (Key.get()->containsUnexpandedParameterPack() ||
11022 Value.get()->containsUnexpandedParameterPack())
11023 Element.EllipsisLoc = OrigElement.EllipsisLoc;
11025 Elements.push_back(Element);
11035 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
11036 if (Key.isInvalid())
11039 if (Key.get() != OrigElement.Key)
11044 = getDerived().TransformExpr(OrigElement.Value);
11045 if (Value.isInvalid())
11048 if (Value.get() != OrigElement.Value)
11051 ObjCDictionaryElement Element = {
11052 Key.
get(), Value.get(), SourceLocation(),
None
11054 Elements.push_back(Element);
11057 if (!getDerived().AlwaysRebuild() && !ArgChanged)
11058 return SemaRef.MaybeBindToTemporary(E);
11060 return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(),
11064 template<
typename Derived>
11066 TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) {
11067 TypeSourceInfo *EncodedTypeInfo
11068 = getDerived().TransformType(E->getEncodedTypeSourceInfo());
11069 if (!EncodedTypeInfo)
11072 if (!getDerived().AlwaysRebuild() &&
11073 EncodedTypeInfo == E->getEncodedTypeSourceInfo())
11076 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(),
11078 E->getRParenLoc());
11081 template<
typename Derived>
11083 TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
11088 return getDerived().TransformExpr(E->getSubExpr());
11091 template<
typename Derived>
11093 TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
11094 TypeSourceInfo *TSInfo
11095 = getDerived().TransformType(E->getTypeInfoAsWritten());
11099 ExprResult Result = getDerived().TransformExpr(E->getSubExpr());
11100 if (Result.isInvalid())
11103 if (!getDerived().AlwaysRebuild() &&
11104 TSInfo == E->getTypeInfoAsWritten() &&
11105 Result.get() == E->getSubExpr())
11108 return SemaRef.BuildObjCBridgedCast(E->getLParenLoc(), E->getBridgeKind(),
11109 E->getBridgeKeywordLoc(), TSInfo,
11113 template <
typename Derived>
11114 ExprResult TreeTransform<Derived>::TransformObjCAvailabilityCheckExpr(
11115 ObjCAvailabilityCheckExpr *E) {
11119 template<
typename Derived>
11121 TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) {
11123 bool ArgChanged =
false;
11124 SmallVector<Expr*, 8> Args;
11125 Args.reserve(E->getNumArgs());
11126 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(),
false, Args,
11132 TypeSourceInfo *ReceiverTypeInfo
11133 = getDerived().TransformType(E->getClassReceiverTypeInfo());
11134 if (!ReceiverTypeInfo)
11138 if (!getDerived().AlwaysRebuild() &&
11139 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged)
11140 return SemaRef.MaybeBindToTemporary(E);
11143 SmallVector<SourceLocation, 16> SelLocs;
11144 E->getSelectorLocs(SelLocs);
11145 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo,
11148 E->getMethodDecl(),
11156 SmallVector<SourceLocation, 16> SelLocs;
11157 E->getSelectorLocs(SelLocs);
11158 return getDerived().RebuildObjCMessageExpr(E->getSuperLoc(),
11161 E->getReceiverType(),
11162 E->getMethodDecl(),
11170 "Only class and instance messages may be instantiated");
11172 = getDerived().TransformExpr(E->getInstanceReceiver());
11173 if (Receiver.isInvalid())
11177 if (!getDerived().AlwaysRebuild() &&
11178 Receiver.get() == E->getInstanceReceiver() && !ArgChanged)
11179 return SemaRef.MaybeBindToTemporary(E);
11182 SmallVector<SourceLocation, 16> SelLocs;
11183 E->getSelectorLocs(SelLocs);
11184 return getDerived().RebuildObjCMessageExpr(Receiver.get(),
11187 E->getMethodDecl(),
11193 template<
typename Derived>
11195 TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) {
11199 template<
typename Derived>
11201 TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) {
11205 template<
typename Derived>
11207 TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) {
11209 ExprResult Base = getDerived().TransformExpr(E->getBase());
11210 if (Base.isInvalid())
11216 if (!getDerived().AlwaysRebuild() &&
11217 Base.get() == E->getBase())
11220 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(),
11222 E->isArrow(), E->isFreeIvar());
11225 template<
typename Derived>
11227 TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
11230 if (!E->isObjectReceiver())
11234 ExprResult Base = getDerived().TransformExpr(E->getBase());
11235 if (Base.isInvalid())
11241 if (!getDerived().AlwaysRebuild() &&
11242 Base.get() == E->getBase())
11245 if (E->isExplicitProperty())
11246 return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
11247 E->getExplicitProperty(),
11250 return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
11251 SemaRef.Context.PseudoObjectTy,
11252 E->getImplicitPropertyGetter(),
11253 E->getImplicitPropertySetter(),
11257 template<
typename Derived>
11259 TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
11261 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
11262 if (Base.isInvalid())
11266 ExprResult Key = getDerived().TransformExpr(E->getKeyExpr());
11267 if (Key.isInvalid())
11271 if (!getDerived().AlwaysRebuild() &&
11272 Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr())
11275 return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(),
11276 Base.get(), Key.get(),
11277 E->getAtIndexMethodDecl(),
11278 E->setAtIndexMethodDecl());
11281 template<
typename Derived>
11283 TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) {
11285 ExprResult Base = getDerived().TransformExpr(E->getBase());
11286 if (Base.isInvalid())
11290 if (!getDerived().AlwaysRebuild() &&
11291 Base.get() == E->getBase())
11294 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(),
11299 template<
typename Derived>
11301 TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) {
11302 bool ArgumentChanged =
false;
11303 SmallVector<Expr*, 8> SubExprs;
11304 SubExprs.reserve(E->getNumSubExprs());
11305 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(),
false,
11306 SubExprs, &ArgumentChanged))
11309 if (!getDerived().AlwaysRebuild() &&
11313 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(),
11315 E->getRParenLoc());
11318 template<
typename Derived>
11320 TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *E) {
11321 ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr());
11322 if (SrcExpr.isInvalid())
11325 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
11329 if (!getDerived().AlwaysRebuild() &&
11330 Type == E->getTypeSourceInfo() &&
11331 SrcExpr.get() == E->getSrcExpr())
11334 return getDerived().RebuildConvertVectorExpr(E->getBuiltinLoc(),
11335 SrcExpr.get(), Type,
11336 E->getRParenLoc());
11339 template<
typename Derived>
11341 TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) {
11342 BlockDecl *oldBlock = E->getBlockDecl();
11344 SemaRef.ActOnBlockStart(E->getCaretLocation(),
nullptr);
11345 BlockScopeInfo *blockScope = SemaRef.getCurBlock();
11347 blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic());
11348 blockScope->TheDecl->setBlockMissingReturnType(
11349 oldBlock->blockMissingReturnType());
11351 SmallVector<ParmVarDecl*, 4> params;
11352 SmallVector<QualType, 4> paramTypes;
11354 const FunctionProtoType *exprFunctionType = E->getFunctionType();
11357 Sema::ExtParameterInfoBuilder extParamInfos;
11358 if (getDerived().TransformFunctionTypeParams(
11359 E->getCaretLocation(), oldBlock->parameters(),
nullptr,
11360 exprFunctionType->getExtParameterInfosOrNull(), paramTypes, ¶ms,
11362 getSema().ActOnBlockError(E->getCaretLocation(),
nullptr);
11366 QualType exprResultType =
11367 getDerived().TransformType(exprFunctionType->getReturnType());
11369 auto epi = exprFunctionType->getExtProtoInfo();
11370 epi.ExtParameterInfos = extParamInfos.getPointerOrNull(paramTypes.size());
11372 QualType functionType =
11373 getDerived().RebuildFunctionProtoType(exprResultType, paramTypes, epi);
11374 blockScope->FunctionType = functionType;
11377 if (!params.empty())
11378 blockScope->TheDecl->setParams(params);
11380 if (!oldBlock->blockMissingReturnType()) {
11381 blockScope->HasImplicitReturnType =
false;
11382 blockScope->ReturnType = exprResultType;
11386 StmtResult body = getDerived().TransformStmt(E->getBody());
11387 if (body.isInvalid()) {
11388 getSema().ActOnBlockError(E->getCaretLocation(),
nullptr);
11395 if (!SemaRef.getDiagnostics().hasErrorOccurred()) {
11396 for (
const auto &
I : oldBlock->captures()) {
11397 VarDecl *oldCapture =
I.getVariable();
11400 if (isa<ParmVarDecl>(oldCapture) &&
11401 cast<ParmVarDecl>(oldCapture)->isParameterPack())
11404 VarDecl *newCapture =
11405 cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(),
11407 assert(blockScope->CaptureMap.count(newCapture));
11409 assert(oldBlock->capturesCXXThis() == blockScope->isCXXThisCaptured());
11413 return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(),
11417 template<
typename Derived>
11419 TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) {
11420 llvm_unreachable(
"Cannot transform asType expressions yet");
11423 template<
typename Derived>
11425 TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) {
11426 QualType RetTy = getDerived().TransformType(E->getType());
11427 bool ArgumentChanged =
false;
11428 SmallVector<Expr*, 8> SubExprs;
11429 SubExprs.reserve(E->getNumSubExprs());
11430 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(),
false,
11431 SubExprs, &ArgumentChanged))
11434 if (!getDerived().AlwaysRebuild() &&
11438 return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs,
11439 RetTy, E->getOp(), E->getRParenLoc());
11446 template<
typename Derived>
11449 return SemaRef.BuildPointerType(PointeeType, Star,
11450 getDerived().getBaseEntity());
11453 template<
typename Derived>
11456 return SemaRef.BuildBlockPointerType(PointeeType, Star,
11457 getDerived().getBaseEntity());
11460 template<
typename Derived>
11463 bool WrittenAsLValue,
11465 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue,
11466 Sigil, getDerived().getBaseEntity());
11469 template<
typename Derived>
11474 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Sigil,
11475 getDerived().getBaseEntity());
11478 template<
typename Derived>
11489 return SemaRef.BuildObjCObjectType(BaseType, Loc, TypeArgsLAngleLoc,
11490 TypeArgs, TypeArgsRAngleLoc,
11491 ProtocolLAngleLoc, Protocols, ProtocolLocs,
11496 template<
typename Derived>
11500 return SemaRef.Context.getObjCObjectPointerType(PointeeType);
11503 template<
typename Derived>
11507 const llvm::APInt *Size,
11509 unsigned IndexTypeQuals,
11511 if (SizeExpr || !Size)
11512 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr,
11513 IndexTypeQuals, BracketsRange,
11514 getDerived().getBaseEntity());
11517 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy,
11518 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy,
11519 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty
11521 const unsigned NumTypes = llvm::array_lengthof(Types);
11523 for (
unsigned I = 0;
I != NumTypes; ++
I)
11524 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[
I])) {
11525 SizeType = Types[
I];
11534 return SemaRef.BuildArrayType(ElementType, SizeMod, ArraySize,
11535 IndexTypeQuals, BracketsRange,
11536 getDerived().getBaseEntity());
11539 template<
typename Derived>
11543 const llvm::APInt &Size,
11544 unsigned IndexTypeQuals,
11546 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size,
nullptr,
11547 IndexTypeQuals, BracketsRange);
11550 template<
typename Derived>
11554 unsigned IndexTypeQuals,
11556 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
nullptr,
11557 IndexTypeQuals, BracketsRange);
11560 template<
typename Derived>
11565 unsigned IndexTypeQuals,
11567 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
11569 IndexTypeQuals, BracketsRange);
11572 template<
typename Derived>
11577 unsigned IndexTypeQuals,
11579 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
11581 IndexTypeQuals, BracketsRange);
11584 template<
typename Derived>
11586 unsigned NumElements,
11589 return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind);
11592 template<
typename Derived>
11594 unsigned NumElements,
11596 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
11597 NumElements,
true);
11601 return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc);
11604 template<
typename Derived>
11609 return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc);
11612 template<
typename Derived>
11617 return SemaRef.BuildFunctionType(T, ParamTypes,
11618 getDerived().getBaseLocation(),
11619 getDerived().getBaseEntity(),
11623 template<
typename Derived>
11625 return SemaRef.Context.getFunctionNoProtoType(T);
11628 template<
typename Derived>
11630 assert(D &&
"no decl found");
11631 if (D->isInvalidDecl())
return QualType();
11635 if (isa<UsingDecl>(D)) {
11638 "UnresolvedUsingTypenameDecl transformed to non-typename using");
11642 Ty = cast<TypeDecl>((*Using->
shadow_begin())->getTargetDecl());
11645 assert(isa<UnresolvedUsingTypenameDecl>(D) &&
11646 "UnresolvedUsingTypenameDecl transformed to non-using decl");
11647 Ty = cast<UnresolvedUsingTypenameDecl>(D);
11650 return SemaRef.Context.getTypeDeclType(Ty);
11653 template<
typename Derived>
11656 return SemaRef.BuildTypeofExprType(E, Loc);
11659 template<
typename Derived>
11661 return SemaRef.Context.getTypeOfType(Underlying);
11664 template<
typename Derived>
11667 return SemaRef.BuildDecltypeType(E, Loc);
11670 template<
typename Derived>
11674 return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc);
11677 template<
typename Derived>
11682 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
11685 template<
typename Derived>
11688 return SemaRef.BuildAtomicType(ValueType, KWLoc);
11691 template<
typename Derived>
11694 return SemaRef.BuildPipeType(ValueType, KWLoc);
11697 template<
typename Derived>
11702 return SemaRef.Context.getQualifiedTemplateName(SS.
getScopeRep(), TemplateKW,
11706 template<
typename Derived>
11717 getSema().ActOnDependentTemplateName(
nullptr,
11718 SS, TemplateKWLoc, TemplateName,
11722 return Template.
get();
11725 template<
typename Derived>
11733 SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc };
11737 getSema().ActOnDependentTemplateName(
nullptr,
11738 SS, TemplateKWLoc, Name,
11742 return Template.
get();
11745 template<
typename Derived>
11753 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus);
11758 return SemaRef.checkPseudoObjectAssignment(
nullptr, OpLoc, Opc,
11760 ExprResult Result = SemaRef.CheckPlaceholderExpr(First);
11763 First = Result.
get();
11767 ExprResult Result = SemaRef.CheckPlaceholderExpr(Second);
11770 Second = Result.
get();
11774 if (Op == OO_Subscript) {
11777 return getSema().CreateBuiltinArraySubscriptExpr(First,
11778 Callee->getLocStart(),
11780 }
else if (Op == OO_Arrow) {
11782 return SemaRef.BuildOverloadedArrowExpr(
nullptr, First, OpLoc);
11783 }
else if (Second ==
nullptr || isPostIncDec) {
11790 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First);
11799 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second);
11812 assert(ULE->requiresADL());
11813 Functions.
append(ULE->decls_begin(), ULE->decls_end());
11818 NamedDecl *ND = cast<DeclRefExpr>(Callee)->getDecl();
11819 if (!isa<CXXMethodDecl>(ND))
11824 Expr *Args[2] = { First, Second };
11825 unsigned NumArgs = 1 + (Second !=
nullptr);
11828 if (NumArgs == 1 || isPostIncDec) {
11831 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First);
11834 if (Op == OO_Subscript) {
11838 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) {
11845 LBrace = Callee->getLocStart();
11849 return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace,
11856 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]);
11863 template<
typename Derived>
11878 ->template getAs<RecordType>())){
11880 return SemaRef.BuildPseudoDestructorExpr(
11881 Base, OperatorLoc, isArrow ? tok::arrow : tok::period, SS, ScopeType,
11882 CCLoc, TildeLoc, Destroyed);
11887 SemaRef.Context.getCanonicalType(DestroyedType->
getType())));
11896 diag::err_expected_class_or_namespace)
11897 << ScopeType->
getType() << getSema().getLangOpts().CPlusPlus;
11905 return getSema().BuildMemberReferenceExpr(Base, BaseType,
11906 OperatorLoc, isArrow,
11914 template<
typename Derived>
11922 for (
unsigned I = 0;
I < NumParams; ++
I) {
11923 if (
I != ContextParamPos) {
11929 Params.push_back(std::make_pair(StringRef(), QualType()));
11932 getSema().ActOnCapturedRegionStart(Loc,
nullptr,
11936 Sema::CompoundScopeRAII CompoundScope(getSema());
11940 if (Body.isInvalid()) {
11941 getSema().ActOnCapturedRegionError();
11945 return getSema().ActOnCapturedRegionEnd(Body.get());
11950 #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...
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.
Stores the type being destroyed by a pseudo-destructor expression.
A (possibly-)qualified type.
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.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
void setLAngleLoc(SourceLocation Loc)
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...
The current expression is potentially evaluated at run time, which means that code may be generated t...
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
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)
DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, ArrayRef< TemplateArgument > Args, QualType Canon)
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 ':'.
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.
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
bool isSpelledAsLValue() const
Expr * getAlignment()
Returns alignment.
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...
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.
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
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...
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.
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.
Represents a C++ using-declaration.
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.
QualType getReturnType() const
shadow_iterator shadow_begin() 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.
TemplateArgumentLocContainerIterator & operator++()
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
std::input_iterator_tag iterator_category
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
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
shadow_iterator shadow_end() const
RAII object used to change the argument pack substitution index within a Sema object.
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.
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 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)
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.
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
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 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.
class LLVM_ALIGNAS(8) TemplateSpecializationType unsigned NumArgs
Represents a type template specialization; the template must be a class template, a type alias templa...
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 ','.
The result type of a method or function.
OpenMPProcBindClauseKind
OpenMP attributes for 'proc_bind' clause.
A type, stored as a Type*.
UnresolvedSetImpl::iterator decls_iterator
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...
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.
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.
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.
const TemplateArgument * iterator
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)
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.
bool hasTypename() const
Return true if the using declaration has 'typename'.
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 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.
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...
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>'.
QualType getCanonicalType() const
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
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
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.
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
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.
pack_iterator pack_end() const
Iterator referencing one past the last argument of a template argument pack.
LookupResultKind getResultKind() const
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
ArrayRef< ParmVarDecl * > getParams() const
void setRAngleLoc(SourceLocation Loc)
This represents 'dist_schedule' clause in the '#pragma omp ...' directive.
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 '('.
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
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.
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.
const TemplateArgument & getArgument() const
SourceLocation ColonLoc
Location of ':'.
TemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon, QualType Aliased)
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.
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.
QualType getDeducedType() const
Get the type deduced for this auto type, or null if it's either not been deduced or was deduced to a ...