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;
428 TransformedLocalDecls[Old] = New;
436 return getDerived().TransformDecl(Loc, D);
449 return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D));
461 NamedDecl *FirstQualifierInScope =
nullptr);
496 NamedDecl *FirstQualifierInScope =
nullptr);
508 bool Uneval =
false);
531 bool Uneval =
false) {
532 return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs,
550 template<
typename InputIterator>
551 bool TransformTemplateArguments(InputIterator First,
554 bool Uneval =
false);
562 return SemaRef.Context.getTrivialTypeSourceInfo(T,
563 getDerived().getBaseLocation());
566 #define ABSTRACT_TYPELOC(CLASS, PARENT)
567 #define TYPELOC(CLASS, PARENT) \
568 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
569 #include "clang/AST/TypeLocNodes.def"
571 template<
typename Fn>
572 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
573 FunctionProtoTypeLoc TL,
574 CXXRecordDecl *ThisContext,
575 unsigned ThisTypeQuals,
576 Fn TransformExceptionSpec);
578 bool TransformExceptionSpec(SourceLocation Loc,
579 FunctionProtoType::ExceptionSpecInfo &ESI,
580 SmallVectorImpl<QualType> &Exceptions,
586 TransformTemplateSpecializationType(TypeLocBuilder &TLB,
587 TemplateSpecializationTypeLoc TL,
588 TemplateName Template);
591 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
592 DependentTemplateSpecializationTypeLoc TL,
593 TemplateName Template,
596 QualType TransformDependentTemplateSpecializationType(
597 TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
598 NestedNameSpecifierLoc QualifierLoc);
607 bool TransformFunctionTypeParams(SourceLocation Loc,
608 ParmVarDecl **Params,
unsigned NumParams,
609 const QualType *ParamTypes,
610 SmallVectorImpl<QualType> &PTypes,
611 SmallVectorImpl<ParmVarDecl*> *PVars);
618 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
620 Optional<unsigned> NumExpansions,
621 bool ExpectParameterPack);
623 QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);
625 StmtResult TransformCompoundStmt(CompoundStmt *
S,
bool IsStmtExpr);
626 ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *
E);
636 bool IsAddressOfOperand,
639 ExprResult TransformParenDependentScopeDeclRefExpr(
647 #define STMT(Node, Parent) \
648 LLVM_ATTRIBUTE_NOINLINE \
649 StmtResult Transform##Node(Node *S);
650 #define EXPR(Node, Parent) \
651 LLVM_ATTRIBUTE_NOINLINE \
652 ExprResult Transform##Node(Node *E);
653 #define ABSTRACT_STMT(Stmt)
654 #include "clang/AST/StmtNodes.inc"
656 #define OPENMP_CLAUSE(Name, Class) \
657 LLVM_ATTRIBUTE_NOINLINE \
658 OMPClause *Transform ## Class(Class *S);
659 #include "clang/Basic/OpenMPKinds.def"
665 QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);
671 QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);
681 QualType RebuildReferenceType(QualType ReferentType,
683 SourceLocation Sigil);
690 QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
691 SourceLocation Sigil);
697 QualType RebuildObjCObjectType(QualType BaseType,
699 SourceLocation TypeArgsLAngleLoc,
700 ArrayRef<TypeSourceInfo *> TypeArgs,
701 SourceLocation TypeArgsRAngleLoc,
702 SourceLocation ProtocolLAngleLoc,
703 ArrayRef<ObjCProtocolDecl *> Protocols,
704 ArrayRef<SourceLocation> ProtocolLocs,
705 SourceLocation ProtocolRAngleLoc);
711 QualType RebuildObjCObjectPointerType(QualType PointeeType,
712 SourceLocation Star);
721 QualType RebuildArrayType(QualType ElementType,
723 const llvm::APInt *Size,
725 unsigned IndexTypeQuals,
726 SourceRange BracketsRange);
733 QualType RebuildConstantArrayType(QualType ElementType,
735 const llvm::APInt &Size,
736 unsigned IndexTypeQuals,
737 SourceRange BracketsRange);
744 QualType RebuildIncompleteArrayType(QualType ElementType,
746 unsigned IndexTypeQuals,
747 SourceRange BracketsRange);
754 QualType RebuildVariableArrayType(QualType ElementType,
757 unsigned IndexTypeQuals,
758 SourceRange BracketsRange);
765 QualType RebuildDependentSizedArrayType(QualType ElementType,
768 unsigned IndexTypeQuals,
769 SourceRange BracketsRange);
776 QualType RebuildVectorType(QualType ElementType,
unsigned NumElements,
784 QualType RebuildExtVectorType(QualType ElementType,
unsigned NumElements,
785 SourceLocation AttributeLoc);
792 QualType RebuildDependentSizedExtVectorType(QualType ElementType,
794 SourceLocation AttributeLoc);
800 QualType RebuildFunctionProtoType(QualType T,
801 MutableArrayRef<QualType> ParamTypes,
802 const FunctionProtoType::ExtProtoInfo &EPI);
805 QualType RebuildFunctionNoProtoType(QualType ResultType);
809 QualType RebuildUnresolvedUsingType(Decl *D);
813 return SemaRef.Context.getTypeDeclType(Typedef);
818 return SemaRef.Context.getTypeDeclType(Record);
823 return SemaRef.Context.getTypeDeclType(Enum);
855 return SemaRef.Context.getAutoType(Deduced, Keyword,
873 return SemaRef.Context.getParenType(InnerType);
885 return SemaRef.Context.getElaboratedType(Keyword,
904 SS.
Adopt(QualifierLoc);
906 = getDerived().RebuildTemplateName(SS, *Name, NameLoc,
QualType(),
914 return SemaRef.Context.getDependentTemplateSpecializationType(Keyword,
922 getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
928 return SemaRef.Context.getElaboratedType(Keyword,
944 SS.
Adopt(QualifierLoc);
948 if (!SemaRef.computeDeclContext(SS))
949 return SemaRef.Context.getDependentNameType(Keyword,
955 return SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc,
964 DeclContext *DC = SemaRef.computeDeclContext(SS,
false);
968 if (SemaRef.RequireCompleteDeclContext(SS, DC))
972 SemaRef.LookupQualifiedName(Result, DC);
984 llvm_unreachable(
"Tag lookup cannot find non-tags");
995 SemaRef.LookupQualifiedName(Result, DC);
1002 if (isa<TypedefDecl>(SomeDecl)) Kind = 1;
1003 else if (isa<TypeAliasDecl>(SomeDecl)) Kind = 2;
1004 else if (isa<ClassTemplateDecl>(SomeDecl)) Kind = 3;
1005 SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) <<
Kind;
1006 SemaRef.Diag(SomeDecl->
getLocation(), diag::note_declared_at);
1010 SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope)
1017 if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind,
false,
1019 SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id;
1020 SemaRef.Diag(Tag->
getLocation(), diag::note_previous_use);
1025 QualType T = SemaRef.Context.getTypeDeclType(Tag);
1026 return SemaRef.Context.getElaboratedType(Keyword,
1039 return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc,
1096 return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
1107 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements,
1120 return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS,
1129 getSema().ActOnCaseStmtBody(S, Body);
1140 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt,
1150 return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt);
1160 return SemaRef.ActOnAttributedStmt(AttrLoc, Attrs, SubStmt);
1170 return getSema().ActOnIfStmt(IfLoc, Cond, CondVar, Then, ElseLoc, Else);
1179 return getSema().ActOnStartOfSwitchStmt(SwitchLoc, Cond,
1189 return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body);
1198 return getSema().ActOnWhileStmt(WhileLoc, Cond, CondVar, Body);
1208 return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
1220 return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
1221 CondVar, Inc, RParenLoc, Body);
1230 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label);
1240 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target);
1248 return getSema().BuildReturnStmt(ReturnLoc, Result);
1258 return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc);
1266 bool IsVolatile,
unsigned NumOutputs,
1271 return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
1272 NumInputs, Names, Constraints, Exprs,
1273 AsmString, Clobbers, RParenLoc);
1282 StringRef AsmString,
1283 unsigned NumOutputs,
unsigned NumInputs,
1288 return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString,
1289 NumOutputs, NumInputs,
1290 Constraints, Clobbers, Exprs, EndLoc);
1298 return getSema().BuildCoreturnStmt(CoreturnLoc, Result);
1306 return getSema().BuildCoawaitExpr(CoawaitLoc, Result);
1314 return getSema().BuildCoyieldExpr(CoyieldLoc, Result);
1325 return getSema().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts,
1335 return getSema().BuildObjCExceptionDecl(TInfo, T,
1349 return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
1359 return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body);
1368 return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
1381 return getSema().ActOnOpenMPExecutableDirective(
1382 Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
1395 return getSema().ActOnOpenMPIfClause(NameModifier, Condition, StartLoc,
1396 LParenLoc, NameModifierLoc, ColonLoc,
1407 return getSema().ActOnOpenMPFinalClause(Condition, StartLoc, LParenLoc,
1419 return getSema().ActOnOpenMPNumThreadsClause(NumThreads, StartLoc,
1430 return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc);
1440 return getSema().ActOnOpenMPSimdlenClause(Len, StartLoc, LParenLoc, EndLoc);
1450 return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc,
1463 return getSema().ActOnOpenMPDefaultClause(Kind, KindKwLoc,
1464 StartLoc, LParenLoc, EndLoc);
1476 return getSema().ActOnOpenMPProcBindClause(Kind, KindKwLoc,
1477 StartLoc, LParenLoc, EndLoc);
1489 return getSema().ActOnOpenMPScheduleClause(
1490 M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
1501 return getSema().ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Num);
1512 return getSema().ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc,
1524 return getSema().ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc,
1536 return getSema().ActOnOpenMPLastprivateClause(VarList, StartLoc, LParenLoc,
1548 return getSema().ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc,
1563 return getSema().ActOnOpenMPReductionClause(
1564 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1579 return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc,
1580 Modifier, ModifierLoc, ColonLoc,
1593 return getSema().ActOnOpenMPAlignedClause(VarList, Alignment, StartLoc,
1594 LParenLoc, ColonLoc, EndLoc);
1605 return getSema().ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc,
1617 return getSema().ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc,
1629 return getSema().ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc,
1642 return getSema().ActOnOpenMPDependClause(DepKind, DepLoc, ColonLoc, VarList,
1643 StartLoc, LParenLoc, EndLoc);
1653 return getSema().ActOnOpenMPDeviceClause(Device, StartLoc, LParenLoc,
1666 return getSema().ActOnOpenMPMapClause(MapTypeModifier, MapType, MapLoc,
1667 ColonLoc, VarList,StartLoc,
1678 return getSema().ActOnOpenMPNumTeamsClause(NumTeams, StartLoc, LParenLoc,
1690 return getSema().ActOnOpenMPThreadLimitClause(ThreadLimit, StartLoc,
1701 return getSema().ActOnOpenMPPriorityClause(Priority, StartLoc, LParenLoc,
1712 return getSema().ActOnOpenMPGrainsizeClause(Grainsize, StartLoc, LParenLoc,
1723 return getSema().ActOnOpenMPNumTasksClause(NumTasks, StartLoc, LParenLoc,
1734 return getSema().ActOnOpenMPHintClause(Hint, StartLoc, LParenLoc, EndLoc);
1743 return getSema().ActOnObjCAtSynchronizedOperand(atLoc,
object);
1752 return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body);
1761 return getSema().ActOnObjCAutoreleasePoolStmt(AtLoc, Body);
1773 StmtResult ForEachStmt = getSema().ActOnObjCForCollectionStmt(ForLoc,
1780 return getSema().FinishObjCForCollectionStmt(ForEachStmt.
get(), Body);
1792 VarDecl *Var = getSema().BuildExceptionDeclaration(
nullptr, Declarator,
1793 StartLoc, IdLoc, Id);
1795 getSema().CurContext->addDecl(Var);
1816 return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers);
1832 if (
DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) {
1833 if (RangeStmt->isSingleDecl()) {
1834 if (
VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
1835 if (RangeVar->isInvalidDecl())
1838 Expr *RangeExpr = RangeVar->getInit();
1841 return getSema().ActOnObjCForCollectionStmt(ForLoc, LoopVar, RangeExpr,
1847 return getSema().BuildCXXForRangeStmt(ForLoc, CoawaitLoc, ColonLoc,
1849 Cond, Inc, LoopVar, RParenLoc,
1862 return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
1863 QualifierLoc, NameInfo, Nested);
1871 return getSema().FinishCXXForRangeStmt(ForRange, Body);
1876 return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler);
1881 return getSema().ActOnSEHExceptBlock(Loc, FilterExpr, Block);
1894 return getSema().BuildPredefinedExpr(Loc, IT);
1904 return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
1917 SS.
Adopt(QualifierLoc);
1921 return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD);
1930 return getSema().ActOnParenExpr(LParen, RParen, SubExpr);
1953 return getSema().BuildUnaryOp(
nullptr, OpLoc, Opc, SubExpr);
1964 return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
1977 return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R);
1989 = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind);
2004 return getSema().ActOnArraySubscriptExpr(
nullptr, LHS,
2017 return getSema().ActOnOMPArraySectionExpr(Base, LBracketLoc, LowerBound,
2018 ColonLoc, Length, RBracketLoc);
2028 Expr *ExecConfig =
nullptr) {
2029 return getSema().ActOnCallExpr(
nullptr, Callee, LParenLoc,
2030 Args, RParenLoc, ExecConfig);
2052 assert(!QualifierLoc &&
"Can't have an unnamed field with a qualifier!");
2054 "unnamed member not of record type?");
2057 getSema().PerformObjectMemberConversion(BaseResult.get(),
2060 if (BaseResult.isInvalid())
2062 Base = BaseResult.get();
2065 MemberExpr(Base, isArrow, OpLoc, Member, MemberNameInfo,
2066 cast<FieldDecl>(Member)->getType(), VK,
OK_Ordinary);
2071 SS.
Adopt(QualifierLoc);
2073 Base = BaseResult.
get();
2082 return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow,
2084 FirstQualifierInScope,
2085 R, ExplicitTemplateArgs,
2096 return getSema().BuildBinOp(
nullptr, OpLoc, Opc, LHS, RHS);
2108 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond,
2120 return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
2132 return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
2147 return getSema().BuildMemberReferenceExpr(Base, Base->
getType(),
2165 = SemaRef.ActOnInitList(LBraceLoc, Inits, RBraceLoc);
2186 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
2210 return getSema().BuildVAArgExpr(BuiltinLoc,
2222 return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs);
2232 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label);
2242 return getSema().ActOnStmtExpr(LParenLoc, SubStmt, RParenLoc);
2252 return SemaRef.ActOnChooseExpr(BuiltinLoc,
2264 Expr *ControllingExpr,
2267 return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
2268 ControllingExpr, Types, Exprs);
2292 Stmt::StmtClass Class,
2300 case Stmt::CXXStaticCastExprClass:
2301 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
2302 RAngleLoc, LParenLoc,
2303 SubExpr, RParenLoc);
2305 case Stmt::CXXDynamicCastExprClass:
2306 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
2307 RAngleLoc, LParenLoc,
2308 SubExpr, RParenLoc);
2310 case Stmt::CXXReinterpretCastExprClass:
2311 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
2312 RAngleLoc, LParenLoc,
2316 case Stmt::CXXConstCastExprClass:
2317 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
2318 RAngleLoc, LParenLoc,
2319 SubExpr, RParenLoc);
2322 llvm_unreachable(
"Invalid C++ named cast");
2337 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
2354 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
2371 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
2388 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
2402 return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc,
2415 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2428 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2440 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
2452 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
2464 getSema().CheckCXXThisCapture(ThisLoc);
2465 return new (getSema().Context)
CXXThisExpr(ThisLoc, ThisType, isImplicit);
2473 bool IsThrownVariableInScope) {
2474 return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope);
2504 return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc,
2522 Expr *Initializer) {
2523 return getSema().BuildCXXNew(StartLoc, UseGlobal,
2540 bool IsGlobalDelete,
2543 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
2555 return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc);
2567 return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc);
2578 return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc);
2591 bool IsAddressOfOperand,
2594 SS.
Adopt(QualifierLoc);
2596 if (TemplateArgs || TemplateKWLoc.
isValid())
2597 return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc, NameInfo,
2600 return getSema().BuildQualifiedDeclarationNameExpr(
2601 SS, NameInfo, IsAddressOfOperand,
nullptr, RecoveryTSI);
2613 return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL,
2626 bool HadMultipleCandidates,
2627 bool ListInitialization,
2628 bool StdInitListInitialization,
2629 bool RequiresZeroInit,
2633 if (getSema().CompleteConstructorCall(Constructor, Args, Loc,
2637 return getSema().BuildCXXConstructExpr(Loc, T, Constructor, IsElidable,
2639 HadMultipleCandidates,
2641 StdInitListInitialization,
2642 RequiresZeroInit, ConstructKind,
2654 return getSema().BuildCXXTypeConstructExpr(TSInfo,
2668 return getSema().BuildCXXTypeConstructExpr(TSInfo,
2688 SS.
Adopt(QualifierLoc);
2690 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
2691 OperatorLoc, IsArrow,
2693 FirstQualifierInScope,
2695 TemplateArgs,
nullptr);
2711 SS.
Adopt(QualifierLoc);
2713 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
2714 OperatorLoc, IsArrow,
2716 FirstQualifierInScope,
2717 R, TemplateArgs,
nullptr);
2725 return SemaRef.BuildCXXNoexceptExpr(Range.
getBegin(), Arg, Range.
getEnd());
2736 RParenLoc, Length, PartialArgs);
2744 return getSema().BuildObjCBoxedExpr(SR, ValueExpr);
2752 Expr **Elements,
unsigned NumElements) {
2753 return getSema().BuildObjCArrayLiteral(Range,
2761 return getSema().BuildObjCSubscriptExpression(RB, Base, Key,
2762 getterMethod, setterMethod);
2771 return getSema().BuildObjCDictionaryLiteral(Range, Elements);
2781 return SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo, RParenLoc);
2792 return SemaRef.BuildClassMessage(ReceiverTypeInfo,
2795 Sel, Method, LBracLoc, SelectorLocs,
2807 return SemaRef.BuildInstanceMessage(Receiver,
2810 Sel, Method, LBracLoc, SelectorLocs,
2826 Sel, Method, LBracLoc, SelectorLocs,
2828 : SemaRef.BuildClassMessage(
nullptr,
2831 Sel, Method, LBracLoc, SelectorLocs,
2843 bool IsArrow,
bool IsFreeIvar) {
2847 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->
getType(),
2865 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->
getType(),
2888 PropertyLoc, Base));
2899 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->
getType(),
2917 = SemaRef.Context.Idents.get(
"__builtin_shufflevector");
2920 assert(!Lookup.
empty() &&
"No __builtin_shufflevector?");
2925 SemaRef.Context.BuiltinFnTy,
2927 QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType());
2928 Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy,
2933 SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(),
2937 return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.
get()));
2944 return SemaRef.SemaConvertVectorExpr(SrcExpr, DstTInfo,
2945 BuiltinLoc, RParenLoc);
2960 EllipsisLoc, NumExpansions);
2981 llvm_unreachable(
"Pack expansion pattern has no parameter packs");
3003 return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions);
3014 return getSema().BuildCXXFoldExpr(LParenLoc, LHS, Operator, EllipsisLoc,
3024 return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator);
3039 return new (SemaRef.Context)
AtomicExpr(BuiltinLoc, SubExprs, RetTy, Op,
3059 template<
typename Derived>
3064 switch (S->getStmtClass()) {
3065 case Stmt::NoStmtClass:
break;
3068 #define STMT(Node, Parent) \
3069 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
3070 #define ABSTRACT_STMT(Node)
3071 #define EXPR(Node, Parent)
3072 #include "clang/AST/StmtNodes.inc"
3075 #define STMT(Node, Parent)
3076 #define ABSTRACT_STMT(Stmt)
3077 #define EXPR(Node, Parent) case Stmt::Node##Class:
3078 #include "clang/AST/StmtNodes.inc"
3080 ExprResult E = getDerived().TransformExpr(cast<Expr>(S));
3084 return getSema().ActOnExprStmt(E);
3091 template<
typename Derived>
3099 #define OPENMP_CLAUSE(Name, Class) \
3100 case OMPC_ ## Name : \
3101 return getDerived().Transform ## Class(cast<Class>(S));
3102 #include "clang/Basic/OpenMPKinds.def"
3109 template<
typename Derived>
3114 switch (E->getStmtClass()) {
3115 case Stmt::NoStmtClass:
break;
3116 #define STMT(Node, Parent) case Stmt::Node##Class: break;
3117 #define ABSTRACT_STMT(Stmt)
3118 #define EXPR(Node, Parent) \
3119 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
3120 #include "clang/AST/StmtNodes.inc"
3126 template<
typename Derived>
3135 Init = ExprTemp->getSubExpr();
3138 Init = MTE->GetTemporaryExpr();
3141 Init = Binder->getSubExpr();
3144 Init = ICE->getSubExprAsWritten();
3147 dyn_cast<CXXStdInitializerListExpr>(Init))
3148 return TransformInitializer(ILE->getSubExpr(), NotCopyInit);
3154 if (!NotCopyInit && !(Construct && Construct->isListInitialization()))
3155 return getDerived().TransformExpr(Init);
3160 return getDerived().RebuildParenListExpr(Parens.
getBegin(),
None,
3165 if (isa<ImplicitValueInitExpr>(Init))
3171 if (!Construct || isa<CXXTemporaryObjectExpr>(Construct))
3172 return getDerived().TransformExpr(Init);
3176 if (Construct && Construct->isStdInitListInitialization())
3177 return TransformInitializer(Construct->getArg(0), NotCopyInit);
3180 bool ArgChanged =
false;
3181 if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(),
3182 true, NewArgs, &ArgChanged))
3186 if (Construct->isListInitialization())
3187 return getDerived().RebuildInitList(Construct->getLocStart(), NewArgs,
3188 Construct->getLocEnd(),
3189 Construct->getType());
3192 SourceRange Parens = Construct->getParenOrBraceRange();
3196 assert(NewArgs.empty() &&
3197 "no parens or braces but have direct init with arguments?");
3200 return getDerived().RebuildParenListExpr(Parens.
getBegin(), NewArgs,
3204 template<
typename Derived>
3210 for (
unsigned I = 0;
I != NumInputs; ++
I) {
3212 if (IsCall && getDerived().DropCallArgument(Inputs[
I])) {
3220 Expr *Pattern = Expansion->getPattern();
3223 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
3224 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
3229 bool RetainExpansion =
false;
3232 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
3233 Pattern->getSourceRange(),
3235 Expand, RetainExpansion,
3244 ExprResult OutPattern = getDerived().TransformExpr(Pattern);
3248 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.
get(),
3249 Expansion->getEllipsisLoc(),
3256 Outputs.push_back(Out.
get());
3262 if (ArgChanged) *ArgChanged =
true;
3266 for (
unsigned I = 0; I != *NumExpansions; ++
I) {
3268 ExprResult Out = getDerived().TransformExpr(Pattern);
3275 Out = getDerived().RebuildPackExpansion(
3276 Out.
get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
3281 Outputs.push_back(Out.
get());
3286 if (RetainExpansion) {
3287 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
3289 ExprResult Out = getDerived().TransformExpr(Pattern);
3293 Out = getDerived().RebuildPackExpansion(
3294 Out.
get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
3298 Outputs.push_back(Out.
get());
3305 IsCall ? getDerived().TransformInitializer(Inputs[I],
false)
3306 : getDerived().TransformExpr(Inputs[I]);
3310 if (Result.
get() != Inputs[
I] && ArgChanged)
3313 Outputs.push_back(Result.
get());
3319 template<
typename Derived>
3328 Qualifiers.push_back(Qualifier);
3331 while (!Qualifiers.empty()) {
3337 if (SemaRef.BuildCXXNestedNameSpecifier(
nullptr,
3341 ObjectType,
false, SS,
3342 FirstQualifierInScope,
false))
3349 = cast_or_null<NamespaceDecl>(
3350 getDerived().TransformDecl(
3359 = cast_or_null<NamespaceAliasDecl>(
3375 cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
3384 FirstQualifierInScope, SS);
3390 (SemaRef.getLangOpts().CPlusPlus11 &&
3393 "Can't get cv-qualifiers here");
3396 diag::warn_cxx98_compat_enum_nested_name_spec);
3405 SemaRef.Diag(TL.
getBeginLoc(), diag::err_nested_name_spec_non_tag)
3406 << TL.
getType() << SS.getRange();
3413 FirstQualifierInScope =
nullptr;
3419 !getDerived().AlwaysRebuild())
3432 template<
typename Derived>
3456 NewTInfo = getDerived().TransformType(OldTInfo);
3459 NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->
getType());
3467 NewCanTy = SemaRef.Context.getCanonicalType(NewT);
3471 = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.
getNameKind(),
3480 llvm_unreachable(
"Unknown name kind.");
3483 template<
typename Derived>
3492 assert(Template &&
"qualified template name must refer to a template");
3495 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
3500 if (!getDerived().AlwaysRebuild() &&
3502 TransTemplate == Template)
3505 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
3513 FirstQualifierInScope =
nullptr;
3516 if (!getDerived().AlwaysRebuild() &&
3521 if (DTN->isIdentifier()) {
3522 return getDerived().RebuildTemplateName(SS,
3523 *DTN->getIdentifier(),
3526 FirstQualifierInScope);
3529 return getDerived().RebuildTemplateName(SS, DTN->getOperator(), NameLoc,
3535 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
3540 if (!getDerived().AlwaysRebuild() &&
3541 TransTemplate == Template)
3550 = cast_or_null<TemplateTemplateParmDecl>(
3551 getDerived().TransformDecl(NameLoc, SubstPack->getParameterPack()));
3555 if (!getDerived().AlwaysRebuild() &&
3556 TransParam == SubstPack->getParameterPack())
3559 return getDerived().RebuildTemplateName(TransParam,
3560 SubstPack->getArgumentPack());
3564 llvm_unreachable(
"overloaded function decl survived to here");
3567 template<
typename Derived>
3574 llvm_unreachable(
"null template argument in TreeTransform");
3579 SemaRef.Context.getTrivialTypeSourceInfo(Arg.
getAsType(), Loc));
3588 Builder.
MakeTrivial(SemaRef.Context, DTN->getQualifier(), Loc);
3590 Builder.
MakeTrivial(SemaRef.Context, QTN->getQualifier(), Loc);
3617 template<
typename Derived>
3628 llvm_unreachable(
"Unexpected TemplateArgument");
3635 DI = getDerived().TransformType(DI);
3636 if (!DI)
return true;
3645 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
3651 SS.
Adopt(QualifierLoc);
3653 = getDerived().TransformTemplateName(SS, Arg.
getAsTemplate(),
3664 llvm_unreachable(
"Caller should expand pack expansions");
3674 ExprResult E = getDerived().TransformExpr(InputExpr);
3675 E = SemaRef.ActOnConstantExpression(E);
3688 template<
typename Derived,
typename InputIterator>
3696 typedef typename std::iterator_traits<InputIterator>::difference_type
3713 : Self(Self), Iter(Iter) { }
3728 Self.InventTemplateArgumentLoc(*Iter, Result);
3736 return X.Iter == Y.Iter;
3741 return X.Iter != Y.Iter;
3745 template<
typename Derived>
3746 template<
typename InputIterator>
3750 for (; First !=
Last; ++First) {
3763 if (TransformTemplateArguments(PackLocIterator(*
this,
3765 PackLocIterator(*
this,
3779 = getSema().getTemplateArgumentPackExpansionPattern(
3780 In, Ellipsis, OrigNumExpansions);
3783 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
3784 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
3789 bool RetainExpansion =
false;
3791 if (getDerived().TryExpandParameterPacks(Ellipsis,
3805 if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))
3808 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,
3819 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
3822 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
3826 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
3837 if (RetainExpansion) {
3838 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
3840 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
3843 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
3855 if (getDerived().TransformTemplateArgument(In, Out, Uneval))
3869 template<
typename Derived>
3871 if (getDerived().AlreadyTransformed(T))
3876 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
3877 getDerived().getBaseLocation());
3887 template<
typename Derived>
3891 getDerived().getBaseEntity());
3892 if (getDerived().AlreadyTransformed(DI->
getType()))
3907 template<
typename Derived>
3911 #define ABSTRACT_TYPELOC(CLASS, PARENT)
3912 #define TYPELOC(CLASS, PARENT) \
3913 case TypeLoc::CLASS: \
3914 return getDerived().Transform##CLASS##Type(TLB, \
3915 T.castAs<CLASS##TypeLoc>());
3916 #include "clang/AST/TypeLocNodes.def"
3919 llvm_unreachable(
"unhandled type loc!");
3927 template<
typename Derived>
3954 = dyn_cast<SubstTemplateTypeParmType>(Result)) {
3955 QualType Replacement = SubstTypeParam->getReplacementType();
3961 Result = SemaRef.Context.getSubstTemplateTypeParmType(
3962 SubstTypeParam->getReplacedParameter(),
3965 }
else if ((AutoTy = dyn_cast<AutoType>(Result)) && AutoTy->
isDeduced()) {
3968 Qualifiers Qs = Deduced.getQualifiers();
3970 Deduced = SemaRef.Context.getQualifiedType(Deduced.getUnqualifiedType(),
3972 Result = SemaRef.Context.getAutoType(Deduced, AutoTy->
getKeyword(),
3979 SemaRef.Diag(R.getBegin(), diag::err_attr_objc_ownership_redundant)
3986 if (!Quals.
empty()) {
3987 Result = SemaRef.BuildQualifiedType(Result, T.
getBeginLoc(), Quals);
3990 TLB.
push<QualifiedTypeLoc>(Result);
3997 template<
typename Derived>
3999 TreeTransform<Derived>::TransformTypeInObjectScope(TypeLoc TL,
4000 QualType ObjectType,
4001 NamedDecl *UnqualLookup,
4003 if (getDerived().AlreadyTransformed(TL.getType()))
4006 TypeSourceInfo *TSI =
4007 TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
4009 return TSI->getTypeLoc();
4013 template<
typename Derived>
4015 TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
4016 QualType ObjectType,
4017 NamedDecl *UnqualLookup,
4019 if (getDerived().AlreadyTransformed(TSInfo->getType()))
4022 return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType,
4026 template <
typename Derived>
4027 TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope(
4028 TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup,
4031 assert(!getDerived().AlreadyTransformed(T));
4036 if (isa<TemplateSpecializationType>(T)) {
4037 TemplateSpecializationTypeLoc SpecTL =
4038 TL.castAs<TemplateSpecializationTypeLoc>();
4040 TemplateName Template
4041 = getDerived().TransformTemplateName(SS,
4042 SpecTL.getTypePtr()->getTemplateName(),
4043 SpecTL.getTemplateNameLoc(),
4044 ObjectType, UnqualLookup);
4045 if (Template.isNull())
4048 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL,
4050 }
else if (isa<DependentTemplateSpecializationType>(T)) {
4051 DependentTemplateSpecializationTypeLoc SpecTL =
4052 TL.castAs<DependentTemplateSpecializationTypeLoc>();
4054 TemplateName Template
4055 = getDerived().RebuildTemplateName(SS,
4056 *SpecTL.getTypePtr()->getIdentifier(),
4057 SpecTL.getTemplateNameLoc(),
4058 ObjectType, UnqualLookup);
4059 if (Template.isNull())
4062 Result = getDerived().TransformDependentTemplateSpecializationType(TLB,
4068 Result = getDerived().TransformType(TLB, TL);
4071 if (Result.isNull())
4074 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
4077 template <
class TyLoc>
static inline
4079 TyLoc NewT = TLB.
push<TyLoc>(T.getType());
4080 NewT.setNameLoc(T.getNameLoc());
4084 template<
typename Derived>
4085 QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
4087 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType());
4088 NewT.setBuiltinLoc(T.getBuiltinLoc());
4089 if (T.needsExtraLocalData())
4090 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs();
4094 template<
typename Derived>
4095 QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
4101 template <
typename Derived>
4102 QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB,
4103 AdjustedTypeLoc TL) {
4105 return getDerived().TransformType(TLB, TL.getOriginalLoc());
4108 template<
typename Derived>
4109 QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB,
4110 DecayedTypeLoc TL) {
4111 QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc());
4112 if (OriginalType.isNull())
4115 QualType Result = TL.getType();
4116 if (getDerived().AlwaysRebuild() ||
4117 OriginalType != TL.getOriginalLoc().getType())
4118 Result = SemaRef.Context.getDecayedType(OriginalType);
4119 TLB.push<DecayedTypeLoc>(Result);
4124 template<
typename Derived>
4125 QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
4126 PointerTypeLoc TL) {
4127 QualType PointeeType
4128 = getDerived().TransformType(TLB, TL.getPointeeLoc());
4129 if (PointeeType.isNull())
4132 QualType Result = TL.getType();
4133 if (PointeeType->getAs<ObjCObjectType>()) {
4138 Result = SemaRef.Context.getObjCObjectPointerType(PointeeType);
4140 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
4141 NewT.setStarLoc(TL.getStarLoc());
4145 if (getDerived().AlwaysRebuild() ||
4146 PointeeType != TL.getPointeeLoc().getType()) {
4147 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
4148 if (Result.isNull())
4154 TLB.TypeWasModifiedSafely(Result->getPointeeType());
4156 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result);
4157 NewT.setSigilLoc(TL.getSigilLoc());
4161 template<
typename Derived>
4163 TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
4164 BlockPointerTypeLoc TL) {
4165 QualType PointeeType
4166 = getDerived().TransformType(TLB, TL.getPointeeLoc());
4167 if (PointeeType.isNull())
4170 QualType Result = TL.getType();
4171 if (getDerived().AlwaysRebuild() ||
4172 PointeeType != TL.getPointeeLoc().getType()) {
4173 Result = getDerived().RebuildBlockPointerType(PointeeType,
4175 if (Result.isNull())
4179 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result);
4180 NewT.setSigilLoc(TL.getSigilLoc());
4188 template<
typename Derived>
4196 if (PointeeType.
isNull())
4200 if (getDerived().AlwaysRebuild() ||
4202 Result = getDerived().RebuildReferenceType(PointeeType,
4216 if (isa<LValueReferenceType>(Result))
4225 template<
typename Derived>
4229 return TransformReferenceType(TLB, TL);
4232 template<
typename Derived>
4234 TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
4235 RValueReferenceTypeLoc TL) {
4236 return TransformReferenceType(TLB, TL);
4239 template<
typename Derived>
4241 TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
4242 MemberPointerTypeLoc TL) {
4243 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
4244 if (PointeeType.isNull())
4247 TypeSourceInfo* OldClsTInfo = TL.getClassTInfo();
4248 TypeSourceInfo *NewClsTInfo =
nullptr;
4250 NewClsTInfo = getDerived().TransformType(OldClsTInfo);
4255 const MemberPointerType *T = TL.getTypePtr();
4256 QualType OldClsType = QualType(T->getClass(), 0);
4257 QualType NewClsType;
4259 NewClsType = NewClsTInfo->getType();
4261 NewClsType = getDerived().TransformType(OldClsType);
4262 if (NewClsType.isNull())
4266 QualType Result = TL.getType();
4267 if (getDerived().AlwaysRebuild() ||
4268 PointeeType != T->getPointeeType() ||
4269 NewClsType != OldClsType) {
4270 Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType,
4272 if (Result.isNull())
4278 const MemberPointerType *MPT = Result->getAs<MemberPointerType>();
4279 if (MPT && PointeeType != MPT->getPointeeType()) {
4280 assert(isa<AdjustedType>(MPT->getPointeeType()));
4281 TLB.push<AdjustedTypeLoc>(MPT->getPointeeType());
4284 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
4285 NewTL.setSigilLoc(TL.getSigilLoc());
4286 NewTL.setClassTInfo(NewClsTInfo);
4291 template<
typename Derived>
4293 TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
4294 ConstantArrayTypeLoc TL) {
4295 const ConstantArrayType *T = TL.getTypePtr();
4296 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4297 if (ElementType.isNull())
4300 QualType Result = TL.getType();
4301 if (getDerived().AlwaysRebuild() ||
4302 ElementType != T->getElementType()) {
4303 Result = getDerived().RebuildConstantArrayType(ElementType,
4304 T->getSizeModifier(),
4306 T->getIndexTypeCVRQualifiers(),
4307 TL.getBracketsRange());
4308 if (Result.isNull())
4316 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4317 NewTL.setLBracketLoc(TL.getLBracketLoc());
4318 NewTL.setRBracketLoc(TL.getRBracketLoc());
4320 Expr *Size = TL.getSizeExpr();
4322 EnterExpressionEvaluationContext Unevaluated(SemaRef,
4324 Size = getDerived().TransformExpr(Size).template getAs<Expr>();
4325 Size = SemaRef.ActOnConstantExpression(Size).get();
4327 NewTL.setSizeExpr(Size);
4332 template<
typename Derived>
4333 QualType TreeTransform<Derived>::TransformIncompleteArrayType(
4334 TypeLocBuilder &TLB,
4335 IncompleteArrayTypeLoc TL) {
4336 const IncompleteArrayType *T = TL.getTypePtr();
4337 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4338 if (ElementType.isNull())
4341 QualType Result = TL.getType();
4342 if (getDerived().AlwaysRebuild() ||
4343 ElementType != T->getElementType()) {
4344 Result = getDerived().RebuildIncompleteArrayType(ElementType,
4345 T->getSizeModifier(),
4346 T->getIndexTypeCVRQualifiers(),
4347 TL.getBracketsRange());
4348 if (Result.isNull())
4352 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
4353 NewTL.setLBracketLoc(TL.getLBracketLoc());
4354 NewTL.setRBracketLoc(TL.getRBracketLoc());
4355 NewTL.setSizeExpr(
nullptr);
4360 template<
typename Derived>
4362 TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
4363 VariableArrayTypeLoc TL) {
4364 const VariableArrayType *T = TL.getTypePtr();
4365 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4366 if (ElementType.isNull())
4370 = getDerived().TransformExpr(T->getSizeExpr());
4371 if (SizeResult.isInvalid())
4374 Expr *Size = SizeResult.
get();
4376 QualType Result = TL.
getType();
4377 if (getDerived().AlwaysRebuild() ||
4378 ElementType != T->getElementType() ||
4379 Size != T->getSizeExpr()) {
4380 Result = getDerived().RebuildVariableArrayType(ElementType,
4381 T->getSizeModifier(),
4383 T->getIndexTypeCVRQualifiers(),
4384 TL.getBracketsRange());
4385 if (Result.isNull())
4391 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4392 NewTL.setLBracketLoc(TL.getLBracketLoc());
4393 NewTL.setRBracketLoc(TL.getRBracketLoc());
4394 NewTL.setSizeExpr(Size);
4399 template<
typename Derived>
4401 TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
4402 DependentSizedArrayTypeLoc TL) {
4403 const DependentSizedArrayType *T = TL.
getTypePtr();
4404 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4405 if (ElementType.isNull())
4409 EnterExpressionEvaluationContext Unevaluated(SemaRef,
4413 Expr *origSize = TL.getSizeExpr();
4414 if (!origSize) origSize = T->getSizeExpr();
4417 = getDerived().TransformExpr(origSize);
4418 sizeResult = SemaRef.ActOnConstantExpression(sizeResult);
4419 if (sizeResult.isInvalid())
4422 Expr *size = sizeResult.
get();
4424 QualType Result = TL.
getType();
4425 if (getDerived().AlwaysRebuild() ||
4426 ElementType != T->getElementType() ||
4428 Result = getDerived().RebuildDependentSizedArrayType(ElementType,
4429 T->getSizeModifier(),
4431 T->getIndexTypeCVRQualifiers(),
4432 TL.getBracketsRange());
4433 if (Result.isNull())
4439 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4440 NewTL.setLBracketLoc(TL.getLBracketLoc());
4441 NewTL.setRBracketLoc(TL.getRBracketLoc());
4442 NewTL.setSizeExpr(size);
4447 template<
typename Derived>
4448 QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
4449 TypeLocBuilder &TLB,
4450 DependentSizedExtVectorTypeLoc TL) {
4451 const DependentSizedExtVectorType *T = TL.
getTypePtr();
4454 QualType ElementType = getDerived().TransformType(T->getElementType());
4455 if (ElementType.isNull())
4459 EnterExpressionEvaluationContext Unevaluated(SemaRef,
4462 ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
4463 Size = SemaRef.ActOnConstantExpression(Size);
4464 if (Size.isInvalid())
4467 QualType Result = TL.getType();
4468 if (getDerived().AlwaysRebuild() ||
4469 ElementType != T->getElementType() ||
4470 Size.get() != T->getSizeExpr()) {
4471 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
4473 T->getAttributeLoc());
4474 if (Result.isNull())
4479 if (isa<DependentSizedExtVectorType>(Result)) {
4480 DependentSizedExtVectorTypeLoc NewTL
4481 = TLB.push<DependentSizedExtVectorTypeLoc>(Result);
4482 NewTL.setNameLoc(TL.getNameLoc());
4484 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
4485 NewTL.setNameLoc(TL.getNameLoc());
4491 template<
typename Derived>
4492 QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
4494 const VectorType *T = TL.getTypePtr();
4495 QualType ElementType = getDerived().TransformType(T->getElementType());
4496 if (ElementType.isNull())
4499 QualType Result = TL.getType();
4500 if (getDerived().AlwaysRebuild() ||
4501 ElementType != T->getElementType()) {
4502 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(),
4503 T->getVectorKind());
4504 if (Result.isNull())
4508 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
4509 NewTL.setNameLoc(TL.getNameLoc());
4514 template<
typename Derived>
4515 QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
4516 ExtVectorTypeLoc TL) {
4517 const VectorType *T = TL.getTypePtr();
4518 QualType ElementType = getDerived().TransformType(T->getElementType());
4519 if (ElementType.isNull())
4522 QualType Result = TL.getType();
4523 if (getDerived().AlwaysRebuild() ||
4524 ElementType != T->getElementType()) {
4525 Result = getDerived().RebuildExtVectorType(ElementType,
4526 T->getNumElements(),
4528 if (Result.isNull())
4532 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
4533 NewTL.setNameLoc(TL.getNameLoc());
4538 template <
typename Derived>
4541 bool ExpectParameterPack) {
4545 if (NumExpansions && isa<PackExpansionType>(OldDI->
getType())) {
4555 QualType Result = getDerived().TransformType(TLB,
4560 Result = RebuildPackExpansionType(Result,
4570 NewDI = TLB.getTypeSourceInfo(SemaRef.Context, Result);
4572 NewDI = getDerived().TransformType(OldDI);
4576 if (NewDI == OldDI && indexAdjustment == 0)
4593 template<
typename Derived>
4600 int indexAdjustment = 0;
4602 for (
unsigned i = 0; i != NumParams; ++i) {
4604 assert(OldParm->getFunctionScopeIndex() == i);
4608 if (OldParm->isParameterPack()) {
4613 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc();
4616 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
4617 assert(Unexpanded.size() > 0 &&
"Could not find parameter packs!");
4620 bool ShouldExpand =
false;
4621 bool RetainExpansion =
false;
4624 NumExpansions = OrigNumExpansions;
4625 if (getDerived().TryExpandParameterPacks(ExpansionTL.
getEllipsisLoc(),
4626 Pattern.getSourceRange(),
4637 getDerived().ExpandingFunctionParameterPack(OldParm);
4638 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
4641 = getDerived().TransformFunctionTypeParam(OldParm,
4648 OutParamTypes.push_back(NewParm->
getType());
4650 PVars->push_back(NewParm);
4655 if (RetainExpansion) {
4656 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4658 = getDerived().TransformFunctionTypeParam(OldParm,
4665 OutParamTypes.push_back(NewParm->
getType());
4667 PVars->push_back(NewParm);
4683 NewParm = getDerived().TransformFunctionTypeParam(OldParm,
4688 NewParm = getDerived().TransformFunctionTypeParam(
4689 OldParm, indexAdjustment,
None,
false);
4695 OutParamTypes.push_back(NewParm->
getType());
4697 PVars->push_back(NewParm);
4704 bool IsPackExpansion =
false;
4708 = dyn_cast<PackExpansionType>(OldType)) {
4710 QualType Pattern = Expansion->getPattern();
4712 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
4715 bool ShouldExpand =
false;
4716 bool RetainExpansion =
false;
4717 if (getDerived().TryExpandParameterPacks(Loc,
SourceRange(),
4728 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
4730 QualType NewType = getDerived().TransformType(Pattern);
4734 OutParamTypes.push_back(NewType);
4736 PVars->push_back(
nullptr);
4745 if (RetainExpansion) {
4746 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4747 QualType NewType = getDerived().TransformType(Pattern);
4751 OutParamTypes.push_back(NewType);
4753 PVars->push_back(
nullptr);
4758 OldType = Expansion->getPattern();
4759 IsPackExpansion =
true;
4761 NewType = getDerived().TransformType(OldType);
4763 NewType = getDerived().TransformType(OldType);
4769 if (IsPackExpansion)
4770 NewType = getSema().Context.getPackExpansionType(NewType,
4773 OutParamTypes.push_back(NewType);
4775 PVars->push_back(
nullptr);
4780 for (
unsigned i = 0, e = PVars->size(); i != e; ++i)
4782 assert(parm->getFunctionScopeIndex() == i);
4789 template<
typename Derived>
4796 TLB, TL,
nullptr, 0,
4799 ExceptionStorage, Changed);
4803 template<
typename Derived>
template<
typename Fn>
4806 unsigned ThisTypeQuals, Fn TransformExceptionSpec) {
4821 if (getDerived().TransformFunctionTypeParams(
4835 ResultType = getDerived().TransformType(TLB, TL.
getReturnLoc());
4841 ResultType = getDerived().TransformType(TLB, TL.
getReturnLoc());
4845 if (getDerived().TransformFunctionTypeParams(
4853 bool EPIChanged =
false;
4861 if (getDerived().AlwaysRebuild() || ResultType != T->
getReturnType() ||
4862 T->
getParamTypes() != llvm::makeArrayRef(ParamTypes) || EPIChanged) {
4863 Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI);
4873 for (
unsigned i = 0, e = NewTL.
getNumParams(); i != e; ++i)
4879 template<
typename Derived>
4893 NoexceptExpr = getSema().CheckBooleanCondition(
4894 NoexceptExpr.
get(), NoexceptExpr.
get()->getLocStart());
4899 NoexceptExpr = getSema().VerifyIntegerConstantExpression(
4900 NoexceptExpr.
get(),
nullptr,
4901 diag::err_noexcept_needs_constant_expression,
4923 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
4925 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
4930 bool Expand =
false;
4931 bool RetainExpansion =
false;
4935 if (getDerived().TryExpandParameterPacks(
4937 RetainExpansion, NumExpansions))
4945 QualType U = getDerived().TransformType(PackExpansion->getPattern());
4949 U = SemaRef.Context.getPackExpansionType(U, NumExpansions);
4950 Exceptions.push_back(U);
4956 for (
unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
4959 QualType U = getDerived().TransformType(PackExpansion->getPattern());
4960 if (U.
isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
4963 Exceptions.push_back(U);
4966 QualType U = getDerived().TransformType(T);
4967 if (U.
isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
4972 Exceptions.push_back(U);
4980 template<
typename Derived>
4990 if (getDerived().AlwaysRebuild() || ResultType != T->
getReturnType())
4991 Result = getDerived().RebuildFunctionNoProtoType(ResultType);
5002 template<
typename Derived> QualType
5003 TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB,
5004 UnresolvedUsingTypeLoc TL) {
5005 const UnresolvedUsingType *T = TL.getTypePtr();
5006 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl());
5010 QualType Result = TL.getType();
5011 if (getDerived().AlwaysRebuild() || D != T->getDecl()) {
5012 Result = getDerived().RebuildUnresolvedUsingType(D);
5013 if (Result.isNull())
5019 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result);
5020 NewTL.setNameLoc(TL.getNameLoc());
5025 template<
typename Derived>
5026 QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
5027 TypedefTypeLoc TL) {
5029 TypedefNameDecl *Typedef
5030 = cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5035 QualType Result = TL.getType();
5036 if (getDerived().AlwaysRebuild() ||
5037 Typedef != T->getDecl()) {
5038 Result = getDerived().RebuildTypedefType(Typedef);
5039 if (Result.isNull())
5043 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result);
5044 NewTL.setNameLoc(TL.getNameLoc());
5049 template<
typename Derived>
5050 QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
5051 TypeOfExprTypeLoc TL) {
5056 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
5060 E = SemaRef.HandleExprEvaluationContextForTypeof(E.get());
5064 QualType Result = TL.getType();
5065 if (getDerived().AlwaysRebuild() ||
5066 E.get() != TL.getUnderlyingExpr()) {
5067 Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc());
5068 if (Result.isNull())
5073 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result);
5074 NewTL.setTypeofLoc(TL.getTypeofLoc());
5075 NewTL.setLParenLoc(TL.getLParenLoc());
5076 NewTL.setRParenLoc(TL.getRParenLoc());
5081 template<
typename Derived>
5082 QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
5084 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo();
5085 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);
5089 QualType Result = TL.getType();
5090 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {
5091 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType());
5092 if (Result.isNull())
5096 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result);
5097 NewTL.setTypeofLoc(TL.getTypeofLoc());
5098 NewTL.setLParenLoc(TL.getLParenLoc());
5099 NewTL.setRParenLoc(TL.getRParenLoc());
5100 NewTL.setUnderlyingTInfo(New_Under_TI);
5105 template<
typename Derived>
5106 QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
5107 DecltypeTypeLoc TL) {
5108 const DecltypeType *T = TL.getTypePtr();
5114 ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
5118 E = getSema().ActOnDecltypeExpression(E.get());
5122 QualType Result = TL.getType();
5123 if (getDerived().AlwaysRebuild() ||
5124 E.get() != T->getUnderlyingExpr()) {
5125 Result = getDerived().RebuildDecltypeType(E.get(), TL.getNameLoc());
5126 if (Result.isNull())
5131 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
5132 NewTL.setNameLoc(TL.getNameLoc());
5137 template<
typename Derived>
5138 QualType TreeTransform<Derived>::TransformUnaryTransformType(
5139 TypeLocBuilder &TLB,
5140 UnaryTransformTypeLoc TL) {
5141 QualType Result = TL.
getType();
5142 if (Result->isDependentType()) {
5143 const UnaryTransformType *T = TL.
getTypePtr();
5145 getDerived().TransformType(TL.getUnderlyingTInfo())->getType();
5146 Result = getDerived().RebuildUnaryTransformType(NewBase,
5149 if (Result.isNull())
5153 UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result);
5154 NewTL.setKWLoc(TL.getKWLoc());
5155 NewTL.setParensRange(TL.getParensRange());
5156 NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo());
5160 template<
typename Derived>
5161 QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
5163 const AutoType *T = TL.getTypePtr();
5164 QualType OldDeduced = T->getDeducedType();
5165 QualType NewDeduced;
5166 if (!OldDeduced.isNull()) {
5167 NewDeduced = getDerived().TransformType(OldDeduced);
5168 if (NewDeduced.isNull())
5172 QualType Result = TL.getType();
5173 if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
5174 T->isDependentType()) {
5175 Result = getDerived().RebuildAutoType(NewDeduced, T->getKeyword());
5176 if (Result.isNull())
5180 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
5181 NewTL.setNameLoc(TL.getNameLoc());
5186 template<
typename Derived>
5187 QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,
5189 const RecordType *T = TL.getTypePtr();
5191 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5196 QualType Result = TL.getType();
5197 if (getDerived().AlwaysRebuild() ||
5198 Record != T->getDecl()) {
5199 Result = getDerived().RebuildRecordType(Record);
5200 if (Result.isNull())
5204 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
5205 NewTL.setNameLoc(TL.getNameLoc());
5210 template<
typename Derived>
5211 QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
5213 const EnumType *T = TL.getTypePtr();
5215 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5220 QualType Result = TL.getType();
5221 if (getDerived().AlwaysRebuild() ||
5222 Enum != T->getDecl()) {
5223 Result = getDerived().RebuildEnumType(Enum);
5224 if (Result.isNull())
5228 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result);
5229 NewTL.setNameLoc(TL.getNameLoc());
5234 template<
typename Derived>
5235 QualType TreeTransform<Derived>::TransformInjectedClassNameType(
5236 TypeLocBuilder &TLB,
5237 InjectedClassNameTypeLoc TL) {
5238 Decl *D = getDerived().TransformDecl(TL.getNameLoc(),
5239 TL.getTypePtr()->getDecl());
5240 if (!D)
return QualType();
5242 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D));
5243 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc());
5247 template<
typename Derived>
5248 QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
5249 TypeLocBuilder &TLB,
5250 TemplateTypeParmTypeLoc TL) {
5254 template<
typename Derived>
5255 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
5256 TypeLocBuilder &TLB,
5257 SubstTemplateTypeParmTypeLoc TL) {
5258 const SubstTemplateTypeParmType *T = TL.getTypePtr();
5263 TemporaryBase Rebase(*
this, TL.getNameLoc(), DeclarationName());
5264 QualType Replacement = getDerived().TransformType(T->getReplacementType());
5265 if (Replacement.isNull())
5271 = SemaRef.Context.getSubstTemplateTypeParmType(T->getReplacedParameter(),
5275 SubstTemplateTypeParmTypeLoc NewTL
5276 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
5277 NewTL.setNameLoc(TL.getNameLoc());
5282 template<
typename Derived>
5283 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
5284 TypeLocBuilder &TLB,
5285 SubstTemplateTypeParmPackTypeLoc TL) {
5289 template<
typename Derived>
5299 = getDerived().TransformTemplateName(SS, T->getTemplateName(),
5304 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template);
5307 template<
typename Derived>
5315 if (getDerived().AlwaysRebuild() ||
5317 Result = getDerived().RebuildAtomicType(ValueType, TL.
getKWLoc());
5322 AtomicTypeLoc NewTL = TLB.
push<AtomicTypeLoc>(Result);
5330 template <
typename Derived>
5331 QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB,
5333 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
5334 if (ValueType.isNull())
5337 QualType Result = TL.getType();
5338 if (getDerived().AlwaysRebuild() || ValueType != TL.getValueLoc().getType()) {
5339 Result = getDerived().RebuildPipeType(ValueType, TL.getKWLoc());
5340 if (Result.isNull())
5344 PipeTypeLoc NewTL = TLB.push<PipeTypeLoc>(Result);
5345 NewTL.setKWLoc(TL.getKWLoc());
5355 template<
typename ArgLocContainer>
5357 ArgLocContainer *Container;
5382 : Container(&Container), Index(Index) { }
5396 return Container->getArgLoc(Index);
5400 return pointer(Container->getArgLoc(Index));
5405 return X.Container == Y.Container && X.Index == Y.Index;
5415 template <
typename Derived>
5417 TypeLocBuilder &TLB,
5418 TemplateSpecializationTypeLoc TL,
5419 TemplateName Template) {
5420 TemplateArgumentListInfo NewTemplateArgs;
5421 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
5422 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
5423 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>
5425 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5426 ArgIterator(TL, TL.getNumArgs()),
5433 getDerived().RebuildTemplateSpecializationType(Template,
5434 TL.getTemplateNameLoc(),
5437 if (!Result.isNull()) {
5442 if (isa<DependentTemplateSpecializationType>(Result)) {
5443 DependentTemplateSpecializationTypeLoc NewTL
5444 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
5445 NewTL.setElaboratedKeywordLoc(SourceLocation());
5446 NewTL.setQualifierLoc(NestedNameSpecifierLoc());
5447 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5448 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5449 NewTL.setLAngleLoc(TL.getLAngleLoc());
5450 NewTL.setRAngleLoc(TL.getRAngleLoc());
5451 for (
unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
5452 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
5456 TemplateSpecializationTypeLoc NewTL
5457 = TLB.push<TemplateSpecializationTypeLoc>(Result);
5458 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5459 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5460 NewTL.setLAngleLoc(TL.getLAngleLoc());
5461 NewTL.setRAngleLoc(TL.getRAngleLoc());
5462 for (
unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
5463 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
5469 template <
typename Derived>
5480 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5489 = getSema().Context.getDependentTemplateSpecializationType(
5491 DTN->getQualifier(),
5492 DTN->getIdentifier(),
5503 for (
unsigned i = 0, e = NewTemplateArgs.
size(); i != e; ++i)
5509 = getDerived().RebuildTemplateSpecializationType(Template,
5521 for (
unsigned i = 0, e = NewTemplateArgs.
size(); i != e; ++i)
5528 template<
typename Derived>
5543 QualType NamedT = getDerived().TransformType(TLB, TL.
getNamedTypeLoc());
5544 if (NamedT.isNull())
5554 TemplateName Template = TST->getTemplateName();
5555 if (TypeAliasTemplateDecl *TAT = dyn_cast_or_null<TypeAliasTemplateDecl>(
5556 Template.getAsTemplateDecl())) {
5558 diag::err_tag_reference_non_tag) << 4;
5559 SemaRef.Diag(TAT->getLocation(), diag::note_declared_at);
5564 QualType Result = TL.
getType();
5565 if (getDerived().AlwaysRebuild() ||
5570 QualifierLoc, NamedT);
5571 if (Result.isNull())
5575 ElaboratedTypeLoc NewTL = TLB.
push<ElaboratedTypeLoc>(Result);
5577 NewTL.setQualifierLoc(QualifierLoc);
5581 template<
typename Derived>
5582 QualType TreeTransform<Derived>::TransformAttributedType(
5583 TypeLocBuilder &TLB,
5584 AttributedTypeLoc TL) {
5586 QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc());
5587 if (modifiedType.isNull())
5590 QualType result = TL.getType();
5593 if (getDerived().AlwaysRebuild() ||
5594 modifiedType != oldType->getModifiedType()) {
5597 QualType equivalentType
5598 = getDerived().TransformType(oldType->getEquivalentType());
5599 if (equivalentType.isNull())
5604 if (
auto nullability = oldType->getImmediateNullability()) {
5605 if (!modifiedType->canHaveNullability()) {
5606 SemaRef.Diag(TL.getAttrNameLoc(), diag::err_nullability_nonpointer)
5612 result = SemaRef.Context.getAttributedType(oldType->getAttrKind(),
5617 AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result);
5618 newTL.setAttrNameLoc(TL.getAttrNameLoc());
5619 if (TL.hasAttrOperand())
5620 newTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5621 if (TL.hasAttrExprOperand())
5622 newTL.setAttrExprOperand(TL.getAttrExprOperand());
5623 else if (TL.hasAttrEnumOperand())
5624 newTL.setAttrEnumOperandLoc(TL.getAttrEnumOperandLoc());
5629 template<
typename Derived>
5631 TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB,
5633 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
5637 QualType Result = TL.getType();
5638 if (getDerived().AlwaysRebuild() ||
5639 Inner != TL.getInnerLoc().getType()) {
5640 Result = getDerived().RebuildParenType(Inner);
5641 if (Result.isNull())
5645 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result);
5646 NewTL.setLParenLoc(TL.getLParenLoc());
5647 NewTL.setRParenLoc(TL.getRParenLoc());
5651 template<
typename Derived>
5652 QualType TreeTransform<Derived>::TransformDependentNameType(TypeLocBuilder &TLB,
5653 DependentNameTypeLoc TL) {
5654 const DependentNameType *T = TL.getTypePtr();
5656 NestedNameSpecifierLoc QualifierLoc
5657 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
5662 = getDerived().RebuildDependentNameType(T->getKeyword(),
5663 TL.getElaboratedKeywordLoc(),
5667 if (Result.isNull())
5670 if (
const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) {
5671 QualType NamedT = ElabT->getNamedType();
5672 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc());
5674 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
5675 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5676 NewTL.setQualifierLoc(QualifierLoc);
5678 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result);
5679 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5680 NewTL.setQualifierLoc(QualifierLoc);
5681 NewTL.setNameLoc(TL.getNameLoc());
5686 template<
typename Derived>
5689 DependentTemplateSpecializationTypeLoc TL) {
5690 NestedNameSpecifierLoc QualifierLoc;
5691 if (TL.getQualifierLoc()) {
5693 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
5699 .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc);
5702 template<
typename Derived>
5715 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5721 = getDerived().RebuildDependentTemplateSpecializationType(T->getKeyword(),
5729 if (
const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) {
5730 QualType NamedT = ElabT->getNamedType();
5739 for (
unsigned I = 0, E = NewTemplateArgs.
size();
I !=
E; ++
I)
5746 }
else if (isa<DependentTemplateSpecializationType>(Result)) {
5755 for (
unsigned I = 0, E = NewTemplateArgs.
size();
I !=
E; ++
I)
5764 for (
unsigned I = 0, E = NewTemplateArgs.
size();
I !=
E; ++
I)
5770 template<
typename Derived>
5779 if (getDerived().AlwaysRebuild() ||
5781 Result = getDerived().RebuildPackExpansionType(Pattern,
5789 PackExpansionTypeLoc NewT = TLB.
push<PackExpansionTypeLoc>(Result);
5794 template<
typename Derived>
5796 TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
5797 ObjCInterfaceTypeLoc TL) {
5799 TLB.pushFullCopy(TL);
5800 return TL.getType();
5803 template<
typename Derived>
5805 TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
5806 ObjCObjectTypeLoc TL) {
5808 QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc());
5809 if (BaseType.isNull())
5812 bool AnyChanged = BaseType != TL.getBaseLoc().getType();
5815 SmallVector<TypeSourceInfo *, 4> NewTypeArgInfos;
5816 for (
unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) {
5817 TypeSourceInfo *TypeArgInfo = TL.getTypeArgTInfo(i);
5818 TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc();
5819 QualType TypeArg = TypeArgInfo->getType();
5820 if (
auto PackExpansionLoc = TypeArgLoc.getAs<PackExpansionTypeLoc>()) {
5824 const auto *PackExpansion = PackExpansionLoc.getType()
5825 ->
castAs<PackExpansionType>();
5826 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
5827 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
5829 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
5833 TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc();
5834 bool Expand =
false;
5835 bool RetainExpansion =
false;
5836 Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
5837 if (getDerived().TryExpandParameterPacks(
5838 PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(),
5839 Unexpanded, Expand, RetainExpansion, NumExpansions))
5846 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
5848 TypeLocBuilder TypeArgBuilder;
5849 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
5850 QualType NewPatternType = getDerived().TransformType(TypeArgBuilder,
5852 if (NewPatternType.isNull())
5855 QualType NewExpansionType = SemaRef.Context.getPackExpansionType(
5856 NewPatternType, NumExpansions);
5857 auto NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(NewExpansionType);
5858 NewExpansionLoc.setEllipsisLoc(PackExpansionLoc.getEllipsisLoc());
5859 NewTypeArgInfos.push_back(
5860 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewExpansionType));
5866 for (
unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
5867 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);
5869 TypeLocBuilder TypeArgBuilder;
5870 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
5872 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder,
5874 if (NewTypeArg.isNull())
5877 NewTypeArgInfos.push_back(
5878 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
5884 TypeLocBuilder TypeArgBuilder;
5885 TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize());
5886 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder, TypeArgLoc);
5887 if (NewTypeArg.isNull())
5891 if (NewTypeArg == TypeArg) {
5892 NewTypeArgInfos.push_back(TypeArgInfo);
5896 NewTypeArgInfos.push_back(
5897 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
5901 QualType Result = TL.getType();
5902 if (getDerived().AlwaysRebuild() || AnyChanged) {
5904 Result = getDerived().RebuildObjCObjectType(
5907 TL.getTypeArgsLAngleLoc(),
5909 TL.getTypeArgsRAngleLoc(),
5910 TL.getProtocolLAngleLoc(),
5911 llvm::makeArrayRef(TL.getTypePtr()->qual_begin(),
5912 TL.getNumProtocols()),
5913 TL.getProtocolLocs(),
5914 TL.getProtocolRAngleLoc());
5916 if (Result.isNull())
5920 ObjCObjectTypeLoc NewT = TLB.push<ObjCObjectTypeLoc>(Result);
5921 assert(TL.hasBaseTypeAsWritten() &&
"Can't be dependent");
5922 NewT.setHasBaseTypeAsWritten(
true);
5923 NewT.setTypeArgsLAngleLoc(TL.getTypeArgsLAngleLoc());
5924 for (
unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)
5925 NewT.setTypeArgTInfo(i, NewTypeArgInfos[i]);
5926 NewT.setTypeArgsRAngleLoc(TL.getTypeArgsRAngleLoc());
5927 NewT.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
5928 for (
unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
5929 NewT.setProtocolLoc(i, TL.getProtocolLoc(i));
5930 NewT.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
5934 template<
typename Derived>
5936 TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
5937 ObjCObjectPointerTypeLoc TL) {
5938 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
5939 if (PointeeType.isNull())
5942 QualType Result = TL.getType();
5943 if (getDerived().AlwaysRebuild() ||
5944 PointeeType != TL.getPointeeLoc().getType()) {
5945 Result = getDerived().RebuildObjCObjectPointerType(PointeeType,
5947 if (Result.isNull())
5951 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
5952 NewT.setStarLoc(TL.getStarLoc());
5959 template<
typename Derived>
5961 TreeTransform<Derived>::TransformNullStmt(NullStmt *
S) {
5965 template<
typename Derived>
5968 return getDerived().TransformCompoundStmt(S,
false);
5971 template<
typename Derived>
5977 bool SubStmtInvalid =
false;
5978 bool SubStmtChanged =
false;
5980 for (
auto *B : S->
body()) {
5981 StmtResult Result = getDerived().TransformStmt(B);
5985 if (isa<DeclStmt>(B))
5989 SubStmtInvalid =
true;
5993 SubStmtChanged = SubStmtChanged || Result.
get() != B;
5994 Statements.push_back(Result.
getAs<
Stmt>());
6000 if (!getDerived().AlwaysRebuild() &&
6004 return getDerived().RebuildCompoundStmt(S->
getLBracLoc(),
6010 template<
typename Derived>
6012 TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
6015 EnterExpressionEvaluationContext Unevaluated(SemaRef,
6019 LHS = getDerived().TransformExpr(S->getLHS());
6020 LHS = SemaRef.ActOnConstantExpression(LHS);
6021 if (LHS.isInvalid())
6025 RHS = getDerived().TransformExpr(S->getRHS());
6026 RHS = SemaRef.ActOnConstantExpression(RHS);
6027 if (RHS.isInvalid())
6034 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
6036 S->getEllipsisLoc(),
6039 if (Case.isInvalid())
6043 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6044 if (SubStmt.isInvalid())
6048 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get());
6051 template<
typename Derived>
6053 TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
6055 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6056 if (SubStmt.isInvalid())
6060 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
6064 template<
typename Derived>
6066 TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) {
6067 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6068 if (SubStmt.isInvalid())
6071 Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(),
6078 return getDerived().RebuildLabelStmt(S->getIdentLoc(),
6079 cast<LabelDecl>(LD), SourceLocation(),
6083 template <
typename Derived>
6091 #define PRAGMA_SPELLING_ATTR(X) \
6093 return getDerived().Transform##X##Attr(cast<X##Attr>(R));
6094 #include "clang/Basic/AttrList.inc"
6100 template <
typename Derived>
6102 bool AttrsChanged =
false;
6107 const Attr *R = getDerived().TransformAttr(
I);
6108 AttrsChanged |= (
I != R);
6113 if (SubStmt.isInvalid())
6116 if (SubStmt.get() == S->
getSubStmt() && !AttrsChanged)
6119 return getDerived().RebuildAttributedStmt(S->
getAttrLoc(), Attrs,
6123 template<
typename Derived>
6125 TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
6128 VarDecl *ConditionVar =
nullptr;
6129 if (S->getConditionVariable()) {
6131 = cast_or_null<VarDecl>(
6132 getDerived().TransformDefinition(
6133 S->getConditionVariable()->getLocation(),
6134 S->getConditionVariable()));
6138 Cond = getDerived().TransformExpr(S->getCond());
6140 if (Cond.isInvalid())
6145 ExprResult CondE = getSema().ActOnBooleanCondition(
nullptr, S->getIfLoc(),
6147 if (CondE.isInvalid())
6154 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.get(), S->getIfLoc()));
6155 if (!S->getConditionVariable() && S->getCond() && !FullCond.get())
6159 StmtResult Then = getDerived().TransformStmt(S->getThen());
6160 if (Then.isInvalid())
6164 StmtResult Else = getDerived().TransformStmt(S->getElse());
6165 if (Else.isInvalid())
6168 if (!getDerived().AlwaysRebuild() &&
6169 FullCond.get() == S->getCond() &&
6170 ConditionVar == S->getConditionVariable() &&
6171 Then.get() == S->getThen() &&
6172 Else.get() == S->getElse())
6175 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar,
6177 S->getElseLoc(), Else.get());
6180 template<
typename Derived>
6182 TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
6185 VarDecl *ConditionVar =
nullptr;
6186 if (S->getConditionVariable()) {
6188 = cast_or_null<VarDecl>(
6189 getDerived().TransformDefinition(
6190 S->getConditionVariable()->getLocation(),
6191 S->getConditionVariable()));
6195 Cond = getDerived().TransformExpr(S->getCond());
6197 if (Cond.isInvalid())
6203 = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), Cond.get(),
6205 if (Switch.isInvalid())
6209 StmtResult Body = getDerived().TransformStmt(S->getBody());
6210 if (Body.isInvalid())
6214 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(),
6218 template<
typename Derived>
6220 TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
6223 VarDecl *ConditionVar =
nullptr;
6224 if (S->getConditionVariable()) {
6226 = cast_or_null<VarDecl>(
6227 getDerived().TransformDefinition(
6228 S->getConditionVariable()->getLocation(),
6229 S->getConditionVariable()));
6233 Cond = getDerived().TransformExpr(S->getCond());
6235 if (Cond.isInvalid())
6240 ExprResult CondE = getSema().ActOnBooleanCondition(
nullptr,
6243 if (CondE.isInvalid())
6249 Sema::FullExprArg FullCond(
6250 getSema().MakeFullExpr(Cond.get(), S->getWhileLoc()));
6251 if (!S->getConditionVariable() && S->getCond() && !FullCond.get())
6255 StmtResult Body = getDerived().TransformStmt(S->getBody());
6256 if (Body.isInvalid())
6259 if (!getDerived().AlwaysRebuild() &&
6260 FullCond.get() == S->getCond() &&
6261 ConditionVar == S->getConditionVariable() &&
6262 Body.get() == S->getBody())
6265 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond,
6266 ConditionVar, Body.get());
6269 template<
typename Derived>
6271 TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
6273 StmtResult Body = getDerived().TransformStmt(S->getBody());
6274 if (Body.isInvalid())
6278 ExprResult Cond = getDerived().TransformExpr(S->getCond());
6279 if (Cond.isInvalid())
6282 if (!getDerived().AlwaysRebuild() &&
6283 Cond.get() == S->getCond() &&
6284 Body.get() == S->getBody())
6287 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(),
6288 S->getWhileLoc(), Cond.get(),
6292 template<
typename Derived>
6294 TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
6296 StmtResult Init = getDerived().TransformStmt(S->getInit());
6297 if (Init.isInvalid())
6302 if (getSema().getLangOpts().OpenMP && Init.isUsable())
6303 getSema().ActOnOpenMPLoopInitialization(S->getForLoc(), Init.get());
6307 VarDecl *ConditionVar =
nullptr;
6308 if (S->getConditionVariable()) {
6310 = cast_or_null<VarDecl>(
6311 getDerived().TransformDefinition(
6312 S->getConditionVariable()->getLocation(),
6313 S->getConditionVariable()));
6317 Cond = getDerived().TransformExpr(S->getCond());
6319 if (Cond.isInvalid())
6324 ExprResult CondE = getSema().ActOnBooleanCondition(
nullptr,
6327 if (CondE.isInvalid())
6334 Sema::FullExprArg FullCond(
6335 getSema().MakeFullExpr(Cond.get(), S->getForLoc()));
6336 if (!S->getConditionVariable() && S->getCond() && !FullCond.get())
6340 ExprResult Inc = getDerived().TransformExpr(S->getInc());
6341 if (Inc.isInvalid())
6344 Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(Inc.get()));
6345 if (S->getInc() && !FullInc.get())
6349 StmtResult Body = getDerived().TransformStmt(S->getBody());
6350 if (Body.isInvalid())
6353 if (!getDerived().AlwaysRebuild() &&
6354 Init.get() == S->getInit() &&
6355 FullCond.get() == S->getCond() &&
6356 Inc.get() == S->getInc() &&
6357 Body.get() == S->getBody())
6360 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
6361 Init.get(), FullCond, ConditionVar,
6362 FullInc, S->getRParenLoc(), Body.get());
6365 template<
typename Derived>
6367 TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
6368 Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(),
6374 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
6375 cast<LabelDecl>(LD));
6378 template<
typename Derived>
6380 TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
6381 ExprResult Target = getDerived().TransformExpr(S->getTarget());
6382 if (Target.isInvalid())
6384 Target = SemaRef.MaybeCreateExprWithCleanups(Target.get());
6386 if (!getDerived().AlwaysRebuild() &&
6387 Target.get() == S->getTarget())
6390 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
6394 template<
typename Derived>
6396 TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
6400 template<
typename Derived>
6402 TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
6406 template<
typename Derived>
6408 TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
6409 ExprResult Result = getDerived().TransformInitializer(S->getRetValue(),
6411 if (Result.isInvalid())
6416 return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get());
6419 template<
typename Derived>
6421 TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
6422 bool DeclChanged =
false;
6423 SmallVector<Decl *, 4> Decls;
6424 for (
auto *D : S->decls()) {
6425 Decl *Transformed = getDerived().TransformDefinition(D->getLocation(), D);
6429 if (Transformed != D)
6432 Decls.push_back(Transformed);
6435 if (!getDerived().AlwaysRebuild() && !DeclChanged)
6438 return getDerived().RebuildDeclStmt(Decls, S->getStartLoc(), S->getEndLoc());
6441 template<
typename Derived>
6443 TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) {
6445 SmallVector<Expr*, 8> Constraints;
6446 SmallVector<Expr*, 8> Exprs;
6447 SmallVector<IdentifierInfo *, 4> Names;
6450 SmallVector<Expr*, 8> Clobbers;
6452 bool ExprsChanged =
false;
6455 for (
unsigned I = 0, E = S->getNumOutputs();
I !=
E; ++
I) {
6456 Names.push_back(S->getOutputIdentifier(
I));
6459 Constraints.push_back(S->getOutputConstraintLiteral(
I));
6462 Expr *OutputExpr = S->getOutputExpr(
I);
6463 ExprResult Result = getDerived().TransformExpr(OutputExpr);
6464 if (Result.isInvalid())
6467 ExprsChanged |= Result.
get() != OutputExpr;
6469 Exprs.push_back(Result.get());
6473 for (
unsigned I = 0, E = S->getNumInputs();
I !=
E; ++
I) {
6474 Names.push_back(S->getInputIdentifier(
I));
6477 Constraints.push_back(S->getInputConstraintLiteral(
I));
6480 Expr *InputExpr = S->getInputExpr(
I);
6481 ExprResult Result = getDerived().TransformExpr(InputExpr);
6482 if (Result.isInvalid())
6485 ExprsChanged |= Result.
get() != InputExpr;
6487 Exprs.push_back(Result.get());
6490 if (!getDerived().AlwaysRebuild() && !ExprsChanged)
6494 for (
unsigned I = 0, E = S->getNumClobbers();
I !=
E; ++
I)
6495 Clobbers.push_back(S->getClobberStringLiteral(
I));
6498 AsmString = S->getAsmString();
6499 return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(),
6500 S->isVolatile(), S->getNumOutputs(),
6501 S->getNumInputs(), Names.data(),
6502 Constraints, Exprs, AsmString.get(),
6503 Clobbers, S->getRParenLoc());
6506 template<
typename Derived>
6508 TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
6509 ArrayRef<Token> AsmToks =
6510 llvm::makeArrayRef(S->getAsmToks(), S->getNumAsmToks());
6512 bool HadError =
false, HadChange =
false;
6514 ArrayRef<Expr*> SrcExprs = S->getAllExprs();
6515 SmallVector<Expr*, 8> TransformedExprs;
6516 TransformedExprs.reserve(SrcExprs.size());
6517 for (
unsigned i = 0, e = SrcExprs.size(); i != e; ++i) {
6518 ExprResult Result = getDerived().TransformExpr(SrcExprs[i]);
6519 if (!Result.isUsable()) {
6522 HadChange |= (Result.get() != SrcExprs[i]);
6523 TransformedExprs.push_back(Result.get());
6528 if (!HadChange && !getDerived().AlwaysRebuild())
6531 return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(),
6532 AsmToks, S->getAsmString(),
6533 S->getNumOutputs(), S->getNumInputs(),
6534 S->getAllConstraints(), S->getClobbers(),
6535 TransformedExprs, S->getEndLoc());
6540 template<
typename Derived>
6542 TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) {
6544 return getDerived().TransformStmt(S->getBody());
6547 template<
typename Derived>
6549 TreeTransform<Derived>::TransformCoreturnStmt(CoreturnStmt *S) {
6550 ExprResult Result = getDerived().TransformInitializer(S->getOperand(),
6552 if (Result.isInvalid())
6557 return getDerived().RebuildCoreturnStmt(S->getKeywordLoc(), Result.get());
6560 template<
typename Derived>
6562 TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *E) {
6563 ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
6565 if (Result.isInvalid())
6570 return getDerived().RebuildCoawaitExpr(E->getKeywordLoc(), Result.get());
6573 template<
typename Derived>
6575 TreeTransform<Derived>::TransformCoyieldExpr(CoyieldExpr *E) {
6576 ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
6578 if (Result.isInvalid())
6583 return getDerived().RebuildCoyieldExpr(E->getKeywordLoc(), Result.get());
6588 template<
typename Derived>
6590 TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
6592 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
6593 if (TryBody.isInvalid())
6597 bool AnyCatchChanged =
false;
6598 SmallVector<Stmt*, 8> CatchStmts;
6599 for (
unsigned I = 0, N = S->getNumCatchStmts();
I != N; ++
I) {
6600 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(
I));
6601 if (Catch.isInvalid())
6603 if (Catch.get() != S->getCatchStmt(
I))
6604 AnyCatchChanged =
true;
6605 CatchStmts.push_back(Catch.get());
6610 if (S->getFinallyStmt()) {
6611 Finally = getDerived().TransformStmt(S->getFinallyStmt());
6612 if (Finally.isInvalid())
6617 if (!getDerived().AlwaysRebuild() &&
6618 TryBody.get() == S->getTryBody() &&
6620 Finally.get() == S->getFinallyStmt())
6624 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(),
6625 CatchStmts, Finally.get());
6628 template<
typename Derived>
6630 TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
6632 VarDecl *Var =
nullptr;
6633 if (VarDecl *FromVar = S->getCatchParamDecl()) {
6634 TypeSourceInfo *TSInfo =
nullptr;
6635 if (FromVar->getTypeSourceInfo()) {
6636 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
6643 T = TSInfo->getType();
6645 T = getDerived().TransformType(FromVar->getType());
6650 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T);
6655 StmtResult Body = getDerived().TransformStmt(S->getCatchBody());
6656 if (Body.isInvalid())
6659 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
6664 template<
typename Derived>
6666 TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
6668 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
6669 if (Body.isInvalid())
6673 if (!getDerived().AlwaysRebuild() &&
6674 Body.get() == S->getFinallyBody())
6678 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
6682 template<
typename Derived>
6684 TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
6686 if (S->getThrowExpr()) {
6687 Operand = getDerived().TransformExpr(S->getThrowExpr());
6688 if (Operand.isInvalid())
6692 if (!getDerived().AlwaysRebuild() &&
6693 Operand.get() == S->getThrowExpr())
6696 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get());
6699 template<
typename Derived>
6701 TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
6702 ObjCAtSynchronizedStmt *S) {
6704 ExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
6705 if (Object.isInvalid())
6708 getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(),
6710 if (Object.isInvalid())
6714 StmtResult Body = getDerived().TransformStmt(S->getSynchBody());
6715 if (Body.isInvalid())
6719 if (!getDerived().AlwaysRebuild() &&
6720 Object.get() == S->getSynchExpr() &&
6721 Body.get() == S->getSynchBody())
6725 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
6726 Object.get(), Body.get());
6729 template<
typename Derived>
6731 TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt(
6732 ObjCAutoreleasePoolStmt *S) {
6734 StmtResult Body = getDerived().TransformStmt(S->getSubStmt());
6735 if (Body.isInvalid())
6739 if (!getDerived().AlwaysRebuild() &&
6740 Body.get() == S->getSubStmt())
6744 return getDerived().RebuildObjCAutoreleasePoolStmt(
6745 S->getAtLoc(), Body.get());
6748 template<
typename Derived>
6750 TreeTransform<Derived>::TransformObjCForCollectionStmt(
6751 ObjCForCollectionStmt *S) {
6753 StmtResult Element = getDerived().TransformStmt(S->getElement());
6754 if (Element.isInvalid())
6758 ExprResult Collection = getDerived().TransformExpr(S->getCollection());
6759 if (Collection.isInvalid())
6763 StmtResult Body = getDerived().TransformStmt(S->getBody());
6764 if (Body.isInvalid())
6768 if (!getDerived().AlwaysRebuild() &&
6769 Element.get() == S->getElement() &&
6770 Collection.get() == S->getCollection() &&
6771 Body.get() == S->getBody())
6775 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
6782 template <
typename Derived>
6783 StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
6785 VarDecl *Var =
nullptr;
6786 if (VarDecl *ExceptionDecl = S->getExceptionDecl()) {
6788 getDerived().TransformType(ExceptionDecl->getTypeSourceInfo());
6792 Var = getDerived().RebuildExceptionDecl(
6793 ExceptionDecl, T, ExceptionDecl->getInnerLocStart(),
6794 ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier());
6795 if (!Var || Var->isInvalidDecl())
6800 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
6801 if (Handler.isInvalid())
6804 if (!getDerived().AlwaysRebuild() && !Var &&
6805 Handler.get() == S->getHandlerBlock())
6808 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get());
6811 template <
typename Derived>
6812 StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
6814 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
6815 if (TryBlock.isInvalid())
6819 bool HandlerChanged =
false;
6820 SmallVector<Stmt *, 8> Handlers;
6821 for (
unsigned I = 0, N = S->getNumHandlers();
I != N; ++
I) {
6822 StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(
I));
6823 if (Handler.isInvalid())
6826 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(
I);
6827 Handlers.push_back(Handler.getAs<
Stmt>());
6830 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
6834 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(),
6838 template<
typename Derived>
6840 TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) {
6841 StmtResult Range = getDerived().TransformStmt(S->getRangeStmt());
6842 if (Range.isInvalid())
6845 StmtResult BeginEnd = getDerived().TransformStmt(S->getBeginEndStmt());
6846 if (BeginEnd.isInvalid())
6849 ExprResult Cond = getDerived().TransformExpr(S->getCond());
6850 if (Cond.isInvalid())
6853 Cond = SemaRef.CheckBooleanCondition(Cond.get(), S->getColonLoc());
6854 if (Cond.isInvalid())
6857 Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.get());
6859 ExprResult Inc = getDerived().TransformExpr(S->getInc());
6860 if (Inc.isInvalid())
6863 Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.get());
6865 StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt());
6866 if (LoopVar.isInvalid())
6870 if (getDerived().AlwaysRebuild() ||
6871 Range.get() != S->getRangeStmt() ||
6872 BeginEnd.get() != S->getBeginEndStmt() ||
6873 Cond.get() != S->getCond() ||
6874 Inc.get() != S->getInc() ||
6875 LoopVar.get() != S->getLoopVarStmt()) {
6876 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
6878 S->getColonLoc(), Range.get(),
6879 BeginEnd.get(), Cond.get(),
6880 Inc.get(), LoopVar.get(),
6882 if (NewStmt.isInvalid())
6886 StmtResult Body = getDerived().TransformStmt(S->getBody());
6887 if (Body.isInvalid())
6892 if (Body.get() != S->getBody() && NewStmt.get() ==
S) {
6893 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
6895 S->getColonLoc(), Range.get(),
6896 BeginEnd.get(), Cond.get(),
6897 Inc.get(), LoopVar.get(),
6899 if (NewStmt.isInvalid())
6903 if (NewStmt.get() ==
S)
6906 return FinishCXXForRangeStmt(NewStmt.get(), Body.get());
6909 template<
typename Derived>
6911 TreeTransform<Derived>::TransformMSDependentExistsStmt(
6912 MSDependentExistsStmt *S) {
6914 NestedNameSpecifierLoc QualifierLoc;
6915 if (S->getQualifierLoc()) {
6917 = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc());
6923 DeclarationNameInfo NameInfo = S->getNameInfo();
6924 if (NameInfo.getName()) {
6925 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
6926 if (!NameInfo.getName())
6931 if (!getDerived().AlwaysRebuild() &&
6932 QualifierLoc == S->getQualifierLoc() &&
6933 NameInfo.getName() == S->getNameInfo().getName())
6938 SS.Adopt(QualifierLoc);
6939 bool Dependent =
false;
6940 switch (getSema().CheckMicrosoftIfExistsSymbol(
nullptr, SS, NameInfo)) {
6942 if (S->isIfExists())
6945 return new (getSema().Context) NullStmt(S->getKeywordLoc());
6948 if (S->isIfNotExists())
6951 return new (getSema().Context) NullStmt(S->getKeywordLoc());
6962 StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt());
6963 if (SubStmt.isInvalid())
6971 return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(),
6978 template<
typename Derived>
6980 TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *E) {
6981 NestedNameSpecifierLoc QualifierLoc;
6982 if (E->getQualifierLoc()) {
6984 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
6989 MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>(
6990 getDerived().TransformDecl(E->getMemberLoc(), E->getPropertyDecl()));
6995 if (Base.isInvalid())
6998 return new (SemaRef.getASTContext())
6999 MSPropertyRefExpr(Base.get(), PD, E->isArrow(),
7000 SemaRef.getASTContext().PseudoObjectTy,
VK_LValue,
7001 QualifierLoc, E->getMemberLoc());
7004 template <
typename Derived>
7005 ExprResult TreeTransform<Derived>::TransformMSPropertySubscriptExpr(
7006 MSPropertySubscriptExpr *E) {
7007 auto BaseRes = getDerived().TransformExpr(E->getBase());
7008 if (BaseRes.isInvalid())
7010 auto IdxRes = getDerived().TransformExpr(E->getIdx());
7011 if (IdxRes.isInvalid())
7014 if (!getDerived().AlwaysRebuild() &&
7015 BaseRes.get() == E->getBase() &&
7016 IdxRes.get() == E->getIdx())
7019 return getDerived().RebuildArraySubscriptExpr(
7020 BaseRes.get(), SourceLocation(), IdxRes.get(), E->getRBracketLoc());
7023 template <
typename Derived>
7024 StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) {
7025 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
7026 if (TryBlock.isInvalid())
7029 StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler());
7030 if (Handler.isInvalid())
7033 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
7034 Handler.get() == S->getHandler())
7037 return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(),
7038 TryBlock.get(), Handler.get());
7041 template <
typename Derived>
7042 StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) {
7043 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
7044 if (Block.isInvalid())
7047 return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.get());
7050 template <
typename Derived>
7051 StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) {
7052 ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr());
7053 if (FilterExpr.isInvalid())
7056 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
7057 if (Block.isInvalid())
7060 return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(),
7064 template <
typename Derived>
7066 if (isa<SEHFinallyStmt>(Handler))
7067 return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler));
7069 return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler));
7072 template<
typename Derived>
7081 template <
typename Derived>
7088 TClauses.reserve(Clauses.size());
7092 getDerived().getSema().StartOpenMPClause((*I)->getClauseKind());
7093 OMPClause *Clause = getDerived().TransformOMPClause(*
I);
7094 getDerived().getSema().EndOpenMPClause();
7096 TClauses.push_back(Clause);
7098 TClauses.push_back(
nullptr);
7108 Body = getDerived().TransformStmt(
7112 getDerived().getSema().ActOnOpenMPRegionEnd(Body, TClauses);
7117 if (TClauses.size() != Clauses.size()) {
7124 DirName = cast<OMPCriticalDirective>(D)->getDirectiveName();
7125 DirName = getDerived().TransformDeclarationNameInfo(DirName);
7129 CancelRegion = cast<OMPCancellationPointDirective>(D)->getCancelRegion();
7131 CancelRegion = cast<OMPCancelDirective>(D)->getCancelRegion();
7134 return getDerived().RebuildOMPExecutableDirective(
7139 template <
typename Derived>
7143 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel, DirName,
nullptr,
7145 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7146 getDerived().getSema().EndOpenMPDSABlock(Res.
get());
7150 template <
typename Derived>
7152 TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *D) {
7153 DeclarationNameInfo DirName;
7154 getDerived().getSema().StartOpenMPDSABlock(OMPD_simd, DirName,
nullptr,
7156 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7157 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7161 template <
typename Derived>
7163 TreeTransform<Derived>::TransformOMPForDirective(OMPForDirective *D) {
7164 DeclarationNameInfo DirName;
7165 getDerived().getSema().StartOpenMPDSABlock(OMPD_for, DirName,
nullptr,
7167 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7168 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7172 template <
typename Derived>
7174 TreeTransform<Derived>::TransformOMPForSimdDirective(OMPForSimdDirective *D) {
7175 DeclarationNameInfo DirName;
7176 getDerived().getSema().StartOpenMPDSABlock(OMPD_for_simd, DirName,
nullptr,
7178 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7179 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7183 template <
typename Derived>
7185 TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *D) {
7186 DeclarationNameInfo DirName;
7187 getDerived().getSema().StartOpenMPDSABlock(OMPD_sections, DirName,
nullptr,
7189 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7190 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7194 template <
typename Derived>
7196 TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *D) {
7197 DeclarationNameInfo DirName;
7198 getDerived().getSema().StartOpenMPDSABlock(OMPD_section, DirName,
nullptr,
7200 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7201 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7205 template <
typename Derived>
7207 TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *D) {
7208 DeclarationNameInfo DirName;
7209 getDerived().getSema().StartOpenMPDSABlock(OMPD_single, DirName,
nullptr,
7211 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7212 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7216 template <
typename Derived>
7218 TreeTransform<Derived>::TransformOMPMasterDirective(OMPMasterDirective *D) {
7219 DeclarationNameInfo DirName;
7220 getDerived().getSema().StartOpenMPDSABlock(OMPD_master, DirName,
nullptr,
7222 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7223 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7227 template <
typename Derived>
7229 TreeTransform<Derived>::TransformOMPCriticalDirective(OMPCriticalDirective *D) {
7230 getDerived().getSema().StartOpenMPDSABlock(
7231 OMPD_critical, D->getDirectiveName(),
nullptr, D->getLocStart());
7232 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7233 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7237 template <
typename Derived>
7238 StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective(
7239 OMPParallelForDirective *D) {
7240 DeclarationNameInfo DirName;
7241 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for, DirName,
7242 nullptr, D->getLocStart());
7243 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7244 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7248 template <
typename Derived>
7249 StmtResult TreeTransform<Derived>::TransformOMPParallelForSimdDirective(
7250 OMPParallelForSimdDirective *D) {
7251 DeclarationNameInfo DirName;
7252 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for_simd, DirName,
7253 nullptr, D->getLocStart());
7254 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7255 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7259 template <
typename Derived>
7260 StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective(
7261 OMPParallelSectionsDirective *D) {
7262 DeclarationNameInfo DirName;
7263 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_sections, DirName,
7264 nullptr, D->getLocStart());
7265 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7266 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7270 template <
typename Derived>
7272 TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *D) {
7273 DeclarationNameInfo DirName;
7274 getDerived().getSema().StartOpenMPDSABlock(OMPD_task, DirName,
nullptr,
7276 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7277 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7281 template <
typename Derived>
7282 StmtResult TreeTransform<Derived>::TransformOMPTaskyieldDirective(
7283 OMPTaskyieldDirective *D) {
7284 DeclarationNameInfo DirName;
7285 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskyield, DirName,
nullptr,
7287 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7288 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7292 template <
typename Derived>
7294 TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *D) {
7295 DeclarationNameInfo DirName;
7296 getDerived().getSema().StartOpenMPDSABlock(OMPD_barrier, DirName,
nullptr,
7298 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7299 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7303 template <
typename Derived>
7305 TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
7306 DeclarationNameInfo DirName;
7307 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskwait, DirName,
nullptr,
7309 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7310 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7314 template <
typename Derived>
7315 StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective(
7316 OMPTaskgroupDirective *D) {
7317 DeclarationNameInfo DirName;
7318 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskgroup, DirName,
nullptr,
7320 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7321 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7325 template <
typename Derived>
7327 TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *D) {
7328 DeclarationNameInfo DirName;
7329 getDerived().getSema().StartOpenMPDSABlock(OMPD_flush, DirName,
nullptr,
7331 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7332 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7336 template <
typename Derived>
7338 TreeTransform<Derived>::TransformOMPOrderedDirective(OMPOrderedDirective *D) {
7339 DeclarationNameInfo DirName;
7340 getDerived().getSema().StartOpenMPDSABlock(OMPD_ordered, DirName,
nullptr,
7342 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7343 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7347 template <
typename Derived>
7349 TreeTransform<Derived>::TransformOMPAtomicDirective(OMPAtomicDirective *D) {
7350 DeclarationNameInfo DirName;
7351 getDerived().getSema().StartOpenMPDSABlock(OMPD_atomic, DirName,
nullptr,
7353 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7354 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7358 template <
typename Derived>
7360 TreeTransform<Derived>::TransformOMPTargetDirective(OMPTargetDirective *D) {
7361 DeclarationNameInfo DirName;
7362 getDerived().getSema().StartOpenMPDSABlock(OMPD_target, DirName,
nullptr,
7364 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7365 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7369 template <
typename Derived>
7370 StmtResult TreeTransform<Derived>::TransformOMPTargetDataDirective(
7371 OMPTargetDataDirective *D) {
7372 DeclarationNameInfo DirName;
7373 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_data, DirName,
nullptr,
7375 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7376 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7380 template <
typename Derived>
7382 TreeTransform<Derived>::TransformOMPTeamsDirective(OMPTeamsDirective *D) {
7383 DeclarationNameInfo DirName;
7384 getDerived().getSema().StartOpenMPDSABlock(OMPD_teams, DirName,
nullptr,
7386 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7387 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7391 template <
typename Derived>
7392 StmtResult TreeTransform<Derived>::TransformOMPCancellationPointDirective(
7393 OMPCancellationPointDirective *D) {
7394 DeclarationNameInfo DirName;
7395 getDerived().getSema().StartOpenMPDSABlock(OMPD_cancellation_point, DirName,
7396 nullptr, D->getLocStart());
7397 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7398 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7402 template <
typename Derived>
7404 TreeTransform<Derived>::TransformOMPCancelDirective(OMPCancelDirective *D) {
7405 DeclarationNameInfo DirName;
7406 getDerived().getSema().StartOpenMPDSABlock(OMPD_cancel, DirName,
nullptr,
7408 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7409 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7413 template <
typename Derived>
7415 TreeTransform<Derived>::TransformOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
7416 DeclarationNameInfo DirName;
7417 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop, DirName,
nullptr,
7419 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7420 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7424 template <
typename Derived>
7425 StmtResult TreeTransform<Derived>::TransformOMPTaskLoopSimdDirective(
7426 OMPTaskLoopSimdDirective *D) {
7427 DeclarationNameInfo DirName;
7428 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop_simd, DirName,
7429 nullptr, D->getLocStart());
7430 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7431 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7435 template <
typename Derived>
7436 StmtResult TreeTransform<Derived>::TransformOMPDistributeDirective(
7437 OMPDistributeDirective *D) {
7438 DeclarationNameInfo DirName;
7439 getDerived().getSema().StartOpenMPDSABlock(OMPD_distribute, DirName,
nullptr,
7441 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7442 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7449 template <
typename Derived>
7450 OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *
C) {
7451 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
7452 if (Cond.isInvalid())
7454 return getDerived().RebuildOMPIfClause(
7455 C->getNameModifier(), Cond.get(), C->getLocStart(), C->getLParenLoc(),
7456 C->getNameModifierLoc(), C->getColonLoc(), C->getLocEnd());
7459 template <
typename Derived>
7460 OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *C) {
7461 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
7462 if (Cond.isInvalid())
7464 return getDerived().RebuildOMPFinalClause(Cond.get(), C->getLocStart(),
7465 C->getLParenLoc(), C->getLocEnd());
7468 template <
typename Derived>
7470 TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *C) {
7471 ExprResult NumThreads = getDerived().TransformExpr(C->getNumThreads());
7472 if (NumThreads.isInvalid())
7474 return getDerived().RebuildOMPNumThreadsClause(
7475 NumThreads.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7478 template <
typename Derived>
7480 TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *C) {
7481 ExprResult E = getDerived().TransformExpr(C->getSafelen());
7484 return getDerived().RebuildOMPSafelenClause(
7485 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7488 template <
typename Derived>
7490 TreeTransform<Derived>::TransformOMPSimdlenClause(OMPSimdlenClause *C) {
7491 ExprResult E = getDerived().TransformExpr(C->getSimdlen());
7494 return getDerived().RebuildOMPSimdlenClause(
7495 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7498 template <
typename Derived>
7500 TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) {
7501 ExprResult E = getDerived().TransformExpr(C->getNumForLoops());
7504 return getDerived().RebuildOMPCollapseClause(
7505 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7508 template <
typename Derived>
7510 TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *C) {
7511 return getDerived().RebuildOMPDefaultClause(
7512 C->getDefaultKind(), C->getDefaultKindKwLoc(), C->getLocStart(),
7513 C->getLParenLoc(), C->getLocEnd());
7516 template <
typename Derived>
7518 TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *C) {
7519 return getDerived().RebuildOMPProcBindClause(
7520 C->getProcBindKind(), C->getProcBindKindKwLoc(), C->getLocStart(),
7521 C->getLParenLoc(), C->getLocEnd());
7524 template <
typename Derived>
7526 TreeTransform<Derived>::TransformOMPScheduleClause(OMPScheduleClause *C) {
7527 ExprResult E = getDerived().TransformExpr(C->getChunkSize());
7530 return getDerived().RebuildOMPScheduleClause(
7531 C->getFirstScheduleModifier(), C->getSecondScheduleModifier(),
7532 C->getScheduleKind(), E.get(), C->getLocStart(), C->getLParenLoc(),
7533 C->getFirstScheduleModifierLoc(), C->getSecondScheduleModifierLoc(),
7534 C->getScheduleKindLoc(), C->getCommaLoc(), C->getLocEnd());
7537 template <
typename Derived>
7539 TreeTransform<Derived>::TransformOMPOrderedClause(OMPOrderedClause *C) {
7541 if (
auto *Num = C->getNumForLoops()) {
7542 E = getDerived().TransformExpr(Num);
7546 return getDerived().RebuildOMPOrderedClause(C->getLocStart(), C->getLocEnd(),
7547 C->getLParenLoc(), E.get());
7550 template <
typename Derived>
7552 TreeTransform<Derived>::TransformOMPNowaitClause(OMPNowaitClause *C) {
7557 template <
typename Derived>
7559 TreeTransform<Derived>::TransformOMPUntiedClause(OMPUntiedClause *C) {
7564 template <
typename Derived>
7566 TreeTransform<Derived>::TransformOMPMergeableClause(OMPMergeableClause *C) {
7571 template <
typename Derived>
7572 OMPClause *TreeTransform<Derived>::TransformOMPReadClause(OMPReadClause *C) {
7577 template <
typename Derived>
7578 OMPClause *TreeTransform<Derived>::TransformOMPWriteClause(OMPWriteClause *C) {
7583 template <
typename Derived>
7585 TreeTransform<Derived>::TransformOMPUpdateClause(OMPUpdateClause *C) {
7590 template <
typename Derived>
7592 TreeTransform<Derived>::TransformOMPCaptureClause(OMPCaptureClause *C) {
7597 template <
typename Derived>
7599 TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *C) {
7604 template <
typename Derived>
7611 template <
typename Derived>
7617 template <
typename Derived>
7624 template <
typename Derived>
7626 TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) {
7628 Vars.reserve(C->varlist_size());
7629 for (
auto *VE : C->varlists()) {
7630 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7631 if (EVar.isInvalid())
7633 Vars.push_back(EVar.get());
7635 return getDerived().RebuildOMPPrivateClause(
7636 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7639 template <
typename Derived>
7640 OMPClause *TreeTransform<Derived>::TransformOMPFirstprivateClause(
7641 OMPFirstprivateClause *C) {
7643 Vars.reserve(C->varlist_size());
7644 for (
auto *VE : C->varlists()) {
7645 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7646 if (EVar.isInvalid())
7648 Vars.push_back(EVar.get());
7650 return getDerived().RebuildOMPFirstprivateClause(
7651 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7654 template <
typename Derived>
7656 TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *C) {
7658 Vars.reserve(C->varlist_size());
7659 for (
auto *VE : C->varlists()) {
7660 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7661 if (EVar.isInvalid())
7663 Vars.push_back(EVar.get());
7665 return getDerived().RebuildOMPLastprivateClause(
7666 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7669 template <
typename Derived>
7671 TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *C) {
7673 Vars.reserve(C->varlist_size());
7674 for (
auto *VE : C->varlists()) {
7675 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7676 if (EVar.isInvalid())
7678 Vars.push_back(EVar.get());
7680 return getDerived().RebuildOMPSharedClause(Vars, C->getLocStart(),
7681 C->getLParenLoc(), C->getLocEnd());
7684 template <
typename Derived>
7686 TreeTransform<Derived>::TransformOMPReductionClause(OMPReductionClause *C) {
7688 Vars.reserve(C->varlist_size());
7689 for (
auto *VE : C->varlists()) {
7690 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7691 if (EVar.isInvalid())
7693 Vars.push_back(EVar.get());
7695 CXXScopeSpec ReductionIdScopeSpec;
7696 ReductionIdScopeSpec.Adopt(C->getQualifierLoc());
7698 DeclarationNameInfo NameInfo = C->getNameInfo();
7699 if (NameInfo.getName()) {
7700 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
7701 if (!NameInfo.getName())
7704 return getDerived().RebuildOMPReductionClause(
7705 Vars, C->getLocStart(), C->getLParenLoc(), C->getColonLoc(),
7706 C->getLocEnd(), ReductionIdScopeSpec, NameInfo);
7709 template <
typename Derived>
7711 TreeTransform<Derived>::TransformOMPLinearClause(
OMPLinearClause *C) {
7713 Vars.reserve(C->varlist_size());
7714 for (
auto *VE : C->varlists()) {
7715 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7716 if (EVar.isInvalid())
7718 Vars.push_back(EVar.get());
7721 if (Step.isInvalid())
7723 return getDerived().RebuildOMPLinearClause(
7724 Vars, Step.get(), C->getLocStart(), C->getLParenLoc(), C->getModifier(),
7725 C->getModifierLoc(), C->getColonLoc(), C->getLocEnd());
7728 template <
typename Derived>
7732 Vars.reserve(C->varlist_size());
7733 for (
auto *VE : C->varlists()) {
7734 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7735 if (EVar.isInvalid())
7737 Vars.push_back(EVar.get());
7740 if (Alignment.isInvalid())
7742 return getDerived().RebuildOMPAlignedClause(
7743 Vars, Alignment.get(), C->getLocStart(), C->getLParenLoc(),
7747 template <
typename Derived>
7749 TreeTransform<Derived>::TransformOMPCopyinClause(
OMPCopyinClause *C) {
7751 Vars.reserve(C->varlist_size());
7752 for (
auto *VE : C->varlists()) {
7753 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7754 if (EVar.isInvalid())
7756 Vars.push_back(EVar.get());
7758 return getDerived().RebuildOMPCopyinClause(Vars, C->getLocStart(),
7759 C->getLParenLoc(), C->getLocEnd());
7762 template <
typename Derived>
7766 Vars.reserve(C->varlist_size());
7767 for (
auto *VE : C->varlists()) {
7768 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7769 if (EVar.isInvalid())
7771 Vars.push_back(EVar.get());
7773 return getDerived().RebuildOMPCopyprivateClause(
7774 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7777 template <
typename Derived>
7780 Vars.reserve(C->varlist_size());
7781 for (
auto *VE : C->varlists()) {
7782 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7783 if (EVar.isInvalid())
7785 Vars.push_back(EVar.get());
7787 return getDerived().RebuildOMPFlushClause(Vars, C->getLocStart(),
7788 C->getLParenLoc(), C->getLocEnd());
7791 template <
typename Derived>
7793 TreeTransform<Derived>::TransformOMPDependClause(
OMPDependClause *C) {
7795 Vars.reserve(C->varlist_size());
7796 for (
auto *VE : C->varlists()) {
7797 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7798 if (EVar.isInvalid())
7800 Vars.push_back(EVar.get());
7802 return getDerived().RebuildOMPDependClause(
7804 C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7807 template <
typename Derived>
7809 TreeTransform<Derived>::TransformOMPDeviceClause(
OMPDeviceClause *C) {
7813 return getDerived().RebuildOMPDeviceClause(
7814 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
7817 template <
typename Derived>
7820 Vars.reserve(C->varlist_size());
7821 for (
auto *VE : C->varlists()) {
7822 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7823 if (EVar.isInvalid())
7825 Vars.push_back(EVar.get());
7827 return getDerived().RebuildOMPMapClause(
7829 C->
getColonLoc(), Vars, C->getLocStart(), C->getLParenLoc(),
7833 template <
typename Derived>
7839 return getDerived().RebuildOMPNumTeamsClause(
7840 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
7843 template <
typename Derived>
7849 return getDerived().RebuildOMPThreadLimitClause(
7850 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
7853 template <
typename Derived>
7859 return getDerived().RebuildOMPPriorityClause(
7860 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
7863 template <
typename Derived>
7869 return getDerived().RebuildOMPGrainsizeClause(
7870 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
7873 template <
typename Derived>
7879 return getDerived().RebuildOMPNumTasksClause(
7880 E.get(), C->getLocStart(), C->
getLParenLoc(), C->getLocEnd());
7883 template <
typename Derived>
7888 return getDerived().RebuildOMPHintClause(E.get(), C->getLocStart(),
7895 template<
typename Derived>
7897 TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) {
7898 if (!E->isTypeDependent())
7901 return getDerived().RebuildPredefinedExpr(E->getLocation(),
7905 template<
typename Derived>
7907 TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) {
7908 NestedNameSpecifierLoc QualifierLoc;
7909 if (E->getQualifierLoc()) {
7911 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
7917 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
7922 DeclarationNameInfo NameInfo = E->getNameInfo();
7923 if (NameInfo.getName()) {
7924 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
7925 if (!NameInfo.getName())
7929 if (!getDerived().AlwaysRebuild() &&
7930 QualifierLoc == E->getQualifierLoc() &&
7931 ND == E->getDecl() &&
7932 NameInfo.getName() == E->getDecl()->getDeclName() &&
7933 !E->hasExplicitTemplateArgs()) {
7937 SemaRef.MarkDeclRefReferenced(E);
7942 TemplateArgumentListInfo TransArgs, *TemplateArgs =
nullptr;
7943 if (E->hasExplicitTemplateArgs()) {
7944 TemplateArgs = &TransArgs;
7945 TransArgs.setLAngleLoc(E->getLAngleLoc());
7946 TransArgs.setRAngleLoc(E->getRAngleLoc());
7947 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
7948 E->getNumTemplateArgs(),
7953 return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo,
7957 template<
typename Derived>
7959 TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) {
7963 template<
typename Derived>
7965 TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) {
7969 template<
typename Derived>
7971 TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) {
7975 template<
typename Derived>
7977 TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) {
7981 template<
typename Derived>
7983 TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) {
7987 template<
typename Derived>
7989 TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) {
7990 if (FunctionDecl *FD = E->getDirectCallee())
7991 SemaRef.MarkFunctionReferenced(E->getLocStart(), FD);
7992 return SemaRef.MaybeBindToTemporary(E);
7995 template<
typename Derived>
7997 TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) {
7999 getDerived().TransformExpr(E->getControllingExpr());
8000 if (ControllingExpr.isInvalid())
8003 SmallVector<Expr *, 4> AssocExprs;
8004 SmallVector<TypeSourceInfo *, 4> AssocTypes;
8005 for (
unsigned i = 0; i != E->getNumAssocs(); ++i) {
8006 TypeSourceInfo *TS = E->getAssocTypeSourceInfo(i);
8008 TypeSourceInfo *AssocType = getDerived().TransformType(TS);
8011 AssocTypes.push_back(AssocType);
8013 AssocTypes.push_back(
nullptr);
8016 ExprResult AssocExpr = getDerived().TransformExpr(E->getAssocExpr(i));
8017 if (AssocExpr.isInvalid())
8019 AssocExprs.push_back(AssocExpr.get());
8022 return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(),
8025 ControllingExpr.get(),
8030 template<
typename Derived>
8032 TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
8033 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
8034 if (SubExpr.isInvalid())
8037 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
8040 return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(),
8047 template<
typename Derived>
8051 return getDerived().TransformDependentScopeDeclRefExpr(DRE,
true,
nullptr);
8053 return getDerived().TransformExpr(E);
8056 template<
typename Derived>
8061 SubExpr = TransformAddressOfOperand(E->
getSubExpr());
8067 if (!getDerived().AlwaysRebuild() && SubExpr.
get() == E->
getSubExpr())
8075 template<
typename Derived>
8077 TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) {
8079 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
8089 bool ExprChanged =
false;
8090 typedef Sema::OffsetOfComponent Component;
8091 SmallVector<Component, 4> Components;
8092 for (
unsigned I = 0, N = E->getNumComponents();
I != N; ++
I) {
8093 const OffsetOfNode &ON = E->getComponent(
I);
8095 Comp.isBrackets =
true;
8096 Comp.LocStart = ON.getSourceRange().getBegin();
8097 Comp.LocEnd = ON.getSourceRange().getEnd();
8098 switch (ON.getKind()) {
8100 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex());
8101 ExprResult Index = getDerived().TransformExpr(FromIndex);
8102 if (Index.isInvalid())
8105 ExprChanged = ExprChanged || Index.
get() != FromIndex;
8106 Comp.isBrackets =
true;
8107 Comp.U.E = Index.get();
8113 Comp.isBrackets =
false;
8114 Comp.U.IdentInfo = ON.getFieldName();
8115 if (!Comp.U.IdentInfo)
8125 Components.push_back(Comp);
8129 if (!getDerived().AlwaysRebuild() &&
8130 Type == E->getTypeSourceInfo() &&
8135 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type,
8136 Components, E->getRParenLoc());
8139 template<
typename Derived>
8141 TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) {
8142 assert((!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) &&
8143 "opaque value expression requires transformation");
8147 template<
typename Derived>
8149 TreeTransform<Derived>::TransformTypoExpr(TypoExpr *E) {
8153 template<
typename Derived>
8155 TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) {
8162 Expr *newSyntacticForm = SemaRef.recreateSyntacticForm(E);
8163 ExprResult result = getDerived().TransformExpr(newSyntacticForm);
8164 if (result.isInvalid())
return ExprError();
8169 if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject))
8170 result = SemaRef.checkPseudoObjectRValue(result.get());
8175 template<
typename Derived>
8177 TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr(
8178 UnaryExprOrTypeTraitExpr *E) {
8179 if (E->isArgumentType()) {
8180 TypeSourceInfo *OldT = E->getArgumentTypeInfo();
8182 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
8186 if (!getDerived().AlwaysRebuild() && OldT == NewT)
8189 return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(),
8191 E->getSourceRange());
8202 TypeSourceInfo *RecoveryTSI =
nullptr;
8204 auto *PE = dyn_cast<ParenExpr>(E->getArgumentExpr());
8206 PE ? dyn_cast<DependentScopeDeclRefExpr>(PE->getSubExpr()) :
nullptr)
8207 SubExpr = getDerived().TransformParenDependentScopeDeclRefExpr(
8208 PE, DRE,
false, &RecoveryTSI);
8210 SubExpr = getDerived().TransformExpr(E->getArgumentExpr());
8213 return getDerived().RebuildUnaryExprOrTypeTrait(
8214 RecoveryTSI, E->getOperatorLoc(), E->getKind(), E->getSourceRange());
8215 }
else if (SubExpr.isInvalid())
8218 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
8221 return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(),
8222 E->getOperatorLoc(),
8224 E->getSourceRange());
8227 template<
typename Derived>
8229 TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
8230 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
8231 if (LHS.isInvalid())
8234 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
8235 if (RHS.isInvalid())
8239 if (!getDerived().AlwaysRebuild() &&
8240 LHS.get() == E->getLHS() &&
8241 RHS.get() == E->getRHS())
8244 return getDerived().RebuildArraySubscriptExpr(LHS.get(),
8245 E->getLHS()->getLocStart(),
8247 E->getRBracketLoc());
8250 template <
typename Derived>
8252 TreeTransform<Derived>::TransformOMPArraySectionExpr(OMPArraySectionExpr *E) {
8253 ExprResult Base = getDerived().TransformExpr(E->getBase());
8254 if (Base.isInvalid())
8258 if (E->getLowerBound()) {
8259 LowerBound = getDerived().TransformExpr(E->getLowerBound());
8260 if (LowerBound.isInvalid())
8265 if (E->getLength()) {
8266 Length = getDerived().TransformExpr(E->getLength());
8267 if (Length.isInvalid())
8271 if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
8272 LowerBound.get() == E->getLowerBound() && Length.get() == E->getLength())
8275 return getDerived().RebuildOMPArraySectionExpr(
8276 Base.get(), E->getBase()->getLocEnd(), LowerBound.get(), E->getColonLoc(),
8277 Length.get(), E->getRBracketLoc());
8280 template<
typename Derived>
8282 TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
8284 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
8285 if (Callee.isInvalid())
8289 bool ArgChanged =
false;
8290 SmallVector<Expr*, 8> Args;
8291 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(),
true, Args,
8295 if (!getDerived().AlwaysRebuild() &&
8296 Callee.get() == E->getCallee() &&
8298 return SemaRef.MaybeBindToTemporary(E);
8301 SourceLocation FakeLParenLoc
8302 = ((Expr *)Callee.get())->getSourceRange().getBegin();
8303 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
8308 template<
typename Derived>
8310 TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
8311 ExprResult Base = getDerived().TransformExpr(E->getBase());
8312 if (Base.isInvalid())
8315 NestedNameSpecifierLoc QualifierLoc;
8316 if (E->hasQualifier()) {
8318 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
8323 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
8326 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
8327 E->getMemberDecl()));
8331 NamedDecl *FoundDecl = E->getFoundDecl();
8332 if (FoundDecl == E->getMemberDecl()) {
8335 FoundDecl = cast_or_null<NamedDecl>(
8336 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl));
8341 if (!getDerived().AlwaysRebuild() &&
8342 Base.get() == E->getBase() &&
8343 QualifierLoc == E->getQualifierLoc() &&
8344 Member == E->getMemberDecl() &&
8345 FoundDecl == E->getFoundDecl() &&
8346 !E->hasExplicitTemplateArgs()) {
8350 SemaRef.MarkMemberReferenced(E);
8355 TemplateArgumentListInfo TransArgs;
8356 if (E->hasExplicitTemplateArgs()) {
8357 TransArgs.setLAngleLoc(E->getLAngleLoc());
8358 TransArgs.setRAngleLoc(E->getRAngleLoc());
8359 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
8360 E->getNumTemplateArgs(),
8366 SourceLocation FakeOperatorLoc =
8367 SemaRef.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd());
8373 NamedDecl *FirstQualifierInScope =
nullptr;
8375 return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc,
8379 E->getMemberNameInfo(),
8382 (E->hasExplicitTemplateArgs()
8383 ? &TransArgs :
nullptr),
8384 FirstQualifierInScope);
8387 template<
typename Derived>
8389 TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
8390 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
8391 if (LHS.isInvalid())
8394 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
8395 if (RHS.isInvalid())
8398 if (!getDerived().AlwaysRebuild() &&
8399 LHS.get() == E->getLHS() &&
8400 RHS.get() == E->getRHS())
8403 Sema::FPContractStateRAII FPContractState(getSema());
8404 getSema().FPFeatures.fp_contract = E->isFPContractable();
8406 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
8407 LHS.get(), RHS.get());
8410 template<
typename Derived>
8412 TreeTransform<Derived>::TransformCompoundAssignOperator(
8413 CompoundAssignOperator *E) {
8414 return getDerived().TransformBinaryOperator(E);
8417 template<
typename Derived>
8419 TransformBinaryConditionalOperator(BinaryConditionalOperator *e) {
8423 ExprResult commonExpr = getDerived().TransformExpr(e->getCommon());
8424 if (commonExpr.isInvalid())
8427 ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr());
8428 if (rhs.isInvalid())
8431 if (!getDerived().AlwaysRebuild() &&
8432 commonExpr.get() == e->getCommon() &&
8433 rhs.get() == e->getFalseExpr())
8436 return getDerived().RebuildConditionalOperator(commonExpr.get(),
8437 e->getQuestionLoc(),
8443 template<
typename Derived>
8445 TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) {
8446 ExprResult Cond = getDerived().TransformExpr(E->getCond());
8447 if (Cond.isInvalid())
8450 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
8451 if (LHS.isInvalid())
8454 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
8455 if (RHS.isInvalid())
8458 if (!getDerived().AlwaysRebuild() &&
8459 Cond.get() == E->getCond() &&
8460 LHS.get() == E->getLHS() &&
8461 RHS.get() == E->getRHS())
8464 return getDerived().RebuildConditionalOperator(Cond.get(),
8465 E->getQuestionLoc(),
8471 template<
typename Derived>
8473 TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) {
8476 return getDerived().TransformExpr(E->getSubExprAsWritten());
8479 template<
typename Derived>
8481 TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
8482 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
8487 = getDerived().TransformExpr(E->getSubExprAsWritten());
8488 if (SubExpr.isInvalid())
8491 if (!getDerived().AlwaysRebuild() &&
8492 Type == E->getTypeInfoAsWritten() &&
8493 SubExpr.get() == E->getSubExpr())
8496 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
8502 template<
typename Derived>
8504 TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) {
8505 TypeSourceInfo *OldT = E->getTypeSourceInfo();
8506 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
8510 ExprResult Init = getDerived().TransformExpr(E->getInitializer());
8511 if (Init.isInvalid())
8514 if (!getDerived().AlwaysRebuild() &&
8516 Init.get() == E->getInitializer())
8517 return SemaRef.MaybeBindToTemporary(E);
8523 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT,
8524 E->getInitializer()->getLocEnd(),
8528 template<
typename Derived>
8530 TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) {
8531 ExprResult Base = getDerived().TransformExpr(E->getBase());
8532 if (Base.isInvalid())
8535 if (!getDerived().AlwaysRebuild() &&
8536 Base.get() == E->getBase())
8540 SourceLocation FakeOperatorLoc =
8541 SemaRef.getLocForEndOfToken(E->getBase()->getLocEnd());
8542 return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc,
8543 E->getAccessorLoc(),
8547 template<
typename Derived>
8549 TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) {
8550 if (InitListExpr *Syntactic = E->getSyntacticForm())
8553 bool InitChanged =
false;
8555 SmallVector<Expr*, 4>
Inits;
8556 if (getDerived().TransformExprs(E->getInits(), E->getNumInits(),
false,
8557 Inits, &InitChanged))
8560 if (!getDerived().AlwaysRebuild() && !InitChanged) {
8567 return getDerived().RebuildInitList(E->getLBraceLoc(),
Inits,
8568 E->getRBraceLoc(), E->getType());
8571 template<
typename Derived>
8573 TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) {
8577 ExprResult Init = getDerived().TransformExpr(E->getInit());
8578 if (Init.isInvalid())
8582 SmallVector<Expr*, 4> ArrayExprs;
8583 bool ExprChanged =
false;
8585 DEnd = E->designators_end();
8587 if (D->isFieldDesignator()) {
8594 if (D->isArrayDesignator()) {
8595 ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D));
8596 if (Index.isInvalid())
8600 D->getLBracketLoc()));
8602 ExprChanged = ExprChanged || Init.
get() != E->getArrayIndex(*D);
8603 ArrayExprs.push_back(Index.get());
8607 assert(D->isArrayRangeDesignator() &&
"New kind of designator?");
8609 = getDerived().TransformExpr(E->getArrayRangeStart(*D));
8610 if (Start.isInvalid())
8613 ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D));
8614 if (End.isInvalid())
8619 D->getLBracketLoc(),
8620 D->getEllipsisLoc()));
8622 ExprChanged = ExprChanged || Start.
get() != E->getArrayRangeStart(*D) ||
8623 End.get() != E->getArrayRangeEnd(*D);
8625 ArrayExprs.push_back(Start.get());
8626 ArrayExprs.push_back(End.get());
8629 if (!getDerived().AlwaysRebuild() &&
8630 Init.get() == E->getInit() &&
8634 return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs,
8635 E->getEqualOrColonLoc(),
8636 E->usesGNUSyntax(), Init.get());
8641 template<
typename Derived>
8643 TreeTransform<Derived>::TransformDesignatedInitUpdateExpr(
8644 DesignatedInitUpdateExpr *E) {
8645 llvm_unreachable(
"Unexpected DesignatedInitUpdateExpr in syntactic form of "
8650 template<
typename Derived>
8652 TreeTransform<Derived>::TransformNoInitExpr(
8654 llvm_unreachable(
"Unexpected NoInitExpr in syntactic form of initializer");
8658 template<
typename Derived>
8660 TreeTransform<Derived>::TransformImplicitValueInitExpr(
8661 ImplicitValueInitExpr *E) {
8662 TemporaryBase Rebase(*
this, E->getLocStart(), DeclarationName());
8666 QualType T = getDerived().TransformType(E->getType());
8670 if (!getDerived().AlwaysRebuild() &&
8674 return getDerived().RebuildImplicitValueInitExpr(T);
8677 template<
typename Derived>
8679 TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) {
8680 TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo());
8684 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
8685 if (SubExpr.isInvalid())
8688 if (!getDerived().AlwaysRebuild() &&
8689 TInfo == E->getWrittenTypeInfo() &&
8690 SubExpr.get() == E->getSubExpr())
8693 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(),
8694 TInfo, E->getRParenLoc());
8697 template<
typename Derived>
8699 TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) {
8700 bool ArgumentChanged =
false;
8701 SmallVector<Expr*, 4>
Inits;
8702 if (TransformExprs(E->getExprs(), E->getNumExprs(),
true,
Inits,
8706 return getDerived().RebuildParenListExpr(E->getLParenLoc(),
8716 template<
typename Derived>
8718 TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) {
8719 Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(),
8724 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
8725 cast<LabelDecl>(LD));
8728 template<
typename Derived>
8730 TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) {
8731 SemaRef.ActOnStartStmtExpr();
8733 = getDerived().TransformCompoundStmt(E->getSubStmt(),
true);
8734 if (SubStmt.isInvalid()) {
8735 SemaRef.ActOnStmtExprError();
8739 if (!getDerived().AlwaysRebuild() &&
8740 SubStmt.get() == E->getSubStmt()) {
8742 SemaRef.ActOnStmtExprError();
8743 return SemaRef.MaybeBindToTemporary(E);
8746 return getDerived().RebuildStmtExpr(E->getLParenLoc(),
8751 template<
typename Derived>
8753 TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) {
8754 ExprResult Cond = getDerived().TransformExpr(E->getCond());
8755 if (Cond.isInvalid())
8758 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
8759 if (LHS.isInvalid())
8762 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
8763 if (RHS.isInvalid())
8766 if (!getDerived().AlwaysRebuild() &&
8767 Cond.get() == E->getCond() &&
8768 LHS.get() == E->getLHS() &&
8769 RHS.get() == E->getRHS())
8772 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(),
8773 Cond.get(), LHS.get(), RHS.get(),
8777 template<
typename Derived>
8779 TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) {
8783 template<
typename Derived>
8785 TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
8786 switch (E->getOperator()) {
8790 case OO_Array_Delete:
8791 llvm_unreachable(
"new and delete operators cannot use CXXOperatorCallExpr");
8795 assert(E->getNumArgs() >= 1 &&
"Object call is missing arguments");
8798 ExprResult Object = getDerived().TransformExpr(E->getArg(0));
8799 if (Object.isInvalid())
8803 SourceLocation FakeLParenLoc = SemaRef.getLocForEndOfToken(
8804 static_cast<Expr *>(Object.get())->getLocEnd());
8807 SmallVector<Expr*, 8> Args;
8808 if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1,
true,
8812 return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc,
8817 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
8819 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
8820 #include "clang/Basic/OperatorKinds.def"
8825 case OO_Conditional:
8826 llvm_unreachable(
"conditional operator is not actually overloadable");
8830 llvm_unreachable(
"not an overloaded operator?");
8833 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
8834 if (Callee.isInvalid())
8838 if (E->getOperator() == OO_Amp)
8839 First = getDerived().TransformAddressOfOperand(E->getArg(0));
8841 First = getDerived().TransformExpr(E->getArg(0));
8842 if (First.isInvalid())
8846 if (E->getNumArgs() == 2) {
8847 Second = getDerived().TransformExpr(E->getArg(1));
8848 if (Second.isInvalid())
8852 if (!getDerived().AlwaysRebuild() &&
8853 Callee.get() == E->getCallee() &&
8854 First.get() == E->getArg(0) &&
8855 (E->getNumArgs() != 2 || Second.get() == E->getArg(1)))
8856 return SemaRef.MaybeBindToTemporary(E);
8858 Sema::FPContractStateRAII FPContractState(getSema());
8859 getSema().FPFeatures.fp_contract = E->isFPContractable();
8861 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(),
8862 E->getOperatorLoc(),
8868 template<
typename Derived>
8870 TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) {
8871 return getDerived().TransformCallExpr(E);
8874 template<
typename Derived>
8876 TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
8878 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
8879 if (Callee.isInvalid())
8883 ExprResult EC = getDerived().TransformCallExpr(E->getConfig());
8888 bool ArgChanged =
false;
8889 SmallVector<Expr*, 8> Args;
8890 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(),
true, Args,
8894 if (!getDerived().AlwaysRebuild() &&
8895 Callee.get() == E->getCallee() &&
8897 return SemaRef.MaybeBindToTemporary(E);
8900 SourceLocation FakeLParenLoc
8901 = ((Expr *)Callee.get())->getSourceRange().getBegin();
8902 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
8904 E->getRParenLoc(), EC.get());
8907 template<
typename Derived>
8919 if (!getDerived().AlwaysRebuild() &&
8923 return getDerived().RebuildCXXNamedCastExpr(
8930 template<
typename Derived>
8936 template<
typename Derived>
8938 TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
8939 return getDerived().TransformCXXNamedCastExpr(E);
8942 template<
typename Derived>
8944 TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
8945 CXXReinterpretCastExpr *E) {
8946 return getDerived().TransformCXXNamedCastExpr(E);
8949 template<
typename Derived>
8951 TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) {
8952 return getDerived().TransformCXXNamedCastExpr(E);
8955 template<
typename Derived>
8957 TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
8958 CXXFunctionalCastExpr *E) {
8959 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
8964 = getDerived().TransformExpr(E->getSubExprAsWritten());
8965 if (SubExpr.isInvalid())
8968 if (!getDerived().AlwaysRebuild() &&
8969 Type == E->getTypeInfoAsWritten() &&
8970 SubExpr.get() == E->getSubExpr())
8973 return getDerived().RebuildCXXFunctionalCastExpr(Type,
8979 template<
typename Derived>
8981 TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) {
8982 if (E->isTypeOperand()) {
8983 TypeSourceInfo *TInfo
8984 = getDerived().TransformType(E->getTypeOperandSourceInfo());
8988 if (!getDerived().AlwaysRebuild() &&
8989 TInfo == E->getTypeOperandSourceInfo())
8992 return getDerived().RebuildCXXTypeidExpr(E->getType(),
9005 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
9006 if (SubExpr.isInvalid())
9009 if (!getDerived().AlwaysRebuild() &&
9010 SubExpr.get() == E->getExprOperand())
9013 return getDerived().RebuildCXXTypeidExpr(E->getType(),
9019 template<
typename Derived>
9021 TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) {
9022 if (E->isTypeOperand()) {
9023 TypeSourceInfo *TInfo
9024 = getDerived().TransformType(E->getTypeOperandSourceInfo());
9028 if (!getDerived().AlwaysRebuild() &&
9029 TInfo == E->getTypeOperandSourceInfo())
9032 return getDerived().RebuildCXXUuidofExpr(E->getType(),
9040 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
9041 if (SubExpr.isInvalid())
9044 if (!getDerived().AlwaysRebuild() &&
9045 SubExpr.get() == E->getExprOperand())
9048 return getDerived().RebuildCXXUuidofExpr(E->getType(),
9054 template<
typename Derived>
9056 TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
9060 template<
typename Derived>
9062 TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
9063 CXXNullPtrLiteralExpr *E) {
9067 template<
typename Derived>
9069 TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) {
9070 QualType T = getSema().getCurrentThisType();
9072 if (!getDerived().AlwaysRebuild() && T == E->getType()) {
9074 getSema().CheckCXXThisCapture(E->getLocStart());
9078 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit());
9081 template<
typename Derived>
9083 TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) {
9084 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
9085 if (SubExpr.isInvalid())
9088 if (!getDerived().AlwaysRebuild() &&
9089 SubExpr.get() == E->getSubExpr())
9092 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(),
9093 E->isThrownVariableInScope());
9096 template<
typename Derived>
9098 TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
9100 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(),
9105 if (!getDerived().AlwaysRebuild() &&
9106 Param == E->getParam())
9109 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param);
9112 template<
typename Derived>
9114 TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
9116 = cast_or_null<FieldDecl>(getDerived().TransformDecl(E->getLocStart(),
9121 if (!getDerived().AlwaysRebuild() && Field == E->getField())
9124 return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field);
9127 template<
typename Derived>
9129 TreeTransform<Derived>::TransformCXXScalarValueInitExpr(
9130 CXXScalarValueInitExpr *E) {
9131 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
9135 if (!getDerived().AlwaysRebuild() &&
9136 T == E->getTypeSourceInfo())
9139 return getDerived().RebuildCXXScalarValueInitExpr(T,
9140 T->getTypeLoc().getEndLoc(),
9144 template<
typename Derived>
9146 TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) {
9148 TypeSourceInfo *AllocTypeInfo
9149 = getDerived().TransformType(E->getAllocatedTypeSourceInfo());
9154 ExprResult ArraySize = getDerived().TransformExpr(E->getArraySize());
9155 if (ArraySize.isInvalid())
9159 bool ArgumentChanged =
false;
9160 SmallVector<Expr*, 8> PlacementArgs;
9161 if (getDerived().TransformExprs(E->getPlacementArgs(),
9162 E->getNumPlacementArgs(),
true,
9163 PlacementArgs, &ArgumentChanged))
9167 Expr *OldInit = E->getInitializer();
9170 NewInit = getDerived().TransformInitializer(OldInit,
true);
9171 if (NewInit.isInvalid())
9175 FunctionDecl *OperatorNew =
nullptr;
9176 if (E->getOperatorNew()) {
9177 OperatorNew = cast_or_null<FunctionDecl>(
9178 getDerived().TransformDecl(E->getLocStart(),
9179 E->getOperatorNew()));
9184 FunctionDecl *OperatorDelete =
nullptr;
9185 if (E->getOperatorDelete()) {
9186 OperatorDelete = cast_or_null<FunctionDecl>(
9187 getDerived().TransformDecl(E->getLocStart(),
9188 E->getOperatorDelete()));
9189 if (!OperatorDelete)
9193 if (!getDerived().AlwaysRebuild() &&
9194 AllocTypeInfo == E->getAllocatedTypeSourceInfo() &&
9195 ArraySize.get() == E->getArraySize() &&
9196 NewInit.get() == OldInit &&
9197 OperatorNew == E->getOperatorNew() &&
9198 OperatorDelete == E->getOperatorDelete() &&
9203 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorNew);
9205 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete);
9207 if (E->isArray() && !E->getAllocatedType()->isDependentType()) {
9208 QualType ElementType
9209 = SemaRef.Context.getBaseElementType(E->getAllocatedType());
9210 if (
const RecordType *RecordT = ElementType->getAs<RecordType>()) {
9211 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordT->getDecl());
9212 if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(Record)) {
9213 SemaRef.MarkFunctionReferenced(E->getLocStart(), Destructor);
9221 QualType AllocType = AllocTypeInfo->getType();
9222 if (!ArraySize.get()) {
9228 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType);
9231 }
else if (
const ConstantArrayType *ConsArrayT
9232 = dyn_cast<ConstantArrayType>(ArrayT)) {
9234 SemaRef.Context.getSizeType(),
9236 AllocType = ConsArrayT->getElementType();
9237 }
else if (
const DependentSizedArrayType *DepArrayT
9238 = dyn_cast<DependentSizedArrayType>(ArrayT)) {
9239 if (DepArrayT->getSizeExpr()) {
9240 ArraySize = DepArrayT->getSizeExpr();
9241 AllocType = DepArrayT->getElementType();
9246 return getDerived().RebuildCXXNewExpr(E->getLocStart(),
9251 E->getTypeIdParens(),
9255 E->getDirectInitRange(),
9259 template<
typename Derived>
9261 TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) {
9262 ExprResult Operand = getDerived().TransformExpr(E->getArgument());
9263 if (Operand.isInvalid())
9267 FunctionDecl *OperatorDelete =
nullptr;
9268 if (E->getOperatorDelete()) {
9269 OperatorDelete = cast_or_null<FunctionDecl>(
9270 getDerived().TransformDecl(E->getLocStart(),
9271 E->getOperatorDelete()));
9272 if (!OperatorDelete)
9276 if (!getDerived().AlwaysRebuild() &&
9277 Operand.get() == E->getArgument() &&
9278 OperatorDelete == E->getOperatorDelete()) {
9282 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete);
9284 if (!E->getArgument()->isTypeDependent()) {
9285 QualType Destroyed = SemaRef.Context.getBaseElementType(
9286 E->getDestroyedType());
9287 if (
const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
9288 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
9289 SemaRef.MarkFunctionReferenced(E->getLocStart(),
9290 SemaRef.LookupDestructor(Record));
9297 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(),
9298 E->isGlobalDelete(),
9303 template<
typename Derived>
9305 TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
9306 CXXPseudoDestructorExpr *E) {
9307 ExprResult Base = getDerived().TransformExpr(E->getBase());
9308 if (Base.isInvalid())
9312 bool MayBePseudoDestructor =
false;
9313 Base = SemaRef.ActOnStartCXXMemberReference(
nullptr, Base.get(),
9314 E->getOperatorLoc(),
9315 E->isArrow()? tok::arrow : tok::period,
9317 MayBePseudoDestructor);
9318 if (Base.isInvalid())
9321 QualType ObjectType = ObjectTypePtr.
get();
9322 NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc();
9325 = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType);
9330 SS.Adopt(QualifierLoc);
9332 PseudoDestructorTypeStorage Destroyed;
9333 if (E->getDestroyedTypeInfo()) {
9334 TypeSourceInfo *DestroyedTypeInfo
9335 = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(),
9336 ObjectType,
nullptr, SS);
9337 if (!DestroyedTypeInfo)
9339 Destroyed = DestroyedTypeInfo;
9340 }
else if (!ObjectType.isNull() && ObjectType->isDependentType()) {
9343 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(),
9344 E->getDestroyedTypeLoc());
9347 ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(),
9348 *E->getDestroyedTypeIdentifier(),
9349 E->getDestroyedTypeLoc(),
9357 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T),
9358 E->getDestroyedTypeLoc());
9361 TypeSourceInfo *ScopeTypeInfo =
nullptr;
9362 if (E->getScopeTypeInfo()) {
9363 CXXScopeSpec EmptySS;
9364 ScopeTypeInfo = getDerived().TransformTypeInObjectScope(
9365 E->getScopeTypeInfo(), ObjectType,
nullptr, EmptySS);
9370 return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(),
9371 E->getOperatorLoc(),
9375 E->getColonColonLoc(),
9380 template<
typename Derived>
9382 TreeTransform<Derived>::TransformUnresolvedLookupExpr(
9383 UnresolvedLookupExpr *Old) {
9384 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(),
9389 E = Old->decls_end();
I !=
E; ++
I) {
9390 NamedDecl *InstD =
static_cast<NamedDecl*
>(
9391 getDerived().TransformDecl(Old->getNameLoc(),
9396 if (isa<UsingShadowDecl>(*
I))
9405 if (isa<UsingDecl>(InstD)) {
9406 UsingDecl *UD = cast<UsingDecl>(InstD);
9407 for (
auto *
I : UD->shadows())
9421 if (Old->getQualifierLoc()) {
9422 NestedNameSpecifierLoc QualifierLoc
9423 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
9427 SS.Adopt(QualifierLoc);
9430 if (Old->getNamingClass()) {
9431 CXXRecordDecl *NamingClass
9432 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
9434 Old->getNamingClass()));
9440 R.setNamingClass(NamingClass);
9443 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
9447 if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid()) {
9448 NamedDecl *D = R.getAsSingle<NamedDecl>();
9452 if (D && D->isCXXInstanceMember()) {
9453 return SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, R,
9458 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL());
9463 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc());
9464 if (Old->hasExplicitTemplateArgs() &&
9465 getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
9466 Old->getNumTemplateArgs(),
9472 return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R,
9473 Old->requiresADL(), &TransArgs);
9476 template<
typename Derived>
9478 TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) {
9479 bool ArgChanged =
false;
9480 SmallVector<TypeSourceInfo *, 4> Args;
9481 for (
unsigned I = 0, N = E->getNumArgs();
I != N; ++
I) {
9482 TypeSourceInfo *From = E->getArg(
I);
9483 TypeLoc FromTL = From->getTypeLoc();
9484 if (!FromTL.getAs<PackExpansionTypeLoc>()) {
9486 TLB.reserve(FromTL.getFullDataSize());
9487 QualType To = getDerived().TransformType(TLB, FromTL);
9491 if (To == From->getType())
9492 Args.push_back(From);
9494 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
9503 PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>();
9504 TypeLoc PatternTL = ExpansionTL.getPatternLoc();
9505 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
9506 SemaRef.collectUnexpandedParameterPacks(PatternTL, Unexpanded);
9511 bool RetainExpansion =
false;
9512 Optional<unsigned> OrigNumExpansions =
9513 ExpansionTL.getTypePtr()->getNumExpansions();
9514 Optional<unsigned> NumExpansions = OrigNumExpansions;
9515 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
9516 PatternTL.getSourceRange(),
9518 Expand, RetainExpansion,
9526 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
9529 TLB.reserve(From->getTypeLoc().getFullDataSize());
9531 QualType To = getDerived().TransformType(TLB, PatternTL);
9535 To = getDerived().RebuildPackExpansionType(To,
9536 PatternTL.getSourceRange(),
9537 ExpansionTL.getEllipsisLoc(),
9542 PackExpansionTypeLoc ToExpansionTL
9543 = TLB.push<PackExpansionTypeLoc>(To);
9544 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
9545 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
9551 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
9552 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef,
I);
9554 TLB.reserve(PatternTL.getFullDataSize());
9555 QualType To = getDerived().TransformType(TLB, PatternTL);
9559 if (To->containsUnexpandedParameterPack()) {
9560 To = getDerived().RebuildPackExpansionType(To,
9561 PatternTL.getSourceRange(),
9562 ExpansionTL.getEllipsisLoc(),
9567 PackExpansionTypeLoc ToExpansionTL
9568 = TLB.push<PackExpansionTypeLoc>(To);
9569 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
9572 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
9575 if (!RetainExpansion)
9580 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
9583 TLB.reserve(From->getTypeLoc().getFullDataSize());
9585 QualType To = getDerived().TransformType(TLB, PatternTL);
9589 To = getDerived().RebuildPackExpansionType(To,
9590 PatternTL.getSourceRange(),
9591 ExpansionTL.getEllipsisLoc(),
9596 PackExpansionTypeLoc ToExpansionTL
9597 = TLB.push<PackExpansionTypeLoc>(To);
9598 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
9599 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
9602 if (!getDerived().AlwaysRebuild() && !ArgChanged)
9605 return getDerived().RebuildTypeTrait(E->getTrait(),
9611 template<
typename Derived>
9613 TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
9614 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo());
9618 if (!getDerived().AlwaysRebuild() &&
9619 T == E->getQueriedTypeSourceInfo())
9625 SubExpr = getDerived().TransformExpr(E->getDimensionExpression());
9626 if (SubExpr.isInvalid())
9629 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getDimensionExpression())
9633 return getDerived().RebuildArrayTypeTrait(E->getTrait(),
9640 template<
typename Derived>
9642 TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) {
9646 SubExpr = getDerived().TransformExpr(E->getQueriedExpression());
9647 if (SubExpr.isInvalid())
9650 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression())
9654 return getDerived().RebuildExpressionTrait(
9655 E->getTrait(), E->getLocStart(), SubExpr.get(), E->getLocEnd());
9658 template <
typename Derived>
9662 ExprResult NewDRE = getDerived().TransformDependentScopeDeclRefExpr(
9663 DRE, AddrTaken, RecoveryTSI);
9670 if (!getDerived().AlwaysRebuild() && NewDRE.
get() == DRE)
9672 return getDerived().RebuildParenExpr(NewDRE.
get(), PE->
getLParen(),
9676 template <
typename Derived>
9679 return TransformDependentScopeDeclRefExpr(E,
false,
9683 template<
typename Derived>
9687 bool IsAddressOfOperand,
9701 = getDerived().TransformDeclarationNameInfo(E->
getNameInfo());
9706 if (!getDerived().AlwaysRebuild() &&
9713 return getDerived().RebuildDependentScopeDeclRefExpr(
9714 QualifierLoc, TemplateKWLoc, NameInfo,
nullptr,
9715 IsAddressOfOperand, RecoveryTSI);
9724 return getDerived().RebuildDependentScopeDeclRefExpr(
9725 QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand,
9729 template<
typename Derived>
9731 TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) {
9735 if ((E->getNumArgs() == 1 ||
9736 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) &&
9737 (!getDerived().DropCallArgument(E->getArg(0))) &&
9738 !E->isListInitialization())
9739 return getDerived().TransformExpr(E->getArg(0));
9741 TemporaryBase Rebase(*
this, E->getLocStart(), DeclarationName());
9743 QualType T = getDerived().TransformType(E->getType());
9747 CXXConstructorDecl *Constructor
9748 = cast_or_null<CXXConstructorDecl>(
9749 getDerived().TransformDecl(E->getLocStart(),
9750 E->getConstructor()));
9754 bool ArgumentChanged =
false;
9755 SmallVector<Expr*, 8> Args;
9756 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(),
true, Args,
9760 if (!getDerived().AlwaysRebuild() &&
9761 T == E->getType() &&
9762 Constructor == E->getConstructor() &&
9766 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor);
9770 return getDerived().RebuildCXXConstructExpr(T, E->getLocStart(),
9771 Constructor, E->isElidable(),
9773 E->hadMultipleCandidates(),
9774 E->isListInitialization(),
9775 E->isStdInitListInitialization(),
9776 E->requiresZeroInitialization(),
9777 E->getConstructionKind(),
9778 E->getParenOrBraceRange());
9785 template<
typename Derived>
9787 TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
9788 return getDerived().TransformExpr(E->getSubExpr());
9796 template<
typename Derived>
9798 TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) {
9799 return getDerived().TransformExpr(E->getSubExpr());
9802 template<
typename Derived>
9804 TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
9805 CXXTemporaryObjectExpr *E) {
9806 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
9810 CXXConstructorDecl *Constructor
9811 = cast_or_null<CXXConstructorDecl>(
9812 getDerived().TransformDecl(E->getLocStart(),
9813 E->getConstructor()));
9817 bool ArgumentChanged =
false;
9818 SmallVector<Expr*, 8> Args;
9819 Args.reserve(E->getNumArgs());
9820 if (TransformExprs(E->getArgs(), E->getNumArgs(),
true, Args,
9824 if (!getDerived().AlwaysRebuild() &&
9825 T == E->getTypeSourceInfo() &&
9826 Constructor == E->getConstructor() &&
9829 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor);
9830 return SemaRef.MaybeBindToTemporary(E);
9834 return getDerived().RebuildCXXTemporaryObjectExpr(T,
9835 T->getTypeLoc().getEndLoc(),
9840 template<
typename Derived>
9842 TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
9845 typedef std::pair<ExprResult, QualType> InitCaptureInfoTy;
9846 SmallVector<InitCaptureInfoTy, 8> InitCaptureExprsAndTypes;
9847 InitCaptureExprsAndTypes.resize(E->explicit_capture_end() -
9848 E->explicit_capture_begin());
9850 CEnd = E->capture_end();
9852 if (!E->isInitCapture(C))
9854 EnterExpressionEvaluationContext EEEC(getSema(),
9856 ExprResult NewExprInitResult = getDerived().TransformInitializer(
9857 C->getCapturedVar()->getInit(),
9860 if (NewExprInitResult.isInvalid())
9862 Expr *NewExprInit = NewExprInitResult.
get();
9864 VarDecl *OldVD = C->getCapturedVar();
9865 QualType NewInitCaptureType =
9866 getSema().buildLambdaInitCaptureInitialization(
9867 C->getLocation(), OldVD->getType()->isReferenceType(),
9868 OldVD->getIdentifier(),
9869 C->getCapturedVar()->getInitStyle() !=
VarDecl::CInit, NewExprInit);
9870 NewExprInitResult = NewExprInit;
9871 InitCaptureExprsAndTypes[C - E->capture_begin()] =
9872 std::make_pair(NewExprInitResult, NewInitCaptureType);
9877 auto TPL = getDerived().TransformTemplateParameterList(
9878 E->getTemplateParameterList());
9884 TypeSourceInfo *NewCallOpTSI =
nullptr;
9886 TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo();
9887 FunctionProtoTypeLoc OldCallOpFPTL =
9888 OldCallOpTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>();
9890 TypeLocBuilder NewCallOpTLBuilder;
9891 SmallVector<QualType, 4> ExceptionStorage;
9892 TreeTransform *This =
this;
9893 QualType NewCallOpType = TransformFunctionProtoType(
9894 NewCallOpTLBuilder, OldCallOpFPTL,
nullptr, 0,
9895 [&](FunctionProtoType::ExceptionSpecInfo &ESI,
bool &Changed) {
9896 return This->TransformExceptionSpec(OldCallOpFPTL.getBeginLoc(), ESI,
9897 ExceptionStorage, Changed);
9899 if (NewCallOpType.isNull())
9901 NewCallOpTSI = NewCallOpTLBuilder.getTypeSourceInfo(getSema().
Context,
9905 LambdaScopeInfo *LSI = getSema().PushLambdaScope();
9906 Sema::FunctionScopeRAII FuncScopeCleanup(getSema());
9907 LSI->GLTemplateParameterList = TPL;
9910 CXXRecordDecl *Class
9911 = getSema().createLambdaClosureType(E->getIntroducerRange(),
9914 E->getCaptureDefault());
9915 getDerived().transformedLocalDecl(E->getLambdaClass(), Class);
9918 CXXMethodDecl *NewCallOperator = getSema().startLambdaDefinition(
9919 Class, E->getIntroducerRange(), NewCallOpTSI,
9920 E->getCallOperator()->getLocEnd(),
9921 NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams());
9922 LSI->CallOperator = NewCallOperator;
9924 getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
9925 getDerived().transformedLocalDecl(E->getCallOperator(), NewCallOperator);
9928 Sema::ContextRAII SavedContext(getSema(), NewCallOperator,
9932 getSema().buildLambdaScope(LSI, NewCallOperator,
9933 E->getIntroducerRange(),
9934 E->getCaptureDefault(),
9935 E->getCaptureDefaultLoc(),
9936 E->hasExplicitParameters(),
9937 E->hasExplicitResultType(),
9943 bool FinishedExplicitCaptures =
false;
9945 CEnd = E->capture_end();
9949 if (!FinishedExplicitCaptures && C->isImplicit()) {
9950 getSema().finishLambdaExplicitCaptures(LSI);
9951 FinishedExplicitCaptures =
true;
9955 if (C->capturesThis()) {
9956 getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit());
9961 if (C->capturesVLAType())
9965 if (E->isInitCapture(C)) {
9966 InitCaptureInfoTy InitExprTypePair =
9967 InitCaptureExprsAndTypes[C - E->capture_begin()];
9969 QualType InitQualType = InitExprTypePair.second;
9970 if (Init.isInvalid() || InitQualType.isNull()) {
9974 VarDecl *OldVD = C->getCapturedVar();
9975 VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl(
9976 OldVD->getLocation(), InitExprTypePair.second, OldVD->getIdentifier(),
9977 OldVD->getInitStyle(), Init.get());
9981 getDerived().transformedLocalDecl(OldVD, NewVD);
9983 getSema().buildInitCaptureField(LSI, NewVD);
9987 assert(C->capturesVariable() &&
"unexpected kind of lambda capture");
9995 SourceLocation EllipsisLoc;
9996 if (C->isPackExpansion()) {
9998 bool ShouldExpand =
false;
9999 bool RetainExpansion =
false;
10000 Optional<unsigned> NumExpansions;
10001 if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(),
10004 ShouldExpand, RetainExpansion,
10010 if (ShouldExpand) {
10014 VarDecl *Pack = C->getCapturedVar();
10015 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
10016 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(),
I);
10017 VarDecl *CapturedVar
10018 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
10020 if (!CapturedVar) {
10026 getSema().tryCaptureVariable(CapturedVar, C->getLocation(),
Kind);
10034 EllipsisLoc = C->getEllipsisLoc();
10038 VarDecl *CapturedVar
10039 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
10040 C->getCapturedVar()));
10041 if (!CapturedVar || CapturedVar->isInvalidDecl()) {
10047 getSema().tryCaptureVariable(CapturedVar, C->getLocation(),
Kind,
10050 if (!FinishedExplicitCaptures)
10051 getSema().finishLambdaExplicitCaptures(LSI);
10059 Invalid ?
StmtError() : getDerived().TransformStmt(E->getBody());
10062 FuncScopeCleanup.disable();
10064 if (Body.isInvalid()) {
10065 SavedContext.pop();
10066 getSema().ActOnLambdaError(E->getLocStart(),
nullptr,
10074 auto LSICopy = *LSI;
10075 getSema().ActOnFinishFunctionBody(NewCallOperator, Body.get(),
10077 SavedContext.pop();
10079 return getSema().BuildLambdaExpr(E->getLocStart(), Body.get()->getLocEnd(),
10083 template<
typename Derived>
10085 TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
10086 CXXUnresolvedConstructExpr *E) {
10087 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
10091 bool ArgumentChanged =
false;
10092 SmallVector<Expr*, 8> Args;
10093 Args.reserve(E->arg_size());
10094 if (getDerived().TransformExprs(E->arg_begin(), E->arg_size(),
true, Args,
10098 if (!getDerived().AlwaysRebuild() &&
10099 T == E->getTypeSourceInfo() &&
10104 return getDerived().RebuildCXXUnresolvedConstructExpr(T,
10107 E->getRParenLoc());
10110 template<
typename Derived>
10112 TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
10113 CXXDependentScopeMemberExpr *E) {
10118 QualType ObjectType;
10119 if (!E->isImplicitAccess()) {
10120 OldBase = E->getBase();
10121 Base = getDerived().TransformExpr(OldBase);
10122 if (Base.isInvalid())
10127 bool MayBePseudoDestructor =
false;
10128 Base = SemaRef.ActOnStartCXXMemberReference(
nullptr, Base.get(),
10129 E->getOperatorLoc(),
10130 E->isArrow()? tok::arrow : tok::period,
10132 MayBePseudoDestructor);
10133 if (Base.isInvalid())
10136 ObjectType = ObjectTy.
get();
10137 BaseType = ((Expr*) Base.get())->getType();
10140 BaseType = getDerived().TransformType(E->getBaseType());
10141 ObjectType = BaseType->getAs<PointerType>()->getPointeeType();
10146 NamedDecl *FirstQualifierInScope
10147 = getDerived().TransformFirstQualifierInScope(
10148 E->getFirstQualifierFoundInScope(),
10149 E->getQualifierLoc().getBeginLoc());
10151 NestedNameSpecifierLoc QualifierLoc;
10152 if (E->getQualifier()) {
10154 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(),
10156 FirstQualifierInScope);
10161 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
10167 DeclarationNameInfo NameInfo
10168 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo());
10169 if (!NameInfo.getName())
10172 if (!E->hasExplicitTemplateArgs()) {
10175 if (!getDerived().AlwaysRebuild() &&
10176 Base.get() == OldBase &&
10177 BaseType == E->getBaseType() &&
10178 QualifierLoc == E->getQualifierLoc() &&
10179 NameInfo.getName() == E->getMember() &&
10180 FirstQualifierInScope == E->getFirstQualifierFoundInScope())
10183 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
10186 E->getOperatorLoc(),
10189 FirstQualifierInScope,
10194 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
10195 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
10196 E->getNumTemplateArgs(),
10200 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
10203 E->getOperatorLoc(),
10206 FirstQualifierInScope,
10211 template<
typename Derived>
10213 TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) {
10217 if (!Old->isImplicitAccess()) {
10218 Base = getDerived().TransformExpr(Old->getBase());
10219 if (Base.isInvalid())
10221 Base = getSema().PerformMemberExprBaseConversion(Base.get(),
10223 if (Base.isInvalid())
10225 BaseType = Base.
get()->getType();
10227 BaseType = getDerived().TransformType(Old->getBaseType());
10230 NestedNameSpecifierLoc QualifierLoc;
10231 if (Old->getQualifierLoc()) {
10233 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
10238 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
10240 LookupResult R(SemaRef, Old->getMemberNameInfo(),
10245 E = Old->decls_end();
I !=
E; ++
I) {
10246 NamedDecl *InstD =
static_cast<NamedDecl*
>(
10247 getDerived().TransformDecl(Old->getMemberLoc(),
10252 if (isa<UsingShadowDecl>(*
I))
10261 if (isa<UsingDecl>(InstD)) {
10262 UsingDecl *UD = cast<UsingDecl>(InstD);
10263 for (
auto *
I : UD->shadows())
10274 if (Old->getNamingClass()) {
10275 CXXRecordDecl *NamingClass
10276 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
10277 Old->getMemberLoc(),
10278 Old->getNamingClass()));
10282 R.setNamingClass(NamingClass);
10285 TemplateArgumentListInfo TransArgs;
10286 if (Old->hasExplicitTemplateArgs()) {
10287 TransArgs.setLAngleLoc(Old->getLAngleLoc());
10288 TransArgs.setRAngleLoc(Old->getRAngleLoc());
10289 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
10290 Old->getNumTemplateArgs(),
10299 NamedDecl *FirstQualifierInScope =
nullptr;
10301 return getDerived().RebuildUnresolvedMemberExpr(Base.get(),
10303 Old->getOperatorLoc(),
10307 FirstQualifierInScope,
10309 (Old->hasExplicitTemplateArgs()
10310 ? &TransArgs :
nullptr));
10313 template<
typename Derived>
10315 TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) {
10317 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand());
10318 if (SubExpr.isInvalid())
10321 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand())
10324 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get());
10327 template<
typename Derived>
10329 TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) {
10330 ExprResult Pattern = getDerived().TransformExpr(E->getPattern());
10331 if (Pattern.isInvalid())
10334 if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern())
10337 return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(),
10338 E->getNumExpansions());
10341 template<
typename Derived>
10343 TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) {
10346 if (!E->isValueDependent())
10351 ArrayRef<TemplateArgument> PackArgs;
10352 TemplateArgument ArgStorage;
10355 if (E->isPartiallySubstituted()) {
10356 PackArgs = E->getPartialArguments();
10357 }
else if (E->isValueDependent()) {
10359 bool ShouldExpand =
false;
10360 bool RetainExpansion =
false;
10361 Optional<unsigned> NumExpansions;
10362 if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(),
10364 ShouldExpand, RetainExpansion,
10370 if (ShouldExpand) {
10371 auto *Pack = E->getPack();
10372 if (
auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Pack)) {
10373 ArgStorage = getSema().Context.getPackExpansionType(
10375 }
else if (
auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Pack)) {
10376 ArgStorage = TemplateArgument(TemplateName(TTPD), None);
10378 auto *VD = cast<ValueDecl>(Pack);
10379 ExprResult DRE = getSema().BuildDeclRefExpr(VD, VD->getType(),
10381 if (DRE.isInvalid())
10383 ArgStorage =
new (getSema().Context) PackExpansionExpr(
10384 getSema().Context.DependentTy, DRE.get(), E->getPackLoc(),
None);
10386 PackArgs = ArgStorage;
10391 if (!PackArgs.size()) {
10392 auto *Pack = cast_or_null<NamedDecl>(
10393 getDerived().TransformDecl(E->getPackLoc(), E->getPack()));
10396 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), Pack,
10401 TemplateArgumentListInfo TransformedPackArgs(E->getPackLoc(),
10404 TemporaryBase Rebase(*
this, E->getPackLoc(), getBaseEntity());
10405 typedef TemplateArgumentLocInventIterator<
10406 Derived,
const TemplateArgument*> PackLocIterator;
10407 if (TransformTemplateArguments(PackLocIterator(*
this, PackArgs.begin()),
10408 PackLocIterator(*
this, PackArgs.end()),
10409 TransformedPackArgs,
true))
10413 SmallVector<TemplateArgument, 8> Args;
10414 bool PartialSubstitution =
false;
10415 for (
auto &Loc : TransformedPackArgs.arguments()) {
10416 Args.push_back(Loc.getArgument());
10417 if (Loc.getArgument().isPackExpansion())
10418 PartialSubstitution =
true;
10421 if (PartialSubstitution)
10422 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
10424 E->getRParenLoc(),
None, Args);
10426 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
10427 E->getPackLoc(), E->getRParenLoc(),
10428 Args.size(),
None);
10431 template<
typename Derived>
10433 TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr(
10434 SubstNonTypeTemplateParmPackExpr *E) {
10439 template<
typename Derived>
10441 TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr(
10442 SubstNonTypeTemplateParmExpr *E) {
10447 template<
typename Derived>
10449 TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
10454 template<
typename Derived>
10456 TreeTransform<Derived>::TransformMaterializeTemporaryExpr(
10457 MaterializeTemporaryExpr *E) {
10458 return getDerived().TransformExpr(E->GetTemporaryExpr());
10461 template<
typename Derived>
10463 TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) {
10464 Expr *Pattern = E->getPattern();
10466 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
10467 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
10468 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
10472 bool Expand =
true;
10473 bool RetainExpansion =
false;
10474 Optional<unsigned> NumExpansions;
10475 if (getDerived().TryExpandParameterPacks(E->getEllipsisLoc(),
10476 Pattern->getSourceRange(),
10478 Expand, RetainExpansion,
10485 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
10488 E->getLHS() ? getDerived().TransformExpr(E->getLHS()) :
ExprResult();
10489 if (LHS.isInvalid())
10493 E->getRHS() ? getDerived().TransformExpr(E->getRHS()) :
ExprResult();
10494 if (RHS.isInvalid())
10497 if (!getDerived().AlwaysRebuild() &&
10498 LHS.get() == E->getLHS() && RHS.get() == E->getRHS())
10501 return getDerived().RebuildCXXFoldExpr(
10502 E->getLocStart(), LHS.get(), E->getOperator(), E->getEllipsisLoc(),
10503 RHS.get(), E->getLocEnd());
10508 ExprResult Result = getDerived().TransformExpr(E->getInit());
10509 if (Result.isInvalid())
10511 bool LeftFold = E->isLeftFold();
10515 if (!LeftFold && RetainExpansion) {
10516 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
10518 ExprResult Out = getDerived().TransformExpr(Pattern);
10519 if (Out.isInvalid())
10522 Result = getDerived().RebuildCXXFoldExpr(
10523 E->getLocStart(), Out.get(), E->getOperator(), E->getEllipsisLoc(),
10524 Result.get(), E->getLocEnd());
10525 if (Result.isInvalid())
10529 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
10530 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(
10531 getSema(), LeftFold ?
I : *NumExpansions -
I - 1);
10532 ExprResult Out = getDerived().TransformExpr(Pattern);
10533 if (Out.isInvalid())
10536 if (Out.get()->containsUnexpandedParameterPack()) {
10538 Result = getDerived().RebuildCXXFoldExpr(
10540 LeftFold ? Result.get() : Out.get(),
10541 E->getOperator(), E->getEllipsisLoc(),
10542 LeftFold ? Out.get() : Result.get(),
10544 }
else if (Result.isUsable()) {
10546 Result = getDerived().RebuildBinaryOperator(
10547 E->getEllipsisLoc(), E->getOperator(),
10548 LeftFold ? Result.get() : Out.get(),
10549 LeftFold ? Out.get() : Result.get());
10553 if (Result.isInvalid())
10559 if (LeftFold && RetainExpansion) {
10560 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
10562 ExprResult Out = getDerived().TransformExpr(Pattern);
10563 if (Out.isInvalid())
10566 Result = getDerived().RebuildCXXFoldExpr(
10567 E->getLocStart(), Result.get(),
10568 E->getOperator(), E->getEllipsisLoc(),
10569 Out.get(), E->getLocEnd());
10570 if (Result.isInvalid())
10576 if (Result.isUnset())
10577 return getDerived().RebuildEmptyCXXFoldExpr(E->getEllipsisLoc(),
10583 template<
typename Derived>
10585 TreeTransform<Derived>::TransformCXXStdInitializerListExpr(
10586 CXXStdInitializerListExpr *E) {
10587 return getDerived().TransformExpr(E->getSubExpr());
10590 template<
typename Derived>
10592 TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) {
10593 return SemaRef.MaybeBindToTemporary(E);
10596 template<
typename Derived>
10598 TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
10602 template<
typename Derived>
10604 TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) {
10605 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
10606 if (SubExpr.isInvalid())
10609 if (!getDerived().AlwaysRebuild() &&
10610 SubExpr.get() == E->getSubExpr())
10613 return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get());
10616 template<
typename Derived>
10618 TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *E) {
10620 SmallVector<Expr *, 8> Elements;
10621 bool ArgChanged =
false;
10622 if (getDerived().TransformExprs(E->getElements(), E->getNumElements(),
10623 false, Elements, &ArgChanged))
10626 if (!getDerived().AlwaysRebuild() && !ArgChanged)
10627 return SemaRef.MaybeBindToTemporary(E);
10629 return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(),
10634 template<
typename Derived>
10636 TreeTransform<Derived>::TransformObjCDictionaryLiteral(
10637 ObjCDictionaryLiteral *E) {
10639 SmallVector<ObjCDictionaryElement, 8> Elements;
10640 bool ArgChanged =
false;
10641 for (
unsigned I = 0, N = E->getNumElements();
I != N; ++
I) {
10642 ObjCDictionaryElement OrigElement = E->getKeyValueElement(
I);
10644 if (OrigElement.isPackExpansion()) {
10646 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
10647 getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded);
10648 getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded);
10649 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
10653 bool Expand =
true;
10654 bool RetainExpansion =
false;
10655 Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions;
10656 Optional<unsigned> NumExpansions = OrigNumExpansions;
10657 SourceRange PatternRange(OrigElement.Key->getLocStart(),
10658 OrigElement.Value->getLocEnd());
10659 if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc,
10662 Expand, RetainExpansion,
10670 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
10671 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
10672 if (Key.isInvalid())
10675 if (Key.get() != OrigElement.Key)
10679 if (Value.isInvalid())
10682 if (Value.get() != OrigElement.Value)
10685 ObjCDictionaryElement Expansion = {
10686 Key.
get(), Value.get(), OrigElement.EllipsisLoc, NumExpansions
10688 Elements.push_back(Expansion);
10698 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
10699 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(),
I);
10700 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
10701 if (Key.isInvalid())
10704 ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
10705 if (Value.isInvalid())
10708 ObjCDictionaryElement Element = {
10709 Key.get(), Value.get(), SourceLocation(), NumExpansions
10715 if (Key.get()->containsUnexpandedParameterPack() ||
10716 Value.get()->containsUnexpandedParameterPack())
10717 Element.EllipsisLoc = OrigElement.EllipsisLoc;
10719 Elements.push_back(Element);
10729 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
10730 if (Key.isInvalid())
10733 if (Key.get() != OrigElement.Key)
10738 = getDerived().TransformExpr(OrigElement.Value);
10739 if (Value.isInvalid())
10742 if (Value.get() != OrigElement.Value)
10745 ObjCDictionaryElement Element = {
10746 Key.
get(), Value.get(), SourceLocation(),
None
10748 Elements.push_back(Element);
10751 if (!getDerived().AlwaysRebuild() && !ArgChanged)
10752 return SemaRef.MaybeBindToTemporary(E);
10754 return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(),
10758 template<
typename Derived>
10760 TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) {
10761 TypeSourceInfo *EncodedTypeInfo
10762 = getDerived().TransformType(E->getEncodedTypeSourceInfo());
10763 if (!EncodedTypeInfo)
10766 if (!getDerived().AlwaysRebuild() &&
10767 EncodedTypeInfo == E->getEncodedTypeSourceInfo())
10770 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(),
10772 E->getRParenLoc());
10775 template<
typename Derived>
10777 TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
10782 return getDerived().TransformExpr(E->getSubExpr());
10785 template<
typename Derived>
10787 TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
10788 TypeSourceInfo *TSInfo
10789 = getDerived().TransformType(E->getTypeInfoAsWritten());
10793 ExprResult Result = getDerived().TransformExpr(E->getSubExpr());
10794 if (Result.isInvalid())
10797 if (!getDerived().AlwaysRebuild() &&
10798 TSInfo == E->getTypeInfoAsWritten() &&
10799 Result.get() == E->getSubExpr())
10802 return SemaRef.BuildObjCBridgedCast(E->getLParenLoc(), E->getBridgeKind(),
10803 E->getBridgeKeywordLoc(), TSInfo,
10807 template<
typename Derived>
10809 TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) {
10811 bool ArgChanged =
false;
10812 SmallVector<Expr*, 8> Args;
10813 Args.reserve(E->getNumArgs());
10814 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(),
false, Args,
10820 TypeSourceInfo *ReceiverTypeInfo
10821 = getDerived().TransformType(E->getClassReceiverTypeInfo());
10822 if (!ReceiverTypeInfo)
10826 if (!getDerived().AlwaysRebuild() &&
10827 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged)
10828 return SemaRef.MaybeBindToTemporary(E);
10831 SmallVector<SourceLocation, 16> SelLocs;
10832 E->getSelectorLocs(SelLocs);
10833 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo,
10836 E->getMethodDecl(),
10844 SmallVector<SourceLocation, 16> SelLocs;
10845 E->getSelectorLocs(SelLocs);
10846 return getDerived().RebuildObjCMessageExpr(E->getSuperLoc(),
10849 E->getReceiverType(),
10850 E->getMethodDecl(),
10858 "Only class and instance messages may be instantiated");
10860 = getDerived().TransformExpr(E->getInstanceReceiver());
10861 if (Receiver.isInvalid())
10865 if (!getDerived().AlwaysRebuild() &&
10866 Receiver.get() == E->getInstanceReceiver() && !ArgChanged)
10867 return SemaRef.MaybeBindToTemporary(E);
10870 SmallVector<SourceLocation, 16> SelLocs;
10871 E->getSelectorLocs(SelLocs);
10872 return getDerived().RebuildObjCMessageExpr(Receiver.get(),
10875 E->getMethodDecl(),
10881 template<
typename Derived>
10883 TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) {
10887 template<
typename Derived>
10889 TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) {
10893 template<
typename Derived>
10895 TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) {
10897 ExprResult Base = getDerived().TransformExpr(E->getBase());
10898 if (Base.isInvalid())
10904 if (!getDerived().AlwaysRebuild() &&
10905 Base.get() == E->getBase())
10908 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(),
10910 E->isArrow(), E->isFreeIvar());
10913 template<
typename Derived>
10915 TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
10918 if (!E->isObjectReceiver())
10922 ExprResult Base = getDerived().TransformExpr(E->getBase());
10923 if (Base.isInvalid())
10929 if (!getDerived().AlwaysRebuild() &&
10930 Base.get() == E->getBase())
10933 if (E->isExplicitProperty())
10934 return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
10935 E->getExplicitProperty(),
10938 return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
10939 SemaRef.Context.PseudoObjectTy,
10940 E->getImplicitPropertyGetter(),
10941 E->getImplicitPropertySetter(),
10945 template<
typename Derived>
10947 TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
10949 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
10950 if (Base.isInvalid())
10954 ExprResult Key = getDerived().TransformExpr(E->getKeyExpr());
10955 if (Key.isInvalid())
10959 if (!getDerived().AlwaysRebuild() &&
10960 Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr())
10963 return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(),
10964 Base.get(), Key.get(),
10965 E->getAtIndexMethodDecl(),
10966 E->setAtIndexMethodDecl());
10969 template<
typename Derived>
10971 TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) {
10973 ExprResult Base = getDerived().TransformExpr(E->getBase());
10974 if (Base.isInvalid())
10978 if (!getDerived().AlwaysRebuild() &&
10979 Base.get() == E->getBase())
10982 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(),
10987 template<
typename Derived>
10989 TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) {
10990 bool ArgumentChanged =
false;
10991 SmallVector<Expr*, 8> SubExprs;
10992 SubExprs.reserve(E->getNumSubExprs());
10993 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(),
false,
10994 SubExprs, &ArgumentChanged))
10997 if (!getDerived().AlwaysRebuild() &&
11001 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(),
11003 E->getRParenLoc());
11006 template<
typename Derived>
11008 TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *E) {
11009 ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr());
11010 if (SrcExpr.isInvalid())
11013 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
11017 if (!getDerived().AlwaysRebuild() &&
11018 Type == E->getTypeSourceInfo() &&
11019 SrcExpr.get() == E->getSrcExpr())
11022 return getDerived().RebuildConvertVectorExpr(E->getBuiltinLoc(),
11023 SrcExpr.get(), Type,
11024 E->getRParenLoc());
11027 template<
typename Derived>
11029 TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) {
11030 BlockDecl *oldBlock = E->getBlockDecl();
11032 SemaRef.ActOnBlockStart(E->getCaretLocation(),
nullptr);
11033 BlockScopeInfo *blockScope = SemaRef.getCurBlock();
11035 blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic());
11036 blockScope->TheDecl->setBlockMissingReturnType(
11037 oldBlock->blockMissingReturnType());
11039 SmallVector<ParmVarDecl*, 4> params;
11040 SmallVector<QualType, 4> paramTypes;
11043 if (getDerived().TransformFunctionTypeParams(E->getCaretLocation(),
11044 oldBlock->param_begin(),
11045 oldBlock->param_size(),
11046 nullptr, paramTypes, ¶ms)) {
11047 getSema().ActOnBlockError(E->getCaretLocation(),
nullptr);
11051 const FunctionProtoType *exprFunctionType = E->getFunctionType();
11052 QualType exprResultType =
11053 getDerived().TransformType(exprFunctionType->getReturnType());
11055 QualType functionType =
11056 getDerived().RebuildFunctionProtoType(exprResultType, paramTypes,
11057 exprFunctionType->getExtProtoInfo());
11058 blockScope->FunctionType = functionType;
11061 if (!params.empty())
11062 blockScope->TheDecl->setParams(params);
11064 if (!oldBlock->blockMissingReturnType()) {
11065 blockScope->HasImplicitReturnType =
false;
11066 blockScope->ReturnType = exprResultType;
11070 StmtResult body = getDerived().TransformStmt(E->getBody());
11071 if (body.isInvalid()) {
11072 getSema().ActOnBlockError(E->getCaretLocation(),
nullptr);
11079 if (!SemaRef.getDiagnostics().hasErrorOccurred()) {
11080 for (
const auto &
I : oldBlock->captures()) {
11081 VarDecl *oldCapture =
I.getVariable();
11084 if (isa<ParmVarDecl>(oldCapture) &&
11085 cast<ParmVarDecl>(oldCapture)->isParameterPack())
11088 VarDecl *newCapture =
11089 cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(),
11091 assert(blockScope->CaptureMap.count(newCapture));
11093 assert(oldBlock->capturesCXXThis() == blockScope->isCXXThisCaptured());
11097 return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(),
11101 template<
typename Derived>
11103 TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) {
11104 llvm_unreachable(
"Cannot transform asType expressions yet");
11107 template<
typename Derived>
11109 TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) {
11110 QualType RetTy = getDerived().TransformType(E->getType());
11111 bool ArgumentChanged =
false;
11112 SmallVector<Expr*, 8> SubExprs;
11113 SubExprs.reserve(E->getNumSubExprs());
11114 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(),
false,
11115 SubExprs, &ArgumentChanged))
11118 if (!getDerived().AlwaysRebuild() &&
11122 return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs,
11123 RetTy, E->getOp(), E->getRParenLoc());
11130 template<
typename Derived>
11133 return SemaRef.BuildPointerType(PointeeType, Star,
11134 getDerived().getBaseEntity());
11137 template<
typename Derived>
11140 return SemaRef.BuildBlockPointerType(PointeeType, Star,
11141 getDerived().getBaseEntity());
11144 template<
typename Derived>
11147 bool WrittenAsLValue,
11149 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue,
11150 Sigil, getDerived().getBaseEntity());
11153 template<
typename Derived>
11158 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Sigil,
11159 getDerived().getBaseEntity());
11162 template<
typename Derived>
11173 return SemaRef.BuildObjCObjectType(BaseType, Loc, TypeArgsLAngleLoc,
11174 TypeArgs, TypeArgsRAngleLoc,
11175 ProtocolLAngleLoc, Protocols, ProtocolLocs,
11180 template<
typename Derived>
11184 return SemaRef.Context.getObjCObjectPointerType(PointeeType);
11187 template<
typename Derived>
11191 const llvm::APInt *Size,
11193 unsigned IndexTypeQuals,
11195 if (SizeExpr || !Size)
11196 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr,
11197 IndexTypeQuals, BracketsRange,
11198 getDerived().getBaseEntity());
11201 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy,
11202 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy,
11203 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty
11205 const unsigned NumTypes = llvm::array_lengthof(Types);
11207 for (
unsigned I = 0;
I != NumTypes; ++
I)
11208 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[
I])) {
11209 SizeType = Types[
I];
11218 return SemaRef.BuildArrayType(ElementType, SizeMod, ArraySize,
11219 IndexTypeQuals, BracketsRange,
11220 getDerived().getBaseEntity());
11223 template<
typename Derived>
11227 const llvm::APInt &Size,
11228 unsigned IndexTypeQuals,
11230 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size,
nullptr,
11231 IndexTypeQuals, BracketsRange);
11234 template<
typename Derived>
11238 unsigned IndexTypeQuals,
11240 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
nullptr,
11241 IndexTypeQuals, BracketsRange);
11244 template<
typename Derived>
11249 unsigned IndexTypeQuals,
11251 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
11253 IndexTypeQuals, BracketsRange);
11256 template<
typename Derived>
11261 unsigned IndexTypeQuals,
11263 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
11265 IndexTypeQuals, BracketsRange);
11268 template<
typename Derived>
11270 unsigned NumElements,
11273 return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind);
11276 template<
typename Derived>
11278 unsigned NumElements,
11280 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
11281 NumElements,
true);
11285 return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc);
11288 template<
typename Derived>
11293 return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc);
11296 template<
typename Derived>
11301 return SemaRef.BuildFunctionType(T, ParamTypes,
11302 getDerived().getBaseLocation(),
11303 getDerived().getBaseEntity(),
11307 template<
typename Derived>
11309 return SemaRef.Context.getFunctionNoProtoType(T);
11312 template<
typename Derived>
11314 assert(D &&
"no decl found");
11319 if (isa<UsingDecl>(D)) {
11322 "UnresolvedUsingTypenameDecl transformed to non-typename using");
11326 Ty = cast<TypeDecl>((*Using->
shadow_begin())->getTargetDecl());
11329 assert(isa<UnresolvedUsingTypenameDecl>(D) &&
11330 "UnresolvedUsingTypenameDecl transformed to non-using decl");
11331 Ty = cast<UnresolvedUsingTypenameDecl>(D);
11334 return SemaRef.Context.getTypeDeclType(Ty);
11337 template<
typename Derived>
11340 return SemaRef.BuildTypeofExprType(E, Loc);
11343 template<
typename Derived>
11345 return SemaRef.Context.getTypeOfType(Underlying);
11348 template<
typename Derived>
11351 return SemaRef.BuildDecltypeType(E, Loc);
11354 template<
typename Derived>
11358 return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc);
11361 template<
typename Derived>
11366 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
11369 template<
typename Derived>
11372 return SemaRef.BuildAtomicType(ValueType, KWLoc);
11375 template<
typename Derived>
11378 return SemaRef.BuildPipeType(ValueType, KWLoc);
11381 template<
typename Derived>
11386 return SemaRef.Context.getQualifiedTemplateName(SS.
getScopeRep(), TemplateKW,
11390 template<
typename Derived>
11401 getSema().ActOnDependentTemplateName(
nullptr,
11402 SS, TemplateKWLoc, TemplateName,
11406 return Template.
get();
11409 template<
typename Derived>
11417 SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc };
11421 getSema().ActOnDependentTemplateName(
nullptr,
11422 SS, TemplateKWLoc, Name,
11426 return Template.
get();
11429 template<
typename Derived>
11437 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus);
11442 return SemaRef.checkPseudoObjectAssignment(
nullptr, OpLoc, Opc,
11444 ExprResult Result = SemaRef.CheckPlaceholderExpr(First);
11447 First = Result.
get();
11451 ExprResult Result = SemaRef.CheckPlaceholderExpr(Second);
11454 Second = Result.
get();
11458 if (Op == OO_Subscript) {
11461 return getSema().CreateBuiltinArraySubscriptExpr(First,
11462 Callee->getLocStart(),
11464 }
else if (Op == OO_Arrow) {
11466 return SemaRef.BuildOverloadedArrowExpr(
nullptr, First, OpLoc);
11467 }
else if (Second ==
nullptr || isPostIncDec) {
11474 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First);
11483 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second);
11496 assert(ULE->requiresADL());
11497 Functions.
append(ULE->decls_begin(), ULE->decls_end());
11502 NamedDecl *ND = cast<DeclRefExpr>(Callee)->getDecl();
11503 if (!isa<CXXMethodDecl>(ND))
11508 Expr *Args[2] = { First, Second };
11509 unsigned NumArgs = 1 + (Second !=
nullptr);
11512 if (NumArgs == 1 || isPostIncDec) {
11515 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First);
11518 if (Op == OO_Subscript) {
11522 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) {
11529 LBrace = Callee->getLocStart();
11533 return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace,
11540 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]);
11547 template<
typename Derived>
11562 ->template getAs<RecordType>())){
11564 return SemaRef.BuildPseudoDestructorExpr(
11565 Base, OperatorLoc, isArrow ? tok::arrow : tok::period, SS, ScopeType,
11566 CCLoc, TildeLoc, Destroyed);
11571 SemaRef.Context.getCanonicalType(DestroyedType->
getType())));
11580 diag::err_expected_class_or_namespace)
11581 << ScopeType->
getType() << getSema().getLangOpts().CPlusPlus;
11589 return getSema().BuildMemberReferenceExpr(Base, BaseType,
11590 OperatorLoc, isArrow,
11598 template<
typename Derived>
11606 for (
unsigned I = 0;
I < NumParams; ++
I) {
11607 if (
I != ContextParamPos) {
11613 Params.push_back(std::make_pair(StringRef(), QualType()));
11616 getSema().ActOnCapturedRegionStart(Loc,
nullptr,
11620 Sema::CompoundScopeRAII CompoundScope(getSema());
11624 if (Body.isInvalid()) {
11625 getSema().ActOnCapturedRegionError();
11629 return getSema().ActOnCapturedRegionEnd(Body.get());
11634 #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
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.
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.
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
Decl - This represents one declaration (or definition), e.g.
This represents 'grainsize' clause in the '#pragma omp ...' directive.
TypeLoc getPatternLoc() const
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Defines the C++ template declaration subclasses.
Represents a C++11 auto or C++14 decltype(auto) type.
Represents an attribute applied to a statement.
bool isEnumeralType() const
ParenExpr - This represents a parethesized expression, e.g.
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
TemplateSpecializationType(TemplateName T, const TemplateArgument *Args, unsigned NumArgs, QualType Canon, QualType Aliased)
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
DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, unsigned NumArgs, const TemplateArgument *Args, QualType Canon)
SourceLocation getLAngleLoc() const
Retrieve the location of the left angle bracket starting the explicit template argument list followin...
void setTemplateKeywordLoc(SourceLocation Loc)
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
NamespaceDecl - Represent a C++ namespace.
Represents a call to a C++ constructor.
bool hasExplicitTemplateArgs() const
Determines whether this lookup had explicit template arguments.
Wrapper for source info for typedefs.
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
SourceLocation getColonLoc() const
Returns the location of ':'.
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
const TemplateArgumentLoc * operator->() const
std::input_iterator_tag iterator_category
A container of type source information.
Wrapper for void* pointer.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
SourceLocation getColonLoc() const
Get colon location.
Represents a C++ constructor within a class.
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.
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...
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 ')'.
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
This represents clause 'map' 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.
A location where the result (returned value) of evaluating a statement should be stored.
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 by copy (a.k.a., by value)
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.
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.
Represents the this expression in C++.
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
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
DeclContext * getDeclContext()
SourceLocation getLParenLoc() const
Returns the location of '('.
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
unsigned getContextParamPosition() const
Represents a C++ template name within the type system.
A namespace alias, stored as a NamespaceAliasDecl*.
SourceRange 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.
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...
SourceLocation getLParenLoc() const
Returns the location of '('.
const IdentifierInfo * getField() const
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
ExceptionSpecificationType Type
The kind of exception specification this is.
void setLAngleLoc(SourceLocation Loc)
TemplateArgumentLocInventIterator()
friend bool operator!=(const TemplateArgumentLocContainerIterator &X, const TemplateArgumentLocContainerIterator &Y)
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
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 isInvalidDecl() const
bool isDefaultArgument() const
Determine whether this expression is a default function argument.
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
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.
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.
The template argument is a type.
SourceLocation getLocStart() const LLVM_READONLY
OpenMPDefaultClauseKind
OpenMP attributes for 'default' clause.
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.
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...
Designator * designators_iterator
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]).
void setRAngleLoc(SourceLocation Loc)
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.
SourceLocation getLocation() const
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)
ParmVarDecl ** getParmArray() const
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
TranslationUnitDecl * getTranslationUnitDecl()
SourceLocation ColonLoc
Location of ':'.
Optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
ExceptionSpecInfo ExceptionSpec
TemplateArgumentLocContainerIterator()
The symbol does not exist.
Represents an implicitly-generated value initialization of an object of a given type.
void setElaboratedKeywordLoc(SourceLocation Loc)
Attr - This represents one attribute.
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 ...