14 #ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
15 #define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
35 #include "llvm/ADT/ArrayRef.h"
36 #include "llvm/Support/ErrorHandling.h"
93 template<
typename Derived>
98 class ForgetPartiallySubstitutedPackRAII {
103 ForgetPartiallySubstitutedPackRAII(Derived &Self) : Self(Self) {
104 Old = Self.ForgetPartiallySubstitutedPack();
107 ~ForgetPartiallySubstitutedPackRAII() {
108 Self.RememberPartiallySubstitutedPack(Old);
125 Derived &
getDerived() {
return static_cast<Derived&
>(*this); }
129 return static_cast<const Derived&
>(*this);
148 bool AlwaysRebuild() {
return SemaRef.ArgumentPackSubstitutionIndex != -1; }
182 OldLocation = Self.
getDerived().getBaseLocation();
183 OldEntity = Self.
getDerived().getBaseEntity();
190 Self.getDerived().setBase(OldLocation, OldEntity);
256 bool &RetainExpansion,
258 ShouldExpand =
false;
338 const Attr *TransformAttr(
const Attr *
S);
347 #define PRAGMA_SPELLING_ATTR(X) \
348 const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; }
349 #include "clang/Basic/AttrList.inc"
368 ExprResult TransformInitializer(Expr *Init,
bool NotCopyInit);
393 bool TransformExprs(Expr **Inputs,
unsigned NumInputs,
bool IsCall,
394 SmallVectorImpl<Expr *> &Outputs,
395 bool *ArgChanged =
nullptr);
404 llvm::DenseMap<Decl *, Decl *>::iterator Known
405 = TransformedLocalDecls.find(D);
406 if (Known != TransformedLocalDecls.end())
407 return Known->second;
427 TransformedLocalDecls[Old] = New;
435 return getDerived().TransformDecl(Loc, D);
448 return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D));
460 NamedDecl *FirstQualifierInScope =
nullptr);
495 NamedDecl *FirstQualifierInScope =
nullptr);
529 return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs);
546 template<
typename InputIterator>
547 bool TransformTemplateArguments(InputIterator First,
557 return SemaRef.Context.getTrivialTypeSourceInfo(T,
558 getDerived().getBaseLocation());
561 #define ABSTRACT_TYPELOC(CLASS, PARENT)
562 #define TYPELOC(CLASS, PARENT) \
563 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
564 #include "clang/AST/TypeLocNodes.def"
566 template<
typename Fn>
567 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
568 FunctionProtoTypeLoc TL,
569 CXXRecordDecl *ThisContext,
570 unsigned ThisTypeQuals,
571 Fn TransformExceptionSpec);
573 bool TransformExceptionSpec(SourceLocation Loc,
574 FunctionProtoType::ExceptionSpecInfo &ESI,
575 SmallVectorImpl<QualType> &Exceptions,
581 TransformTemplateSpecializationType(TypeLocBuilder &TLB,
582 TemplateSpecializationTypeLoc TL,
583 TemplateName Template);
586 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
587 DependentTemplateSpecializationTypeLoc TL,
588 TemplateName Template,
591 QualType TransformDependentTemplateSpecializationType(
592 TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
593 NestedNameSpecifierLoc QualifierLoc);
602 bool TransformFunctionTypeParams(SourceLocation Loc,
603 ParmVarDecl **Params,
unsigned NumParams,
604 const QualType *ParamTypes,
605 SmallVectorImpl<QualType> &PTypes,
606 SmallVectorImpl<ParmVarDecl*> *PVars);
613 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
615 Optional<unsigned> NumExpansions,
616 bool ExpectParameterPack);
618 QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);
620 StmtResult TransformCompoundStmt(CompoundStmt *
S,
bool IsStmtExpr);
621 ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *E);
631 bool IsAddressOfOperand,
634 ExprResult TransformParenDependentScopeDeclRefExpr(
642 #define STMT(Node, Parent) \
643 LLVM_ATTRIBUTE_NOINLINE \
644 StmtResult Transform##Node(Node *S);
645 #define EXPR(Node, Parent) \
646 LLVM_ATTRIBUTE_NOINLINE \
647 ExprResult Transform##Node(Node *E);
648 #define ABSTRACT_STMT(Stmt)
649 #include "clang/AST/StmtNodes.inc"
651 #define OPENMP_CLAUSE(Name, Class) \
652 LLVM_ATTRIBUTE_NOINLINE \
653 OMPClause *Transform ## Class(Class *S);
654 #include "clang/Basic/OpenMPKinds.def"
660 QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);
666 QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);
676 QualType RebuildReferenceType(QualType ReferentType,
678 SourceLocation Sigil);
685 QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
686 SourceLocation Sigil);
692 QualType RebuildObjCObjectType(QualType BaseType,
694 SourceLocation TypeArgsLAngleLoc,
695 ArrayRef<TypeSourceInfo *> TypeArgs,
696 SourceLocation TypeArgsRAngleLoc,
697 SourceLocation ProtocolLAngleLoc,
698 ArrayRef<ObjCProtocolDecl *> Protocols,
699 ArrayRef<SourceLocation> ProtocolLocs,
700 SourceLocation ProtocolRAngleLoc);
706 QualType RebuildObjCObjectPointerType(QualType PointeeType,
707 SourceLocation Star);
716 QualType RebuildArrayType(QualType ElementType,
718 const llvm::APInt *Size,
720 unsigned IndexTypeQuals,
721 SourceRange BracketsRange);
728 QualType RebuildConstantArrayType(QualType ElementType,
730 const llvm::APInt &Size,
731 unsigned IndexTypeQuals,
732 SourceRange BracketsRange);
739 QualType RebuildIncompleteArrayType(QualType ElementType,
741 unsigned IndexTypeQuals,
742 SourceRange BracketsRange);
749 QualType RebuildVariableArrayType(QualType ElementType,
752 unsigned IndexTypeQuals,
753 SourceRange BracketsRange);
760 QualType RebuildDependentSizedArrayType(QualType ElementType,
763 unsigned IndexTypeQuals,
764 SourceRange BracketsRange);
771 QualType RebuildVectorType(QualType ElementType,
unsigned NumElements,
779 QualType RebuildExtVectorType(QualType ElementType,
unsigned NumElements,
780 SourceLocation AttributeLoc);
787 QualType RebuildDependentSizedExtVectorType(QualType ElementType,
789 SourceLocation AttributeLoc);
795 QualType RebuildFunctionProtoType(QualType T,
796 MutableArrayRef<QualType> ParamTypes,
797 const FunctionProtoType::ExtProtoInfo &EPI);
800 QualType RebuildFunctionNoProtoType(QualType ResultType);
804 QualType RebuildUnresolvedUsingType(Decl *D);
808 return SemaRef.Context.getTypeDeclType(Typedef);
813 return SemaRef.Context.getTypeDeclType(Record);
818 return SemaRef.Context.getTypeDeclType(Enum);
850 return SemaRef.Context.getAutoType(Deduced, IsDecltypeAuto,
868 return SemaRef.Context.getParenType(InnerType);
880 return SemaRef.Context.getElaboratedType(Keyword,
899 SS.
Adopt(QualifierLoc);
901 = getDerived().RebuildTemplateName(SS, *Name, NameLoc,
QualType(),
909 return SemaRef.Context.getDependentTemplateSpecializationType(Keyword,
917 getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
923 return SemaRef.Context.getElaboratedType(Keyword,
939 SS.
Adopt(QualifierLoc);
943 if (!SemaRef.computeDeclContext(SS))
944 return SemaRef.Context.getDependentNameType(Keyword,
950 return SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc,
959 DeclContext *DC = SemaRef.computeDeclContext(SS,
false);
963 if (SemaRef.RequireCompleteDeclContext(SS, DC))
967 SemaRef.LookupQualifiedName(Result, DC);
979 llvm_unreachable(
"Tag lookup cannot find non-tags");
990 SemaRef.LookupQualifiedName(Result, DC);
997 if (isa<TypedefDecl>(SomeDecl)) Kind = 1;
998 else if (isa<TypeAliasDecl>(SomeDecl)) Kind = 2;
999 else if (isa<ClassTemplateDecl>(SomeDecl)) Kind = 3;
1000 SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) <<
Kind;
1001 SemaRef.Diag(SomeDecl->
getLocation(), diag::note_declared_at);
1005 SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope)
1012 if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind,
false,
1014 SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id;
1015 SemaRef.Diag(Tag->
getLocation(), diag::note_previous_use);
1020 QualType T = SemaRef.Context.getTypeDeclType(Tag);
1021 return SemaRef.Context.getElaboratedType(Keyword,
1034 return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc,
1088 return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
1099 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements,
1112 return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS,
1121 getSema().ActOnCaseStmtBody(S, Body);
1132 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt,
1142 return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt);
1152 return SemaRef.ActOnAttributedStmt(AttrLoc, Attrs, SubStmt);
1162 return getSema().ActOnIfStmt(IfLoc, Cond, CondVar, Then, ElseLoc, Else);
1171 return getSema().ActOnStartOfSwitchStmt(SwitchLoc, Cond,
1181 return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body);
1190 return getSema().ActOnWhileStmt(WhileLoc, Cond, CondVar, Body);
1200 return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
1212 return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
1213 CondVar, Inc, RParenLoc, Body);
1222 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label);
1232 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target);
1240 return getSema().BuildReturnStmt(ReturnLoc, Result);
1250 return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc);
1258 bool IsVolatile,
unsigned NumOutputs,
1263 return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
1264 NumInputs, Names, Constraints, Exprs,
1265 AsmString, Clobbers, RParenLoc);
1274 StringRef AsmString,
1275 unsigned NumOutputs,
unsigned NumInputs,
1280 return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString,
1281 NumOutputs, NumInputs,
1282 Constraints, Clobbers, Exprs, EndLoc);
1293 return getSema().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts,
1303 return getSema().BuildObjCExceptionDecl(TInfo, T,
1317 return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
1327 return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body);
1336 return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
1349 return getSema().ActOnOpenMPExecutableDirective(
1350 Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
1361 return getSema().ActOnOpenMPIfClause(Condition, StartLoc,
1372 return getSema().ActOnOpenMPFinalClause(Condition, StartLoc, LParenLoc,
1384 return getSema().ActOnOpenMPNumThreadsClause(NumThreads, StartLoc,
1395 return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc);
1405 return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc,
1418 return getSema().ActOnOpenMPDefaultClause(Kind, KindKwLoc,
1419 StartLoc, LParenLoc, EndLoc);
1431 return getSema().ActOnOpenMPProcBindClause(Kind, KindKwLoc,
1432 StartLoc, LParenLoc, EndLoc);
1446 return getSema().ActOnOpenMPScheduleClause(
1447 Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
1458 return getSema().ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc,
1470 return getSema().ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc,
1482 return getSema().ActOnOpenMPLastprivateClause(VarList, StartLoc, LParenLoc,
1494 return getSema().ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc,
1509 return getSema().ActOnOpenMPReductionClause(
1510 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1523 return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc,
1536 return getSema().ActOnOpenMPAlignedClause(VarList, Alignment, StartLoc,
1537 LParenLoc, ColonLoc, EndLoc);
1548 return getSema().ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc,
1560 return getSema().ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc,
1572 return getSema().ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc,
1585 return getSema().ActOnOpenMPDependClause(DepKind, DepLoc, ColonLoc, VarList,
1586 StartLoc, LParenLoc, EndLoc);
1595 return getSema().ActOnObjCAtSynchronizedOperand(atLoc,
object);
1604 return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body);
1613 return getSema().ActOnObjCAutoreleasePoolStmt(AtLoc, Body);
1625 StmtResult ForEachStmt = getSema().ActOnObjCForCollectionStmt(ForLoc,
1632 return getSema().FinishObjCForCollectionStmt(ForEachStmt.
get(), Body);
1644 VarDecl *Var = getSema().BuildExceptionDeclaration(
nullptr, Declarator,
1645 StartLoc, IdLoc, Id);
1647 getSema().CurContext->addDecl(Var);
1668 return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers);
1683 if (
DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) {
1684 if (RangeStmt->isSingleDecl()) {
1685 if (
VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
1686 if (RangeVar->isInvalidDecl())
1689 Expr *RangeExpr = RangeVar->getInit();
1692 return getSema().ActOnObjCForCollectionStmt(ForLoc, LoopVar, RangeExpr,
1698 return getSema().BuildCXXForRangeStmt(ForLoc, ColonLoc, Range, BeginEnd,
1699 Cond, Inc, LoopVar, RParenLoc,
1712 return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
1713 QualifierLoc, NameInfo, Nested);
1721 return getSema().FinishCXXForRangeStmt(ForRange, Body);
1726 return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler);
1731 return getSema().ActOnSEHExceptBlock(Loc, FilterExpr, Block);
1744 return getSema().BuildPredefinedExpr(Loc, IT);
1754 return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
1767 SS.
Adopt(QualifierLoc);
1771 return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD);
1780 return getSema().ActOnParenExpr(LParen, RParen, SubExpr);
1803 return getSema().BuildUnaryOp(
nullptr, OpLoc, Opc, SubExpr);
1813 unsigned NumComponents,
1815 return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
1816 NumComponents, RParenLoc);
1828 return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R);
1840 = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind);
1855 return getSema().ActOnArraySubscriptExpr(
nullptr, LHS,
1867 Expr *ExecConfig =
nullptr) {
1868 return getSema().ActOnCallExpr(
nullptr, Callee, LParenLoc,
1869 Args, RParenLoc, ExecConfig);
1891 assert(!QualifierLoc &&
"Can't have an unnamed field with a qualifier!");
1893 "unnamed member not of record type?");
1896 getSema().PerformObjectMemberConversion(BaseResult.get(),
1899 if (BaseResult.isInvalid())
1901 Base = BaseResult.get();
1904 MemberExpr(Base, isArrow, OpLoc, Member, MemberNameInfo,
1905 cast<FieldDecl>(Member)->getType(), VK,
OK_Ordinary);
1910 SS.
Adopt(QualifierLoc);
1912 Base = BaseResult.
get();
1921 return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow,
1923 FirstQualifierInScope,
1924 R, ExplicitTemplateArgs);
1934 return getSema().BuildBinOp(
nullptr, OpLoc, Opc, LHS, RHS);
1946 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond,
1958 return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
1970 return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
1985 return getSema().BuildMemberReferenceExpr(Base, Base->
getType(),
2002 = SemaRef.ActOnInitList(LBraceLoc, Inits, RBraceLoc);
2023 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
2047 return getSema().BuildVAArgExpr(BuiltinLoc,
2059 return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs);
2069 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label);
2079 return getSema().ActOnStmtExpr(LParenLoc, SubStmt, RParenLoc);
2089 return SemaRef.ActOnChooseExpr(BuiltinLoc,
2101 Expr *ControllingExpr,
2104 return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
2105 ControllingExpr, Types, Exprs);
2129 Stmt::StmtClass Class,
2137 case Stmt::CXXStaticCastExprClass:
2138 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
2139 RAngleLoc, LParenLoc,
2140 SubExpr, RParenLoc);
2142 case Stmt::CXXDynamicCastExprClass:
2143 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
2144 RAngleLoc, LParenLoc,
2145 SubExpr, RParenLoc);
2147 case Stmt::CXXReinterpretCastExprClass:
2148 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
2149 RAngleLoc, LParenLoc,
2153 case Stmt::CXXConstCastExprClass:
2154 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
2155 RAngleLoc, LParenLoc,
2156 SubExpr, RParenLoc);
2159 llvm_unreachable(
"Invalid C++ named cast");
2174 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
2191 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
2208 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
2225 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
2239 return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc,
2252 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2265 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2277 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
2289 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
2301 getSema().CheckCXXThisCapture(ThisLoc);
2302 return new (getSema().Context)
CXXThisExpr(ThisLoc, ThisType, isImplicit);
2310 bool IsThrownVariableInScope) {
2311 return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope);
2341 return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc,
2359 Expr *Initializer) {
2360 return getSema().BuildCXXNew(StartLoc, UseGlobal,
2377 bool IsGlobalDelete,
2380 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
2392 return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc);
2404 return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc);
2415 return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc);
2428 bool IsAddressOfOperand,
2431 SS.
Adopt(QualifierLoc);
2433 if (TemplateArgs || TemplateKWLoc.
isValid())
2434 return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc, NameInfo,
2437 return getSema().BuildQualifiedDeclarationNameExpr(
2438 SS, NameInfo, IsAddressOfOperand, RecoveryTSI);
2450 return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL,
2463 bool HadMultipleCandidates,
2464 bool ListInitialization,
2465 bool StdInitListInitialization,
2466 bool RequiresZeroInit,
2470 if (getSema().CompleteConstructorCall(Constructor, Args, Loc,
2474 return getSema().BuildCXXConstructExpr(Loc, T, Constructor, IsElidable,
2476 HadMultipleCandidates,
2478 StdInitListInitialization,
2479 RequiresZeroInit, ConstructKind,
2491 return getSema().BuildCXXTypeConstructExpr(TSInfo,
2505 return getSema().BuildCXXTypeConstructExpr(TSInfo,
2525 SS.
Adopt(QualifierLoc);
2527 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
2528 OperatorLoc, IsArrow,
2530 FirstQualifierInScope,
2548 SS.
Adopt(QualifierLoc);
2550 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
2551 OperatorLoc, IsArrow,
2553 FirstQualifierInScope,
2562 return SemaRef.BuildCXXNoexceptExpr(Range.
getBegin(), Arg, Range.
getEnd());
2571 return new (SemaRef.Context)
SizeOfPackExpr(SemaRef.Context.getSizeType(),
2572 OperatorLoc, Pack, PackLoc,
2573 RParenLoc, *Length);
2575 return new (SemaRef.Context)
SizeOfPackExpr(SemaRef.Context.getSizeType(),
2576 OperatorLoc, Pack, PackLoc,
2585 return getSema().BuildObjCBoxedExpr(SR, ValueExpr);
2593 Expr **Elements,
unsigned NumElements) {
2594 return getSema().BuildObjCArrayLiteral(Range,
2602 return getSema().BuildObjCSubscriptExpression(RB, Base, Key,
2603 getterMethod, setterMethod);
2612 unsigned NumElements) {
2613 return getSema().BuildObjCDictionaryLiteral(Range, Elements, NumElements);
2623 return SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo, RParenLoc);
2634 return SemaRef.BuildClassMessage(ReceiverTypeInfo,
2637 Sel, Method, LBracLoc, SelectorLocs,
2649 return SemaRef.BuildInstanceMessage(Receiver,
2652 Sel, Method, LBracLoc, SelectorLocs,
2665 QualType ReceiverTy = SemaRef.Context.getObjCInterfaceType(Class);
2670 Sel, Method, LBracLoc, SelectorLocs,
2672 : SemaRef.BuildClassMessage(
nullptr,
2675 Sel, Method, LBracLoc, SelectorLocs,
2687 bool IsArrow,
bool IsFreeIvar) {
2691 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->
getType(),
2708 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->
getType(),
2730 PropertyLoc, Base));
2741 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->
getType(),
2758 = SemaRef.Context.Idents.get(
"__builtin_shufflevector");
2761 assert(!Lookup.
empty() &&
"No __builtin_shufflevector?");
2766 SemaRef.Context.BuiltinFnTy,
2768 QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType());
2769 Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy,
2774 SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(),
2778 return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.
get()));
2785 return SemaRef.SemaConvertVectorExpr(SrcExpr, DstTInfo,
2786 BuiltinLoc, RParenLoc);
2801 EllipsisLoc, NumExpansions);
2822 llvm_unreachable(
"Pack expansion pattern has no parameter packs");
2844 return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions);
2855 return getSema().BuildCXXFoldExpr(LParenLoc, LHS, Operator, EllipsisLoc,
2865 return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator);
2880 return new (SemaRef.Context)
AtomicExpr(BuiltinLoc, SubExprs, RetTy, Op,
2900 template<
typename Derived>
2905 switch (S->getStmtClass()) {
2906 case Stmt::NoStmtClass:
break;
2909 #define STMT(Node, Parent) \
2910 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
2911 #define ABSTRACT_STMT(Node)
2912 #define EXPR(Node, Parent)
2913 #include "clang/AST/StmtNodes.inc"
2916 #define STMT(Node, Parent)
2917 #define ABSTRACT_STMT(Stmt)
2918 #define EXPR(Node, Parent) case Stmt::Node##Class:
2919 #include "clang/AST/StmtNodes.inc"
2921 ExprResult E = getDerived().TransformExpr(cast<Expr>(S));
2925 return getSema().ActOnExprStmt(E);
2932 template<
typename Derived>
2940 #define OPENMP_CLAUSE(Name, Class) \
2941 case OMPC_ ## Name : \
2942 return getDerived().Transform ## Class(cast<Class>(S));
2943 #include "clang/Basic/OpenMPKinds.def"
2950 template<
typename Derived>
2955 switch (E->getStmtClass()) {
2956 case Stmt::NoStmtClass:
break;
2957 #define STMT(Node, Parent) case Stmt::Node##Class: break;
2958 #define ABSTRACT_STMT(Stmt)
2959 #define EXPR(Node, Parent) \
2960 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
2961 #include "clang/AST/StmtNodes.inc"
2967 template<
typename Derived>
2976 Init = ExprTemp->getSubExpr();
2979 Init = MTE->GetTemporaryExpr();
2982 Init = Binder->getSubExpr();
2985 Init = ICE->getSubExprAsWritten();
2988 dyn_cast<CXXStdInitializerListExpr>(Init))
2989 return TransformInitializer(ILE->getSubExpr(), NotCopyInit);
2995 if (!NotCopyInit && !(Construct && Construct->isListInitialization()))
2996 return getDerived().TransformExpr(Init);
3001 return getDerived().RebuildParenListExpr(Parens.
getBegin(),
None,
3006 if (isa<ImplicitValueInitExpr>(Init))
3012 if (!Construct || isa<CXXTemporaryObjectExpr>(Construct))
3013 return getDerived().TransformExpr(Init);
3017 if (Construct && Construct->isStdInitListInitialization())
3018 return TransformInitializer(Construct->getArg(0), NotCopyInit);
3021 bool ArgChanged =
false;
3022 if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(),
3023 true, NewArgs, &ArgChanged))
3027 if (Construct->isListInitialization())
3028 return getDerived().RebuildInitList(Construct->getLocStart(), NewArgs,
3029 Construct->getLocEnd(),
3030 Construct->getType());
3033 SourceRange Parens = Construct->getParenOrBraceRange();
3037 assert(NewArgs.empty() &&
3038 "no parens or braces but have direct init with arguments?");
3041 return getDerived().RebuildParenListExpr(Parens.
getBegin(), NewArgs,
3045 template<
typename Derived>
3051 for (
unsigned I = 0; I != NumInputs; ++I) {
3053 if (IsCall && getDerived().DropCallArgument(Inputs[I])) {
3061 Expr *Pattern = Expansion->getPattern();
3064 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
3065 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
3070 bool RetainExpansion =
false;
3073 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
3074 Pattern->getSourceRange(),
3076 Expand, RetainExpansion,
3085 ExprResult OutPattern = getDerived().TransformExpr(Pattern);
3089 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.
get(),
3090 Expansion->getEllipsisLoc(),
3097 Outputs.push_back(Out.
get());
3103 if (ArgChanged) *ArgChanged =
true;
3107 for (
unsigned I = 0; I != *NumExpansions; ++I) {
3109 ExprResult Out = getDerived().TransformExpr(Pattern);
3116 Out = getDerived().RebuildPackExpansion(
3117 Out.
get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
3122 Outputs.push_back(Out.
get());
3127 if (RetainExpansion) {
3128 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
3130 ExprResult Out = getDerived().TransformExpr(Pattern);
3134 Out = getDerived().RebuildPackExpansion(
3135 Out.
get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
3139 Outputs.push_back(Out.
get());
3146 IsCall ? getDerived().TransformInitializer(Inputs[I],
false)
3147 : getDerived().TransformExpr(Inputs[I]);
3151 if (Result.
get() != Inputs[I] && ArgChanged)
3154 Outputs.push_back(Result.
get());
3160 template<
typename Derived>
3169 Qualifiers.push_back(Qualifier);
3172 while (!Qualifiers.empty()) {
3178 if (SemaRef.BuildCXXNestedNameSpecifier(
nullptr,
3182 ObjectType,
false, SS,
3183 FirstQualifierInScope,
false))
3190 = cast_or_null<NamespaceDecl>(
3191 getDerived().TransformDecl(
3200 = cast_or_null<NamespaceAliasDecl>(
3216 cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
3225 FirstQualifierInScope, SS);
3231 (SemaRef.getLangOpts().CPlusPlus11 &&
3234 "Can't get cv-qualifiers here");
3237 diag::warn_cxx98_compat_enum_nested_name_spec);
3246 SemaRef.Diag(TL.
getBeginLoc(), diag::err_nested_name_spec_non_tag)
3247 << TL.
getType() << SS.getRange();
3254 FirstQualifierInScope =
nullptr;
3260 !getDerived().AlwaysRebuild())
3273 template<
typename Derived>
3297 NewTInfo = getDerived().TransformType(OldTInfo);
3300 NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->
getType());
3308 NewCanTy = SemaRef.Context.getCanonicalType(NewT);
3312 = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.
getNameKind(),
3321 llvm_unreachable(
"Unknown name kind.");
3324 template<
typename Derived>
3333 assert(Template &&
"qualified template name must refer to a template");
3336 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
3341 if (!getDerived().AlwaysRebuild() &&
3343 TransTemplate == Template)
3346 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
3354 FirstQualifierInScope =
nullptr;
3357 if (!getDerived().AlwaysRebuild() &&
3362 if (DTN->isIdentifier()) {
3363 return getDerived().RebuildTemplateName(SS,
3364 *DTN->getIdentifier(),
3367 FirstQualifierInScope);
3370 return getDerived().RebuildTemplateName(SS, DTN->getOperator(), NameLoc,
3376 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
3381 if (!getDerived().AlwaysRebuild() &&
3382 TransTemplate == Template)
3391 = cast_or_null<TemplateTemplateParmDecl>(
3392 getDerived().TransformDecl(NameLoc, SubstPack->getParameterPack()));
3396 if (!getDerived().AlwaysRebuild() &&
3397 TransParam == SubstPack->getParameterPack())
3400 return getDerived().RebuildTemplateName(TransParam,
3401 SubstPack->getArgumentPack());
3405 llvm_unreachable(
"overloaded function decl survived to here");
3408 template<
typename Derived>
3415 llvm_unreachable(
"null template argument in TreeTransform");
3420 SemaRef.Context.getTrivialTypeSourceInfo(Arg.
getAsType(), Loc));
3429 Builder.
MakeTrivial(SemaRef.Context, DTN->getQualifier(), Loc);
3431 Builder.
MakeTrivial(SemaRef.Context, QTN->getQualifier(), Loc);
3458 template<
typename Derived>
3469 llvm_unreachable(
"Unexpected TemplateArgument");
3476 DI = getDerived().TransformType(DI);
3477 if (!DI)
return true;
3486 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
3492 SS.
Adopt(QualifierLoc);
3494 = getDerived().TransformTemplateName(SS, Arg.
getAsTemplate(),
3505 llvm_unreachable(
"Caller should expand pack expansions");
3515 ExprResult E = getDerived().TransformExpr(InputExpr);
3516 E = SemaRef.ActOnConstantExpression(E);
3529 template<
typename Derived,
typename InputIterator>
3537 typedef typename std::iterator_traits<InputIterator>::difference_type
3554 : Self(Self), Iter(Iter) { }
3569 Self.InventTemplateArgumentLoc(*Iter, Result);
3577 return X.Iter == Y.Iter;
3582 return X.Iter != Y.Iter;
3586 template<
typename Derived>
3587 template<
typename InputIterator>
3591 for (; First !=
Last; ++First) {
3604 if (TransformTemplateArguments(PackLocIterator(*
this,
3606 PackLocIterator(*
this,
3620 = getSema().getTemplateArgumentPackExpansionPattern(
3621 In, Ellipsis, OrigNumExpansions);
3624 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
3625 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
3630 bool RetainExpansion =
false;
3632 if (getDerived().TryExpandParameterPacks(Ellipsis,
3646 if (getDerived().TransformTemplateArgument(Pattern, OutPattern))
3649 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,
3660 for (
unsigned I = 0; I != *NumExpansions; ++I) {
3663 if (getDerived().TransformTemplateArgument(Pattern, Out))
3667 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
3678 if (RetainExpansion) {
3679 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
3681 if (getDerived().TransformTemplateArgument(Pattern, Out))
3684 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
3696 if (getDerived().TransformTemplateArgument(In, Out))
3710 template<
typename Derived>
3712 if (getDerived().AlreadyTransformed(T))
3717 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
3718 getDerived().getBaseLocation());
3728 template<
typename Derived>
3732 getDerived().getBaseEntity());
3733 if (getDerived().AlreadyTransformed(DI->
getType()))
3748 template<
typename Derived>
3752 #define ABSTRACT_TYPELOC(CLASS, PARENT)
3753 #define TYPELOC(CLASS, PARENT) \
3754 case TypeLoc::CLASS: \
3755 return getDerived().Transform##CLASS##Type(TLB, \
3756 T.castAs<CLASS##TypeLoc>());
3757 #include "clang/AST/TypeLocNodes.def"
3760 llvm_unreachable(
"unhandled type loc!");
3768 template<
typename Derived>
3795 = dyn_cast<SubstTemplateTypeParmType>(Result)) {
3796 QualType Replacement = SubstTypeParam->getReplacementType();
3802 Result = SemaRef.Context.getSubstTemplateTypeParmType(
3803 SubstTypeParam->getReplacedParameter(),
3806 }
else if ((AutoTy = dyn_cast<AutoType>(Result)) && AutoTy->
isDeduced()) {
3809 Qualifiers Qs = Deduced.getQualifiers();
3811 Deduced = SemaRef.Context.getQualifiedType(Deduced.getUnqualifiedType(),
3813 Result = SemaRef.Context.getAutoType(Deduced, AutoTy->
isDecltypeAuto(),
3820 SemaRef.Diag(R.getBegin(), diag::err_attr_objc_ownership_redundant)
3827 if (!Quals.
empty()) {
3828 Result = SemaRef.BuildQualifiedType(Result, T.
getBeginLoc(), Quals);
3831 TLB.
push<QualifiedTypeLoc>(Result);
3838 template<
typename Derived>
3840 TreeTransform<Derived>::TransformTypeInObjectScope(TypeLoc TL,
3841 QualType ObjectType,
3842 NamedDecl *UnqualLookup,
3844 if (getDerived().AlreadyTransformed(TL.getType()))
3847 TypeSourceInfo *TSI =
3848 TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
3850 return TSI->getTypeLoc();
3854 template<
typename Derived>
3856 TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
3857 QualType ObjectType,
3858 NamedDecl *UnqualLookup,
3860 if (getDerived().AlreadyTransformed(TSInfo->getType()))
3863 return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType,
3867 template <
typename Derived>
3868 TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope(
3869 TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup,
3872 assert(!getDerived().AlreadyTransformed(T));
3877 if (isa<TemplateSpecializationType>(T)) {
3878 TemplateSpecializationTypeLoc SpecTL =
3879 TL.castAs<TemplateSpecializationTypeLoc>();
3881 TemplateName Template
3882 = getDerived().TransformTemplateName(SS,
3883 SpecTL.getTypePtr()->getTemplateName(),
3884 SpecTL.getTemplateNameLoc(),
3885 ObjectType, UnqualLookup);
3886 if (Template.isNull())
3889 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL,
3891 }
else if (isa<DependentTemplateSpecializationType>(T)) {
3892 DependentTemplateSpecializationTypeLoc SpecTL =
3893 TL.castAs<DependentTemplateSpecializationTypeLoc>();
3895 TemplateName Template
3896 = getDerived().RebuildTemplateName(SS,
3897 *SpecTL.getTypePtr()->getIdentifier(),
3898 SpecTL.getTemplateNameLoc(),
3899 ObjectType, UnqualLookup);
3900 if (Template.isNull())
3903 Result = getDerived().TransformDependentTemplateSpecializationType(TLB,
3909 Result = getDerived().TransformType(TLB, TL);
3912 if (Result.isNull())
3915 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
3918 template <
class TyLoc>
static inline
3920 TyLoc NewT = TLB.
push<TyLoc>(T.getType());
3921 NewT.setNameLoc(T.getNameLoc());
3925 template<
typename Derived>
3926 QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
3928 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType());
3929 NewT.setBuiltinLoc(T.getBuiltinLoc());
3930 if (T.needsExtraLocalData())
3931 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs();
3935 template<
typename Derived>
3936 QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
3942 template <
typename Derived>
3943 QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB,
3944 AdjustedTypeLoc TL) {
3946 return getDerived().TransformType(TLB, TL.getOriginalLoc());
3949 template<
typename Derived>
3950 QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB,
3951 DecayedTypeLoc TL) {
3952 QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc());
3953 if (OriginalType.isNull())
3956 QualType Result = TL.getType();
3957 if (getDerived().AlwaysRebuild() ||
3958 OriginalType != TL.getOriginalLoc().getType())
3959 Result = SemaRef.Context.getDecayedType(OriginalType);
3960 TLB.push<DecayedTypeLoc>(Result);
3965 template<
typename Derived>
3966 QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
3967 PointerTypeLoc TL) {
3968 QualType PointeeType
3969 = getDerived().TransformType(TLB, TL.getPointeeLoc());
3970 if (PointeeType.isNull())
3973 QualType Result = TL.getType();
3974 if (PointeeType->getAs<ObjCObjectType>()) {
3979 Result = SemaRef.Context.getObjCObjectPointerType(PointeeType);
3981 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
3982 NewT.setStarLoc(TL.getStarLoc());
3986 if (getDerived().AlwaysRebuild() ||
3987 PointeeType != TL.getPointeeLoc().getType()) {
3988 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
3989 if (Result.isNull())
3995 TLB.TypeWasModifiedSafely(Result->getPointeeType());
3997 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result);
3998 NewT.setSigilLoc(TL.getSigilLoc());
4002 template<
typename Derived>
4004 TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
4005 BlockPointerTypeLoc TL) {
4006 QualType PointeeType
4007 = getDerived().TransformType(TLB, TL.getPointeeLoc());
4008 if (PointeeType.isNull())
4011 QualType Result = TL.getType();
4012 if (getDerived().AlwaysRebuild() ||
4013 PointeeType != TL.getPointeeLoc().getType()) {
4014 Result = getDerived().RebuildBlockPointerType(PointeeType,
4016 if (Result.isNull())
4020 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result);
4021 NewT.setSigilLoc(TL.getSigilLoc());
4029 template<
typename Derived>
4037 if (PointeeType.
isNull())
4041 if (getDerived().AlwaysRebuild() ||
4043 Result = getDerived().RebuildReferenceType(PointeeType,
4057 if (isa<LValueReferenceType>(Result))
4066 template<
typename Derived>
4070 return TransformReferenceType(TLB, TL);
4073 template<
typename Derived>
4075 TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
4076 RValueReferenceTypeLoc TL) {
4077 return TransformReferenceType(TLB, TL);
4080 template<
typename Derived>
4082 TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
4083 MemberPointerTypeLoc TL) {
4084 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
4085 if (PointeeType.isNull())
4088 TypeSourceInfo* OldClsTInfo = TL.getClassTInfo();
4089 TypeSourceInfo *NewClsTInfo =
nullptr;
4091 NewClsTInfo = getDerived().TransformType(OldClsTInfo);
4096 const MemberPointerType *T = TL.getTypePtr();
4097 QualType OldClsType = QualType(T->getClass(), 0);
4098 QualType NewClsType;
4100 NewClsType = NewClsTInfo->getType();
4102 NewClsType = getDerived().TransformType(OldClsType);
4103 if (NewClsType.isNull())
4107 QualType Result = TL.getType();
4108 if (getDerived().AlwaysRebuild() ||
4109 PointeeType != T->getPointeeType() ||
4110 NewClsType != OldClsType) {
4111 Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType,
4113 if (Result.isNull())
4119 const MemberPointerType *MPT = Result->getAs<MemberPointerType>();
4120 if (MPT && PointeeType != MPT->getPointeeType()) {
4121 assert(isa<AdjustedType>(MPT->getPointeeType()));
4122 TLB.push<AdjustedTypeLoc>(MPT->getPointeeType());
4125 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
4126 NewTL.setSigilLoc(TL.getSigilLoc());
4127 NewTL.setClassTInfo(NewClsTInfo);
4132 template<
typename Derived>
4134 TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
4135 ConstantArrayTypeLoc TL) {
4136 const ConstantArrayType *T = TL.getTypePtr();
4137 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4138 if (ElementType.isNull())
4141 QualType Result = TL.getType();
4142 if (getDerived().AlwaysRebuild() ||
4143 ElementType != T->getElementType()) {
4144 Result = getDerived().RebuildConstantArrayType(ElementType,
4145 T->getSizeModifier(),
4147 T->getIndexTypeCVRQualifiers(),
4148 TL.getBracketsRange());
4149 if (Result.isNull())
4157 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4158 NewTL.setLBracketLoc(TL.getLBracketLoc());
4159 NewTL.setRBracketLoc(TL.getRBracketLoc());
4161 Expr *Size = TL.getSizeExpr();
4163 EnterExpressionEvaluationContext Unevaluated(SemaRef,
4165 Size = getDerived().TransformExpr(Size).template getAs<Expr>();
4166 Size = SemaRef.ActOnConstantExpression(Size).get();
4168 NewTL.setSizeExpr(Size);
4173 template<
typename Derived>
4174 QualType TreeTransform<Derived>::TransformIncompleteArrayType(
4175 TypeLocBuilder &TLB,
4176 IncompleteArrayTypeLoc TL) {
4177 const IncompleteArrayType *T = TL.getTypePtr();
4178 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4179 if (ElementType.isNull())
4182 QualType Result = TL.getType();
4183 if (getDerived().AlwaysRebuild() ||
4184 ElementType != T->getElementType()) {
4185 Result = getDerived().RebuildIncompleteArrayType(ElementType,
4186 T->getSizeModifier(),
4187 T->getIndexTypeCVRQualifiers(),
4188 TL.getBracketsRange());
4189 if (Result.isNull())
4193 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
4194 NewTL.setLBracketLoc(TL.getLBracketLoc());
4195 NewTL.setRBracketLoc(TL.getRBracketLoc());
4196 NewTL.setSizeExpr(
nullptr);
4201 template<
typename Derived>
4203 TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
4204 VariableArrayTypeLoc TL) {
4205 const VariableArrayType *T = TL.getTypePtr();
4206 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4207 if (ElementType.isNull())
4211 = getDerived().TransformExpr(T->getSizeExpr());
4212 if (SizeResult.isInvalid())
4215 Expr *Size = SizeResult.
get();
4217 QualType Result = TL.
getType();
4218 if (getDerived().AlwaysRebuild() ||
4219 ElementType != T->getElementType() ||
4220 Size != T->getSizeExpr()) {
4221 Result = getDerived().RebuildVariableArrayType(ElementType,
4222 T->getSizeModifier(),
4224 T->getIndexTypeCVRQualifiers(),
4225 TL.getBracketsRange());
4226 if (Result.isNull())
4232 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4233 NewTL.setLBracketLoc(TL.getLBracketLoc());
4234 NewTL.setRBracketLoc(TL.getRBracketLoc());
4235 NewTL.setSizeExpr(Size);
4240 template<
typename Derived>
4242 TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
4243 DependentSizedArrayTypeLoc TL) {
4244 const DependentSizedArrayType *T = TL.
getTypePtr();
4245 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4246 if (ElementType.isNull())
4250 EnterExpressionEvaluationContext Unevaluated(SemaRef,
4254 Expr *origSize = TL.getSizeExpr();
4255 if (!origSize) origSize = T->getSizeExpr();
4258 = getDerived().TransformExpr(origSize);
4259 sizeResult = SemaRef.ActOnConstantExpression(sizeResult);
4260 if (sizeResult.isInvalid())
4263 Expr *size = sizeResult.
get();
4265 QualType Result = TL.
getType();
4266 if (getDerived().AlwaysRebuild() ||
4267 ElementType != T->getElementType() ||
4269 Result = getDerived().RebuildDependentSizedArrayType(ElementType,
4270 T->getSizeModifier(),
4272 T->getIndexTypeCVRQualifiers(),
4273 TL.getBracketsRange());
4274 if (Result.isNull())
4280 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4281 NewTL.setLBracketLoc(TL.getLBracketLoc());
4282 NewTL.setRBracketLoc(TL.getRBracketLoc());
4283 NewTL.setSizeExpr(size);
4288 template<
typename Derived>
4289 QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
4290 TypeLocBuilder &TLB,
4291 DependentSizedExtVectorTypeLoc TL) {
4292 const DependentSizedExtVectorType *T = TL.
getTypePtr();
4295 QualType ElementType = getDerived().TransformType(T->getElementType());
4296 if (ElementType.isNull())
4300 EnterExpressionEvaluationContext Unevaluated(SemaRef,
4303 ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
4304 Size = SemaRef.ActOnConstantExpression(Size);
4305 if (Size.isInvalid())
4308 QualType Result = TL.getType();
4309 if (getDerived().AlwaysRebuild() ||
4310 ElementType != T->getElementType() ||
4311 Size.get() != T->getSizeExpr()) {
4312 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
4314 T->getAttributeLoc());
4315 if (Result.isNull())
4320 if (isa<DependentSizedExtVectorType>(Result)) {
4321 DependentSizedExtVectorTypeLoc NewTL
4322 = TLB.push<DependentSizedExtVectorTypeLoc>(Result);
4323 NewTL.setNameLoc(TL.getNameLoc());
4325 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
4326 NewTL.setNameLoc(TL.getNameLoc());
4332 template<
typename Derived>
4333 QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
4335 const VectorType *T = TL.getTypePtr();
4336 QualType ElementType = getDerived().TransformType(T->getElementType());
4337 if (ElementType.isNull())
4340 QualType Result = TL.getType();
4341 if (getDerived().AlwaysRebuild() ||
4342 ElementType != T->getElementType()) {
4343 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(),
4344 T->getVectorKind());
4345 if (Result.isNull())
4349 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
4350 NewTL.setNameLoc(TL.getNameLoc());
4355 template<
typename Derived>
4356 QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
4357 ExtVectorTypeLoc TL) {
4358 const VectorType *T = TL.getTypePtr();
4359 QualType ElementType = getDerived().TransformType(T->getElementType());
4360 if (ElementType.isNull())
4363 QualType Result = TL.getType();
4364 if (getDerived().AlwaysRebuild() ||
4365 ElementType != T->getElementType()) {
4366 Result = getDerived().RebuildExtVectorType(ElementType,
4367 T->getNumElements(),
4369 if (Result.isNull())
4373 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
4374 NewTL.setNameLoc(TL.getNameLoc());
4379 template <
typename Derived>
4382 bool ExpectParameterPack) {
4386 if (NumExpansions && isa<PackExpansionType>(OldDI->
getType())) {
4396 QualType Result = getDerived().TransformType(TLB,
4401 Result = RebuildPackExpansionType(Result,
4411 NewDI = TLB.getTypeSourceInfo(SemaRef.Context, Result);
4413 NewDI = getDerived().TransformType(OldDI);
4417 if (NewDI == OldDI && indexAdjustment == 0)
4434 template<
typename Derived>
4441 int indexAdjustment = 0;
4443 for (
unsigned i = 0; i != NumParams; ++i) {
4445 assert(OldParm->getFunctionScopeIndex() == i);
4449 if (OldParm->isParameterPack()) {
4454 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc();
4457 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
4458 assert(Unexpanded.size() > 0 &&
"Could not find parameter packs!");
4461 bool ShouldExpand =
false;
4462 bool RetainExpansion =
false;
4465 NumExpansions = OrigNumExpansions;
4466 if (getDerived().TryExpandParameterPacks(ExpansionTL.
getEllipsisLoc(),
4467 Pattern.getSourceRange(),
4478 getDerived().ExpandingFunctionParameterPack(OldParm);
4479 for (
unsigned I = 0; I != *NumExpansions; ++I) {
4482 = getDerived().TransformFunctionTypeParam(OldParm,
4489 OutParamTypes.push_back(NewParm->
getType());
4491 PVars->push_back(NewParm);
4496 if (RetainExpansion) {
4497 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4499 = getDerived().TransformFunctionTypeParam(OldParm,
4506 OutParamTypes.push_back(NewParm->
getType());
4508 PVars->push_back(NewParm);
4524 NewParm = getDerived().TransformFunctionTypeParam(OldParm,
4529 NewParm = getDerived().TransformFunctionTypeParam(
4530 OldParm, indexAdjustment,
None,
false);
4536 OutParamTypes.push_back(NewParm->
getType());
4538 PVars->push_back(NewParm);
4545 bool IsPackExpansion =
false;
4549 = dyn_cast<PackExpansionType>(OldType)) {
4551 QualType Pattern = Expansion->getPattern();
4553 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
4556 bool ShouldExpand =
false;
4557 bool RetainExpansion =
false;
4558 if (getDerived().TryExpandParameterPacks(Loc,
SourceRange(),
4569 for (
unsigned I = 0; I != *NumExpansions; ++I) {
4571 QualType NewType = getDerived().TransformType(Pattern);
4575 OutParamTypes.push_back(NewType);
4577 PVars->push_back(
nullptr);
4586 if (RetainExpansion) {
4587 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4588 QualType NewType = getDerived().TransformType(Pattern);
4592 OutParamTypes.push_back(NewType);
4594 PVars->push_back(
nullptr);
4599 OldType = Expansion->getPattern();
4600 IsPackExpansion =
true;
4602 NewType = getDerived().TransformType(OldType);
4604 NewType = getDerived().TransformType(OldType);
4610 if (IsPackExpansion)
4611 NewType = getSema().Context.getPackExpansionType(NewType,
4614 OutParamTypes.push_back(NewType);
4616 PVars->push_back(
nullptr);
4621 for (
unsigned i = 0, e = PVars->size(); i != e; ++i)
4623 assert(parm->getFunctionScopeIndex() == i);
4630 template<
typename Derived>
4637 TLB, TL,
nullptr, 0,
4640 ExceptionStorage, Changed);
4644 template<
typename Derived>
template<
typename Fn>
4647 unsigned ThisTypeQuals, Fn TransformExceptionSpec) {
4662 if (getDerived().TransformFunctionTypeParams(
4676 ResultType = getDerived().TransformType(TLB, TL.
getReturnLoc());
4682 ResultType = getDerived().TransformType(TLB, TL.
getReturnLoc());
4686 if (getDerived().TransformFunctionTypeParams(
4694 bool EPIChanged =
false;
4702 if (getDerived().AlwaysRebuild() || ResultType != T->
getReturnType() ||
4705 ParamTypes.begin()) || EPIChanged) {
4706 Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI);
4716 for (
unsigned i = 0, e = NewTL.
getNumParams(); i != e; ++i)
4722 template<
typename Derived>
4736 NoexceptExpr = getSema().CheckBooleanCondition(
4737 NoexceptExpr.
get(), NoexceptExpr.
get()->getLocStart());
4742 NoexceptExpr = getSema().VerifyIntegerConstantExpression(
4743 NoexceptExpr.
get(),
nullptr,
4744 diag::err_noexcept_needs_constant_expression,
4766 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
4768 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
4773 bool Expand =
false;
4774 bool RetainExpansion =
false;
4778 if (getDerived().TryExpandParameterPacks(
4780 RetainExpansion, NumExpansions))
4788 QualType U = getDerived().TransformType(PackExpansion->getPattern());
4792 U = SemaRef.Context.getPackExpansionType(U, NumExpansions);
4793 Exceptions.push_back(U);
4799 for (
unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
4802 QualType U = getDerived().TransformType(PackExpansion->getPattern());
4803 if (U.
isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
4806 Exceptions.push_back(U);
4809 QualType U = getDerived().TransformType(T);
4810 if (U.
isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
4815 Exceptions.push_back(U);
4823 template<
typename Derived>
4833 if (getDerived().AlwaysRebuild() || ResultType != T->
getReturnType())
4834 Result = getDerived().RebuildFunctionNoProtoType(ResultType);
4845 template<
typename Derived> QualType
4846 TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB,
4847 UnresolvedUsingTypeLoc TL) {
4848 const UnresolvedUsingType *T = TL.getTypePtr();
4849 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl());
4853 QualType Result = TL.getType();
4854 if (getDerived().AlwaysRebuild() || D != T->getDecl()) {
4855 Result = getDerived().RebuildUnresolvedUsingType(D);
4856 if (Result.isNull())
4862 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result);
4863 NewTL.setNameLoc(TL.getNameLoc());
4868 template<
typename Derived>
4869 QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
4870 TypedefTypeLoc TL) {
4872 TypedefNameDecl *Typedef
4873 = cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(),
4878 QualType Result = TL.getType();
4879 if (getDerived().AlwaysRebuild() ||
4880 Typedef != T->getDecl()) {
4881 Result = getDerived().RebuildTypedefType(Typedef);
4882 if (Result.isNull())
4886 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result);
4887 NewTL.setNameLoc(TL.getNameLoc());
4892 template<
typename Derived>
4893 QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
4894 TypeOfExprTypeLoc TL) {
4899 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
4903 E = SemaRef.HandleExprEvaluationContextForTypeof(E.get());
4907 QualType Result = TL.getType();
4908 if (getDerived().AlwaysRebuild() ||
4909 E.get() != TL.getUnderlyingExpr()) {
4910 Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc());
4911 if (Result.isNull())
4916 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result);
4917 NewTL.setTypeofLoc(TL.getTypeofLoc());
4918 NewTL.setLParenLoc(TL.getLParenLoc());
4919 NewTL.setRParenLoc(TL.getRParenLoc());
4924 template<
typename Derived>
4925 QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
4927 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo();
4928 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);
4932 QualType Result = TL.getType();
4933 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {
4934 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType());
4935 if (Result.isNull())
4939 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result);
4940 NewTL.setTypeofLoc(TL.getTypeofLoc());
4941 NewTL.setLParenLoc(TL.getLParenLoc());
4942 NewTL.setRParenLoc(TL.getRParenLoc());
4943 NewTL.setUnderlyingTInfo(New_Under_TI);
4948 template<
typename Derived>
4949 QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
4950 DecltypeTypeLoc TL) {
4951 const DecltypeType *T = TL.getTypePtr();
4957 ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
4961 E = getSema().ActOnDecltypeExpression(E.get());
4965 QualType Result = TL.getType();
4966 if (getDerived().AlwaysRebuild() ||
4967 E.get() != T->getUnderlyingExpr()) {
4968 Result = getDerived().RebuildDecltypeType(E.get(), TL.getNameLoc());
4969 if (Result.isNull())
4974 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
4975 NewTL.setNameLoc(TL.getNameLoc());
4980 template<
typename Derived>
4981 QualType TreeTransform<Derived>::TransformUnaryTransformType(
4982 TypeLocBuilder &TLB,
4983 UnaryTransformTypeLoc TL) {
4984 QualType Result = TL.
getType();
4985 if (Result->isDependentType()) {
4986 const UnaryTransformType *T = TL.
getTypePtr();
4988 getDerived().TransformType(TL.getUnderlyingTInfo())->getType();
4989 Result = getDerived().RebuildUnaryTransformType(NewBase,
4992 if (Result.isNull())
4996 UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result);
4997 NewTL.setKWLoc(TL.getKWLoc());
4998 NewTL.setParensRange(TL.getParensRange());
4999 NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo());
5003 template<
typename Derived>
5004 QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
5006 const AutoType *T = TL.getTypePtr();
5007 QualType OldDeduced = T->getDeducedType();
5008 QualType NewDeduced;
5009 if (!OldDeduced.isNull()) {
5010 NewDeduced = getDerived().TransformType(OldDeduced);
5011 if (NewDeduced.isNull())
5015 QualType Result = TL.getType();
5016 if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
5017 T->isDependentType()) {
5018 Result = getDerived().RebuildAutoType(NewDeduced, T->isDecltypeAuto());
5019 if (Result.isNull())
5023 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
5024 NewTL.setNameLoc(TL.getNameLoc());
5029 template<
typename Derived>
5030 QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,
5032 const RecordType *T = TL.getTypePtr();
5034 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5039 QualType Result = TL.getType();
5040 if (getDerived().AlwaysRebuild() ||
5041 Record != T->getDecl()) {
5042 Result = getDerived().RebuildRecordType(Record);
5043 if (Result.isNull())
5047 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
5048 NewTL.setNameLoc(TL.getNameLoc());
5053 template<
typename Derived>
5054 QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
5056 const EnumType *T = TL.getTypePtr();
5058 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5063 QualType Result = TL.getType();
5064 if (getDerived().AlwaysRebuild() ||
5065 Enum != T->getDecl()) {
5066 Result = getDerived().RebuildEnumType(Enum);
5067 if (Result.isNull())
5071 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result);
5072 NewTL.setNameLoc(TL.getNameLoc());
5077 template<
typename Derived>
5078 QualType TreeTransform<Derived>::TransformInjectedClassNameType(
5079 TypeLocBuilder &TLB,
5080 InjectedClassNameTypeLoc TL) {
5081 Decl *D = getDerived().TransformDecl(TL.getNameLoc(),
5082 TL.getTypePtr()->getDecl());
5083 if (!D)
return QualType();
5085 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D));
5086 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc());
5090 template<
typename Derived>
5091 QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
5092 TypeLocBuilder &TLB,
5093 TemplateTypeParmTypeLoc TL) {
5097 template<
typename Derived>
5098 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
5099 TypeLocBuilder &TLB,
5100 SubstTemplateTypeParmTypeLoc TL) {
5101 const SubstTemplateTypeParmType *T = TL.getTypePtr();
5106 TemporaryBase Rebase(*
this, TL.getNameLoc(), DeclarationName());
5107 QualType Replacement = getDerived().TransformType(T->getReplacementType());
5108 if (Replacement.isNull())
5114 = SemaRef.Context.getSubstTemplateTypeParmType(T->getReplacedParameter(),
5118 SubstTemplateTypeParmTypeLoc NewTL
5119 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
5120 NewTL.setNameLoc(TL.getNameLoc());
5125 template<
typename Derived>
5126 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
5127 TypeLocBuilder &TLB,
5128 SubstTemplateTypeParmPackTypeLoc TL) {
5132 template<
typename Derived>
5147 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template);
5150 template<
typename Derived>
5158 if (getDerived().AlwaysRebuild() ||
5160 Result = getDerived().RebuildAtomicType(ValueType, TL.
getKWLoc());
5165 AtomicTypeLoc NewTL = TLB.
push<AtomicTypeLoc>(Result);
5178 template<
typename ArgLocContainer>
5180 ArgLocContainer *Container;
5205 : Container(&Container), Index(Index) { }
5219 return Container->getArgLoc(Index);
5223 return pointer(Container->getArgLoc(Index));
5228 return X.Container == Y.Container && X.Index == Y.Index;
5238 template <
typename Derived>
5240 TypeLocBuilder &TLB,
5241 TemplateSpecializationTypeLoc TL,
5242 TemplateName Template) {
5243 TemplateArgumentListInfo NewTemplateArgs;
5244 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
5245 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
5246 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>
5248 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5249 ArgIterator(TL, TL.getNumArgs()),
5256 getDerived().RebuildTemplateSpecializationType(Template,
5257 TL.getTemplateNameLoc(),
5260 if (!Result.isNull()) {
5265 if (isa<DependentTemplateSpecializationType>(Result)) {
5266 DependentTemplateSpecializationTypeLoc NewTL
5267 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
5268 NewTL.setElaboratedKeywordLoc(SourceLocation());
5269 NewTL.setQualifierLoc(NestedNameSpecifierLoc());
5270 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5271 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5272 NewTL.setLAngleLoc(TL.getLAngleLoc());
5273 NewTL.setRAngleLoc(TL.getRAngleLoc());
5274 for (
unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
5275 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
5279 TemplateSpecializationTypeLoc NewTL
5280 = TLB.push<TemplateSpecializationTypeLoc>(Result);
5281 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5282 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5283 NewTL.setLAngleLoc(TL.getLAngleLoc());
5284 NewTL.setRAngleLoc(TL.getRAngleLoc());
5285 for (
unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
5286 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
5292 template <
typename Derived>
5303 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5312 = getSema().Context.getDependentTemplateSpecializationType(
5314 DTN->getQualifier(),
5315 DTN->getIdentifier(),
5326 for (
unsigned i = 0, e = NewTemplateArgs.
size(); i != e; ++i)
5332 = getDerived().RebuildTemplateSpecializationType(Template,
5344 for (
unsigned i = 0, e = NewTemplateArgs.
size(); i != e; ++i)
5351 template<
typename Derived>
5366 QualType NamedT = getDerived().TransformType(TLB, TL.
getNamedTypeLoc());
5367 if (NamedT.isNull())
5375 if (
const TemplateSpecializationType *TST =
5376 NamedT->getAs<TemplateSpecializationType>()) {
5377 TemplateName Template = TST->getTemplateName();
5378 if (TypeAliasTemplateDecl *TAT = dyn_cast_or_null<TypeAliasTemplateDecl>(
5379 Template.getAsTemplateDecl())) {
5381 diag::err_tag_reference_non_tag) << 4;
5382 SemaRef.Diag(TAT->getLocation(), diag::note_declared_at);
5387 QualType Result = TL.
getType();
5388 if (getDerived().AlwaysRebuild() ||
5393 QualifierLoc, NamedT);
5394 if (Result.isNull())
5398 ElaboratedTypeLoc NewTL = TLB.
push<ElaboratedTypeLoc>(Result);
5400 NewTL.setQualifierLoc(QualifierLoc);
5404 template<
typename Derived>
5405 QualType TreeTransform<Derived>::TransformAttributedType(
5406 TypeLocBuilder &TLB,
5407 AttributedTypeLoc TL) {
5408 const AttributedType *oldType = TL.getTypePtr();
5409 QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc());
5410 if (modifiedType.isNull())
5413 QualType result = TL.getType();
5416 if (getDerived().AlwaysRebuild() ||
5417 modifiedType != oldType->getModifiedType()) {
5420 QualType equivalentType
5421 = getDerived().TransformType(oldType->getEquivalentType());
5422 if (equivalentType.isNull())
5427 if (
auto nullability = oldType->getImmediateNullability()) {
5428 if (!modifiedType->canHaveNullability()) {
5429 SemaRef.Diag(TL.getAttrNameLoc(), diag::err_nullability_nonpointer)
5435 result = SemaRef.Context.getAttributedType(oldType->getAttrKind(),
5440 AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result);
5441 newTL.setAttrNameLoc(TL.getAttrNameLoc());
5442 if (TL.hasAttrOperand())
5443 newTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5444 if (TL.hasAttrExprOperand())
5445 newTL.setAttrExprOperand(TL.getAttrExprOperand());
5446 else if (TL.hasAttrEnumOperand())
5447 newTL.setAttrEnumOperandLoc(TL.getAttrEnumOperandLoc());
5452 template<
typename Derived>
5454 TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB,
5456 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
5460 QualType Result = TL.getType();
5461 if (getDerived().AlwaysRebuild() ||
5462 Inner != TL.getInnerLoc().getType()) {
5463 Result = getDerived().RebuildParenType(Inner);
5464 if (Result.isNull())
5468 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result);
5469 NewTL.setLParenLoc(TL.getLParenLoc());
5470 NewTL.setRParenLoc(TL.getRParenLoc());
5474 template<
typename Derived>
5475 QualType TreeTransform<Derived>::TransformDependentNameType(TypeLocBuilder &TLB,
5476 DependentNameTypeLoc TL) {
5477 const DependentNameType *T = TL.getTypePtr();
5479 NestedNameSpecifierLoc QualifierLoc
5480 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
5485 = getDerived().RebuildDependentNameType(T->getKeyword(),
5486 TL.getElaboratedKeywordLoc(),
5490 if (Result.isNull())
5493 if (
const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) {
5494 QualType NamedT = ElabT->getNamedType();
5495 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc());
5497 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
5498 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5499 NewTL.setQualifierLoc(QualifierLoc);
5501 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result);
5502 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5503 NewTL.setQualifierLoc(QualifierLoc);
5504 NewTL.setNameLoc(TL.getNameLoc());
5509 template<
typename Derived>
5512 DependentTemplateSpecializationTypeLoc TL) {
5513 NestedNameSpecifierLoc QualifierLoc;
5514 if (TL.getQualifierLoc()) {
5516 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
5522 .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc);
5525 template<
typename Derived>
5538 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5544 = getDerived().RebuildDependentTemplateSpecializationType(T->
getKeyword(),
5552 if (
const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) {
5553 QualType NamedT = ElabT->getNamedType();
5562 for (
unsigned I = 0, E = NewTemplateArgs.
size(); I != E; ++I)
5569 }
else if (isa<DependentTemplateSpecializationType>(Result)) {
5578 for (
unsigned I = 0, E = NewTemplateArgs.
size(); I != E; ++I)
5587 for (
unsigned I = 0, E = NewTemplateArgs.
size(); I != E; ++I)
5593 template<
typename Derived>
5602 if (getDerived().AlwaysRebuild() ||
5604 Result = getDerived().RebuildPackExpansionType(Pattern,
5612 PackExpansionTypeLoc NewT = TLB.
push<PackExpansionTypeLoc>(Result);
5617 template<
typename Derived>
5619 TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
5620 ObjCInterfaceTypeLoc TL) {
5622 TLB.pushFullCopy(TL);
5623 return TL.getType();
5626 template<
typename Derived>
5628 TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
5629 ObjCObjectTypeLoc TL) {
5631 QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc());
5632 if (BaseType.isNull())
5635 bool AnyChanged = BaseType != TL.getBaseLoc().getType();
5638 SmallVector<TypeSourceInfo *, 4> NewTypeArgInfos;
5639 for (
unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) {
5640 TypeSourceInfo *TypeArgInfo = TL.getTypeArgTInfo(i);
5641 TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc();
5642 QualType TypeArg = TypeArgInfo->getType();
5643 if (
auto PackExpansionLoc = TypeArgLoc.getAs<PackExpansionTypeLoc>()) {
5647 const auto *PackExpansion = PackExpansionLoc.getType()
5648 ->
castAs<PackExpansionType>();
5649 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
5650 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
5652 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
5656 TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc();
5657 bool Expand =
false;
5658 bool RetainExpansion =
false;
5659 Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
5660 if (getDerived().TryExpandParameterPacks(
5661 PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(),
5662 Unexpanded, Expand, RetainExpansion, NumExpansions))
5669 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
5671 TypeLocBuilder TypeArgBuilder;
5672 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
5673 QualType NewPatternType = getDerived().TransformType(TypeArgBuilder,
5675 if (NewPatternType.isNull())
5678 QualType NewExpansionType = SemaRef.Context.getPackExpansionType(
5679 NewPatternType, NumExpansions);
5680 auto NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(NewExpansionType);
5681 NewExpansionLoc.setEllipsisLoc(PackExpansionLoc.getEllipsisLoc());
5682 NewTypeArgInfos.push_back(
5683 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewExpansionType));
5689 for (
unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
5690 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);
5692 TypeLocBuilder TypeArgBuilder;
5693 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
5695 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder,
5697 if (NewTypeArg.isNull())
5700 NewTypeArgInfos.push_back(
5701 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
5707 TypeLocBuilder TypeArgBuilder;
5708 TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize());
5709 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder, TypeArgLoc);
5710 if (NewTypeArg.isNull())
5714 if (NewTypeArg == TypeArg) {
5715 NewTypeArgInfos.push_back(TypeArgInfo);
5719 NewTypeArgInfos.push_back(
5720 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
5724 QualType Result = TL.getType();
5725 if (getDerived().AlwaysRebuild() || AnyChanged) {
5727 Result = getDerived().RebuildObjCObjectType(
5730 TL.getTypeArgsLAngleLoc(),
5732 TL.getTypeArgsRAngleLoc(),
5733 TL.getProtocolLAngleLoc(),
5734 llvm::makeArrayRef(TL.getTypePtr()->qual_begin(),
5735 TL.getNumProtocols()),
5736 TL.getProtocolLocs(),
5737 TL.getProtocolRAngleLoc());
5739 if (Result.isNull())
5743 ObjCObjectTypeLoc NewT = TLB.push<ObjCObjectTypeLoc>(Result);
5744 assert(TL.hasBaseTypeAsWritten() &&
"Can't be dependent");
5745 NewT.setHasBaseTypeAsWritten(
true);
5746 NewT.setTypeArgsLAngleLoc(TL.getTypeArgsLAngleLoc());
5747 for (
unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)
5748 NewT.setTypeArgTInfo(i, NewTypeArgInfos[i]);
5749 NewT.setTypeArgsRAngleLoc(TL.getTypeArgsRAngleLoc());
5750 NewT.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
5751 for (
unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
5752 NewT.setProtocolLoc(i, TL.getProtocolLoc(i));
5753 NewT.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
5757 template<
typename Derived>
5759 TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
5760 ObjCObjectPointerTypeLoc TL) {
5761 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
5762 if (PointeeType.isNull())
5765 QualType Result = TL.getType();
5766 if (getDerived().AlwaysRebuild() ||
5767 PointeeType != TL.getPointeeLoc().getType()) {
5768 Result = getDerived().RebuildObjCObjectPointerType(PointeeType,
5770 if (Result.isNull())
5774 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
5775 NewT.setStarLoc(TL.getStarLoc());
5782 template<
typename Derived>
5784 TreeTransform<Derived>::TransformNullStmt(NullStmt *
S) {
5788 template<
typename Derived>
5791 return getDerived().TransformCompoundStmt(S,
false);
5794 template<
typename Derived>
5800 bool SubStmtInvalid =
false;
5801 bool SubStmtChanged =
false;
5803 for (
auto *B : S->
body()) {
5804 StmtResult Result = getDerived().TransformStmt(B);
5808 if (isa<DeclStmt>(B))
5812 SubStmtInvalid =
true;
5816 SubStmtChanged = SubStmtChanged || Result.
get() != B;
5817 Statements.push_back(Result.
getAs<
Stmt>());
5823 if (!getDerived().AlwaysRebuild() &&
5827 return getDerived().RebuildCompoundStmt(S->
getLBracLoc(),
5833 template<
typename Derived>
5835 TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
5838 EnterExpressionEvaluationContext Unevaluated(SemaRef,
5842 LHS = getDerived().TransformExpr(S->getLHS());
5843 LHS = SemaRef.ActOnConstantExpression(LHS);
5844 if (LHS.isInvalid())
5848 RHS = getDerived().TransformExpr(S->getRHS());
5849 RHS = SemaRef.ActOnConstantExpression(RHS);
5850 if (RHS.isInvalid())
5857 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
5859 S->getEllipsisLoc(),
5862 if (Case.isInvalid())
5866 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
5867 if (SubStmt.isInvalid())
5871 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get());
5874 template<
typename Derived>
5876 TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
5878 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
5879 if (SubStmt.isInvalid())
5883 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
5887 template<
typename Derived>
5889 TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) {
5890 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
5891 if (SubStmt.isInvalid())
5894 Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(),
5901 return getDerived().RebuildLabelStmt(S->getIdentLoc(),
5902 cast<LabelDecl>(LD), SourceLocation(),
5906 template <
typename Derived>
5914 #define PRAGMA_SPELLING_ATTR(X) \
5916 return getDerived().Transform##X##Attr(cast<X##Attr>(R));
5917 #include "clang/Basic/AttrList.inc"
5923 template <
typename Derived>
5925 bool AttrsChanged =
false;
5929 for (
const auto *I : S->
getAttrs()) {
5930 const Attr *R = getDerived().TransformAttr(I);
5931 AttrsChanged |= (I != R);
5936 if (SubStmt.isInvalid())
5939 if (SubStmt.get() == S->
getSubStmt() && !AttrsChanged)
5942 return getDerived().RebuildAttributedStmt(S->
getAttrLoc(), Attrs,
5946 template<
typename Derived>
5948 TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
5951 VarDecl *ConditionVar =
nullptr;
5952 if (S->getConditionVariable()) {
5954 = cast_or_null<VarDecl>(
5955 getDerived().TransformDefinition(
5956 S->getConditionVariable()->getLocation(),
5957 S->getConditionVariable()));
5961 Cond = getDerived().TransformExpr(S->getCond());
5963 if (Cond.isInvalid())
5968 ExprResult CondE = getSema().ActOnBooleanCondition(
nullptr, S->getIfLoc(),
5970 if (CondE.isInvalid())
5977 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.get()));
5978 if (!S->getConditionVariable() && S->getCond() && !FullCond.get())
5982 StmtResult Then = getDerived().TransformStmt(S->getThen());
5983 if (Then.isInvalid())
5987 StmtResult Else = getDerived().TransformStmt(S->getElse());
5988 if (Else.isInvalid())
5991 if (!getDerived().AlwaysRebuild() &&
5992 FullCond.get() == S->getCond() &&
5993 ConditionVar == S->getConditionVariable() &&
5994 Then.get() == S->getThen() &&
5995 Else.get() == S->getElse())
5998 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar,
6000 S->getElseLoc(), Else.get());
6003 template<
typename Derived>
6005 TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
6008 VarDecl *ConditionVar =
nullptr;
6009 if (S->getConditionVariable()) {
6011 = cast_or_null<VarDecl>(
6012 getDerived().TransformDefinition(
6013 S->getConditionVariable()->getLocation(),
6014 S->getConditionVariable()));
6018 Cond = getDerived().TransformExpr(S->getCond());
6020 if (Cond.isInvalid())
6026 = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), Cond.get(),
6028 if (Switch.isInvalid())
6032 StmtResult Body = getDerived().TransformStmt(S->getBody());
6033 if (Body.isInvalid())
6037 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(),
6041 template<
typename Derived>
6043 TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
6046 VarDecl *ConditionVar =
nullptr;
6047 if (S->getConditionVariable()) {
6049 = cast_or_null<VarDecl>(
6050 getDerived().TransformDefinition(
6051 S->getConditionVariable()->getLocation(),
6052 S->getConditionVariable()));
6056 Cond = getDerived().TransformExpr(S->getCond());
6058 if (Cond.isInvalid())
6063 ExprResult CondE = getSema().ActOnBooleanCondition(
nullptr,
6066 if (CondE.isInvalid())
6072 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.get()));
6073 if (!S->getConditionVariable() && S->getCond() && !FullCond.get())
6077 StmtResult Body = getDerived().TransformStmt(S->getBody());
6078 if (Body.isInvalid())
6081 if (!getDerived().AlwaysRebuild() &&
6082 FullCond.get() == S->getCond() &&
6083 ConditionVar == S->getConditionVariable() &&
6084 Body.get() == S->getBody())
6087 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond,
6088 ConditionVar, Body.get());
6091 template<
typename Derived>
6093 TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
6095 StmtResult Body = getDerived().TransformStmt(S->getBody());
6096 if (Body.isInvalid())
6100 ExprResult Cond = getDerived().TransformExpr(S->getCond());
6101 if (Cond.isInvalid())
6104 if (!getDerived().AlwaysRebuild() &&
6105 Cond.get() == S->getCond() &&
6106 Body.get() == S->getBody())
6109 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(),
6110 S->getWhileLoc(), Cond.get(),
6114 template<
typename Derived>
6116 TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
6118 StmtResult Init = getDerived().TransformStmt(S->getInit());
6119 if (Init.isInvalid())
6124 VarDecl *ConditionVar =
nullptr;
6125 if (S->getConditionVariable()) {
6127 = cast_or_null<VarDecl>(
6128 getDerived().TransformDefinition(
6129 S->getConditionVariable()->getLocation(),
6130 S->getConditionVariable()));
6134 Cond = getDerived().TransformExpr(S->getCond());
6136 if (Cond.isInvalid())
6141 ExprResult CondE = getSema().ActOnBooleanCondition(
nullptr,
6144 if (CondE.isInvalid())
6151 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.get()));
6152 if (!S->getConditionVariable() && S->getCond() && !FullCond.get())
6156 ExprResult Inc = getDerived().TransformExpr(S->getInc());
6157 if (Inc.isInvalid())
6160 Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(Inc.get()));
6161 if (S->getInc() && !FullInc.get())
6165 StmtResult Body = getDerived().TransformStmt(S->getBody());
6166 if (Body.isInvalid())
6169 if (!getDerived().AlwaysRebuild() &&
6170 Init.get() == S->getInit() &&
6171 FullCond.get() == S->getCond() &&
6172 Inc.get() == S->getInc() &&
6173 Body.get() == S->getBody())
6176 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
6177 Init.get(), FullCond, ConditionVar,
6178 FullInc, S->getRParenLoc(), Body.get());
6181 template<
typename Derived>
6183 TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
6184 Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(),
6190 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
6191 cast<LabelDecl>(LD));
6194 template<
typename Derived>
6196 TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
6197 ExprResult Target = getDerived().TransformExpr(S->getTarget());
6198 if (Target.isInvalid())
6200 Target = SemaRef.MaybeCreateExprWithCleanups(Target.get());
6202 if (!getDerived().AlwaysRebuild() &&
6203 Target.get() == S->getTarget())
6206 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
6210 template<
typename Derived>
6212 TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
6216 template<
typename Derived>
6218 TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
6222 template<
typename Derived>
6224 TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
6225 ExprResult Result = getDerived().TransformInitializer(S->getRetValue(),
6227 if (Result.isInvalid())
6232 return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get());
6235 template<
typename Derived>
6237 TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
6238 bool DeclChanged =
false;
6239 SmallVector<Decl *, 4> Decls;
6240 for (
auto *D : S->decls()) {
6241 Decl *Transformed = getDerived().TransformDefinition(D->getLocation(), D);
6245 if (Transformed != D)
6248 Decls.push_back(Transformed);
6251 if (!getDerived().AlwaysRebuild() && !DeclChanged)
6254 return getDerived().RebuildDeclStmt(Decls, S->getStartLoc(), S->getEndLoc());
6257 template<
typename Derived>
6259 TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) {
6261 SmallVector<Expr*, 8> Constraints;
6262 SmallVector<Expr*, 8> Exprs;
6263 SmallVector<IdentifierInfo *, 4> Names;
6266 SmallVector<Expr*, 8> Clobbers;
6268 bool ExprsChanged =
false;
6271 for (
unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) {
6272 Names.push_back(S->getOutputIdentifier(I));
6275 Constraints.push_back(S->getOutputConstraintLiteral(I));
6278 Expr *OutputExpr = S->getOutputExpr(I);
6279 ExprResult Result = getDerived().TransformExpr(OutputExpr);
6280 if (Result.isInvalid())
6283 ExprsChanged |= Result.
get() != OutputExpr;
6285 Exprs.push_back(Result.get());
6289 for (
unsigned I = 0, E = S->getNumInputs(); I != E; ++I) {
6290 Names.push_back(S->getInputIdentifier(I));
6293 Constraints.push_back(S->getInputConstraintLiteral(I));
6296 Expr *InputExpr = S->getInputExpr(I);
6297 ExprResult Result = getDerived().TransformExpr(InputExpr);
6298 if (Result.isInvalid())
6301 ExprsChanged |= Result.
get() != InputExpr;
6303 Exprs.push_back(Result.get());
6306 if (!getDerived().AlwaysRebuild() && !ExprsChanged)
6310 for (
unsigned I = 0, E = S->getNumClobbers(); I != E; ++I)
6311 Clobbers.push_back(S->getClobberStringLiteral(I));
6314 AsmString = S->getAsmString();
6315 return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(),
6316 S->isVolatile(), S->getNumOutputs(),
6317 S->getNumInputs(), Names.data(),
6318 Constraints, Exprs, AsmString.get(),
6319 Clobbers, S->getRParenLoc());
6322 template<
typename Derived>
6324 TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
6325 ArrayRef<Token> AsmToks =
6326 llvm::makeArrayRef(S->getAsmToks(), S->getNumAsmToks());
6328 bool HadError =
false, HadChange =
false;
6330 ArrayRef<Expr*> SrcExprs = S->getAllExprs();
6331 SmallVector<Expr*, 8> TransformedExprs;
6332 TransformedExprs.reserve(SrcExprs.size());
6333 for (
unsigned i = 0, e = SrcExprs.size(); i != e; ++i) {
6334 ExprResult Result = getDerived().TransformExpr(SrcExprs[i]);
6335 if (!Result.isUsable()) {
6338 HadChange |= (Result.get() != SrcExprs[i]);
6339 TransformedExprs.push_back(Result.get());
6344 if (!HadChange && !getDerived().AlwaysRebuild())
6347 return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(),
6348 AsmToks, S->getAsmString(),
6349 S->getNumOutputs(), S->getNumInputs(),
6350 S->getAllConstraints(), S->getClobbers(),
6351 TransformedExprs, S->getEndLoc());
6354 template<
typename Derived>
6356 TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
6358 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
6359 if (TryBody.isInvalid())
6363 bool AnyCatchChanged =
false;
6364 SmallVector<Stmt*, 8> CatchStmts;
6365 for (
unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
6366 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I));
6367 if (Catch.isInvalid())
6369 if (Catch.get() != S->getCatchStmt(I))
6370 AnyCatchChanged =
true;
6371 CatchStmts.push_back(Catch.get());
6376 if (S->getFinallyStmt()) {
6377 Finally = getDerived().TransformStmt(S->getFinallyStmt());
6378 if (Finally.isInvalid())
6383 if (!getDerived().AlwaysRebuild() &&
6384 TryBody.get() == S->getTryBody() &&
6386 Finally.get() == S->getFinallyStmt())
6390 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(),
6391 CatchStmts, Finally.get());
6394 template<
typename Derived>
6396 TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
6398 VarDecl *Var =
nullptr;
6399 if (VarDecl *FromVar = S->getCatchParamDecl()) {
6400 TypeSourceInfo *TSInfo =
nullptr;
6401 if (FromVar->getTypeSourceInfo()) {
6402 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
6409 T = TSInfo->getType();
6411 T = getDerived().TransformType(FromVar->getType());
6416 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T);
6421 StmtResult Body = getDerived().TransformStmt(S->getCatchBody());
6422 if (Body.isInvalid())
6425 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
6430 template<
typename Derived>
6432 TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
6434 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
6435 if (Body.isInvalid())
6439 if (!getDerived().AlwaysRebuild() &&
6440 Body.get() == S->getFinallyBody())
6444 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
6448 template<
typename Derived>
6450 TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
6452 if (S->getThrowExpr()) {
6453 Operand = getDerived().TransformExpr(S->getThrowExpr());
6454 if (Operand.isInvalid())
6458 if (!getDerived().AlwaysRebuild() &&
6459 Operand.get() == S->getThrowExpr())
6462 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get());
6465 template<
typename Derived>
6467 TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
6468 ObjCAtSynchronizedStmt *S) {
6470 ExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
6471 if (Object.isInvalid())
6474 getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(),
6476 if (Object.isInvalid())
6480 StmtResult Body = getDerived().TransformStmt(S->getSynchBody());
6481 if (Body.isInvalid())
6485 if (!getDerived().AlwaysRebuild() &&
6486 Object.get() == S->getSynchExpr() &&
6487 Body.get() == S->getSynchBody())
6491 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
6492 Object.get(), Body.get());
6495 template<
typename Derived>
6497 TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt(
6498 ObjCAutoreleasePoolStmt *S) {
6500 StmtResult Body = getDerived().TransformStmt(S->getSubStmt());
6501 if (Body.isInvalid())
6505 if (!getDerived().AlwaysRebuild() &&
6506 Body.get() == S->getSubStmt())
6510 return getDerived().RebuildObjCAutoreleasePoolStmt(
6511 S->getAtLoc(), Body.get());
6514 template<
typename Derived>
6516 TreeTransform<Derived>::TransformObjCForCollectionStmt(
6517 ObjCForCollectionStmt *S) {
6519 StmtResult Element = getDerived().TransformStmt(S->getElement());
6520 if (Element.isInvalid())
6524 ExprResult Collection = getDerived().TransformExpr(S->getCollection());
6525 if (Collection.isInvalid())
6529 StmtResult Body = getDerived().TransformStmt(S->getBody());
6530 if (Body.isInvalid())
6534 if (!getDerived().AlwaysRebuild() &&
6535 Element.get() == S->getElement() &&
6536 Collection.get() == S->getCollection() &&
6537 Body.get() == S->getBody())
6541 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
6548 template <
typename Derived>
6549 StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
6551 VarDecl *Var =
nullptr;
6552 if (VarDecl *ExceptionDecl = S->getExceptionDecl()) {
6554 getDerived().TransformType(ExceptionDecl->getTypeSourceInfo());
6558 Var = getDerived().RebuildExceptionDecl(
6559 ExceptionDecl, T, ExceptionDecl->getInnerLocStart(),
6560 ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier());
6561 if (!Var || Var->isInvalidDecl())
6566 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
6567 if (Handler.isInvalid())
6570 if (!getDerived().AlwaysRebuild() && !Var &&
6571 Handler.get() == S->getHandlerBlock())
6574 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get());
6577 template <
typename Derived>
6578 StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
6580 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
6581 if (TryBlock.isInvalid())
6585 bool HandlerChanged =
false;
6586 SmallVector<Stmt *, 8> Handlers;
6587 for (
unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) {
6588 StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(I));
6589 if (Handler.isInvalid())
6592 HandlerChanged = HandlerChanged || Handler.
get() != S->getHandler(I);
6593 Handlers.push_back(Handler.getAs<
Stmt>());
6596 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
6600 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(),
6604 template<
typename Derived>
6606 TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) {
6607 StmtResult Range = getDerived().TransformStmt(S->getRangeStmt());
6608 if (Range.isInvalid())
6611 StmtResult BeginEnd = getDerived().TransformStmt(S->getBeginEndStmt());
6612 if (BeginEnd.isInvalid())
6615 ExprResult Cond = getDerived().TransformExpr(S->getCond());
6616 if (Cond.isInvalid())
6619 Cond = SemaRef.CheckBooleanCondition(Cond.get(), S->getColonLoc());
6620 if (Cond.isInvalid())
6623 Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.get());
6625 ExprResult Inc = getDerived().TransformExpr(S->getInc());
6626 if (Inc.isInvalid())
6629 Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.get());
6631 StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt());
6632 if (LoopVar.isInvalid())
6636 if (getDerived().AlwaysRebuild() ||
6637 Range.get() != S->getRangeStmt() ||
6638 BeginEnd.get() != S->getBeginEndStmt() ||
6639 Cond.get() != S->getCond() ||
6640 Inc.get() != S->getInc() ||
6641 LoopVar.get() != S->getLoopVarStmt()) {
6642 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
6643 S->getColonLoc(), Range.get(),
6644 BeginEnd.get(), Cond.get(),
6645 Inc.get(), LoopVar.get(),
6647 if (NewStmt.isInvalid())
6651 StmtResult Body = getDerived().TransformStmt(S->getBody());
6652 if (Body.isInvalid())
6657 if (Body.get() != S->getBody() && NewStmt.get() ==
S) {
6658 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
6659 S->getColonLoc(), Range.get(),
6660 BeginEnd.get(), Cond.get(),
6661 Inc.get(), LoopVar.get(),
6663 if (NewStmt.isInvalid())
6667 if (NewStmt.get() ==
S)
6670 return FinishCXXForRangeStmt(NewStmt.get(), Body.get());
6673 template<
typename Derived>
6675 TreeTransform<Derived>::TransformMSDependentExistsStmt(
6676 MSDependentExistsStmt *S) {
6678 NestedNameSpecifierLoc QualifierLoc;
6679 if (S->getQualifierLoc()) {
6681 = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc());
6687 DeclarationNameInfo NameInfo = S->getNameInfo();
6688 if (NameInfo.getName()) {
6689 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
6690 if (!NameInfo.getName())
6695 if (!getDerived().AlwaysRebuild() &&
6696 QualifierLoc == S->getQualifierLoc() &&
6697 NameInfo.getName() == S->getNameInfo().getName())
6702 SS.Adopt(QualifierLoc);
6703 bool Dependent =
false;
6704 switch (getSema().CheckMicrosoftIfExistsSymbol(
nullptr, SS, NameInfo)) {
6706 if (S->isIfExists())
6709 return new (getSema().Context) NullStmt(S->getKeywordLoc());
6712 if (S->isIfNotExists())
6715 return new (getSema().Context) NullStmt(S->getKeywordLoc());
6726 StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt());
6727 if (SubStmt.isInvalid())
6735 return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(),
6742 template<
typename Derived>
6744 TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *E) {
6745 NestedNameSpecifierLoc QualifierLoc;
6746 if (E->getQualifierLoc()) {
6748 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
6753 MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>(
6754 getDerived().TransformDecl(E->getMemberLoc(), E->getPropertyDecl()));
6759 if (Base.isInvalid())
6762 return new (SemaRef.getASTContext())
6763 MSPropertyRefExpr(Base.get(), PD, E->isArrow(),
6764 SemaRef.getASTContext().PseudoObjectTy,
VK_LValue,
6765 QualifierLoc, E->getMemberLoc());
6768 template <
typename Derived>
6769 StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) {
6770 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
6771 if (TryBlock.isInvalid())
6774 StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler());
6775 if (Handler.isInvalid())
6778 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
6779 Handler.get() == S->getHandler())
6782 return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(),
6783 TryBlock.get(), Handler.get());
6786 template <
typename Derived>
6787 StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) {
6788 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
6789 if (Block.isInvalid())
6792 return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.get());
6795 template <
typename Derived>
6796 StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) {
6797 ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr());
6798 if (FilterExpr.isInvalid())
6801 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
6802 if (Block.isInvalid())
6805 return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(),
6809 template <
typename Derived>
6811 if (isa<SEHFinallyStmt>(Handler))
6812 return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler));
6814 return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler));
6817 template<
typename Derived>
6826 template <
typename Derived>
6833 TClauses.reserve(Clauses.size());
6837 getDerived().getSema().StartOpenMPClause((*I)->getClauseKind());
6838 OMPClause *Clause = getDerived().TransformOMPClause(*I);
6839 getDerived().getSema().EndOpenMPClause();
6841 TClauses.push_back(Clause);
6843 TClauses.push_back(
nullptr);
6856 Body = getDerived().TransformStmt(
6860 getDerived().getSema().ActOnOpenMPRegionEnd(Body, TClauses);
6865 if (TClauses.size() != Clauses.size()) {
6872 DirName = cast<OMPCriticalDirective>(D)->getDirectiveName();
6873 DirName = getDerived().TransformDeclarationNameInfo(DirName);
6877 CancelRegion = cast<OMPCancellationPointDirective>(D)->getCancelRegion();
6879 CancelRegion = cast<OMPCancelDirective>(D)->getCancelRegion();
6882 return getDerived().RebuildOMPExecutableDirective(
6887 template <
typename Derived>
6891 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel, DirName,
nullptr,
6893 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
6894 getDerived().getSema().EndOpenMPDSABlock(Res.
get());
6898 template <
typename Derived>
6900 TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *D) {
6901 DeclarationNameInfo DirName;
6902 getDerived().getSema().StartOpenMPDSABlock(OMPD_simd, DirName,
nullptr,
6904 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
6905 getDerived().getSema().EndOpenMPDSABlock(Res.get());
6909 template <
typename Derived>
6911 TreeTransform<Derived>::TransformOMPForDirective(OMPForDirective *D) {
6912 DeclarationNameInfo DirName;
6913 getDerived().getSema().StartOpenMPDSABlock(OMPD_for, DirName,
nullptr,
6915 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
6916 getDerived().getSema().EndOpenMPDSABlock(Res.get());
6920 template <
typename Derived>
6922 TreeTransform<Derived>::TransformOMPForSimdDirective(OMPForSimdDirective *D) {
6923 DeclarationNameInfo DirName;
6924 getDerived().getSema().StartOpenMPDSABlock(OMPD_for_simd, DirName,
nullptr,
6926 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
6927 getDerived().getSema().EndOpenMPDSABlock(Res.get());
6931 template <
typename Derived>
6933 TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *D) {
6934 DeclarationNameInfo DirName;
6935 getDerived().getSema().StartOpenMPDSABlock(OMPD_sections, DirName,
nullptr,
6937 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
6938 getDerived().getSema().EndOpenMPDSABlock(Res.get());
6942 template <
typename Derived>
6944 TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *D) {
6945 DeclarationNameInfo DirName;
6946 getDerived().getSema().StartOpenMPDSABlock(OMPD_section, DirName,
nullptr,
6948 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
6949 getDerived().getSema().EndOpenMPDSABlock(Res.get());
6953 template <
typename Derived>
6955 TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *D) {
6956 DeclarationNameInfo DirName;
6957 getDerived().getSema().StartOpenMPDSABlock(OMPD_single, DirName,
nullptr,
6959 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
6960 getDerived().getSema().EndOpenMPDSABlock(Res.get());
6964 template <
typename Derived>
6966 TreeTransform<Derived>::TransformOMPMasterDirective(OMPMasterDirective *D) {
6967 DeclarationNameInfo DirName;
6968 getDerived().getSema().StartOpenMPDSABlock(OMPD_master, DirName,
nullptr,
6970 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
6971 getDerived().getSema().EndOpenMPDSABlock(Res.get());
6975 template <
typename Derived>
6977 TreeTransform<Derived>::TransformOMPCriticalDirective(OMPCriticalDirective *D) {
6978 getDerived().getSema().StartOpenMPDSABlock(
6979 OMPD_critical, D->getDirectiveName(),
nullptr, D->getLocStart());
6980 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
6981 getDerived().getSema().EndOpenMPDSABlock(Res.get());
6985 template <
typename Derived>
6986 StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective(
6987 OMPParallelForDirective *D) {
6988 DeclarationNameInfo DirName;
6989 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for, DirName,
6990 nullptr, D->getLocStart());
6991 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
6992 getDerived().getSema().EndOpenMPDSABlock(Res.get());
6996 template <
typename Derived>
6997 StmtResult TreeTransform<Derived>::TransformOMPParallelForSimdDirective(
6998 OMPParallelForSimdDirective *D) {
6999 DeclarationNameInfo DirName;
7000 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for_simd, DirName,
7001 nullptr, D->getLocStart());
7002 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7003 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7007 template <
typename Derived>
7008 StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective(
7009 OMPParallelSectionsDirective *D) {
7010 DeclarationNameInfo DirName;
7011 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_sections, DirName,
7012 nullptr, D->getLocStart());
7013 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7014 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7018 template <
typename Derived>
7020 TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *D) {
7021 DeclarationNameInfo DirName;
7022 getDerived().getSema().StartOpenMPDSABlock(OMPD_task, DirName,
nullptr,
7024 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7025 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7029 template <
typename Derived>
7030 StmtResult TreeTransform<Derived>::TransformOMPTaskyieldDirective(
7031 OMPTaskyieldDirective *D) {
7032 DeclarationNameInfo DirName;
7033 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskyield, DirName,
nullptr,
7035 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7036 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7040 template <
typename Derived>
7042 TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *D) {
7043 DeclarationNameInfo DirName;
7044 getDerived().getSema().StartOpenMPDSABlock(OMPD_barrier, DirName,
nullptr,
7046 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7047 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7051 template <
typename Derived>
7053 TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
7054 DeclarationNameInfo DirName;
7055 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskwait, DirName,
nullptr,
7057 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7058 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7062 template <
typename Derived>
7063 StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective(
7064 OMPTaskgroupDirective *D) {
7065 DeclarationNameInfo DirName;
7066 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskgroup, DirName,
nullptr,
7068 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7069 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7073 template <
typename Derived>
7075 TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *D) {
7076 DeclarationNameInfo DirName;
7077 getDerived().getSema().StartOpenMPDSABlock(OMPD_flush, DirName,
nullptr,
7079 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7080 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7084 template <
typename Derived>
7086 TreeTransform<Derived>::TransformOMPOrderedDirective(OMPOrderedDirective *D) {
7087 DeclarationNameInfo DirName;
7088 getDerived().getSema().StartOpenMPDSABlock(OMPD_ordered, DirName,
nullptr,
7090 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7091 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7095 template <
typename Derived>
7097 TreeTransform<Derived>::TransformOMPAtomicDirective(OMPAtomicDirective *D) {
7098 DeclarationNameInfo DirName;
7099 getDerived().getSema().StartOpenMPDSABlock(OMPD_atomic, DirName,
nullptr,
7101 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7102 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7106 template <
typename Derived>
7108 TreeTransform<Derived>::TransformOMPTargetDirective(OMPTargetDirective *D) {
7109 DeclarationNameInfo DirName;
7110 getDerived().getSema().StartOpenMPDSABlock(OMPD_target, DirName,
nullptr,
7112 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7113 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7117 template <
typename Derived>
7119 TreeTransform<Derived>::TransformOMPTeamsDirective(OMPTeamsDirective *D) {
7120 DeclarationNameInfo DirName;
7121 getDerived().getSema().StartOpenMPDSABlock(OMPD_teams, DirName,
nullptr,
7123 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7124 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7128 template <
typename Derived>
7129 StmtResult TreeTransform<Derived>::TransformOMPCancellationPointDirective(
7130 OMPCancellationPointDirective *D) {
7131 DeclarationNameInfo DirName;
7132 getDerived().getSema().StartOpenMPDSABlock(OMPD_cancellation_point, DirName,
7133 nullptr, D->getLocStart());
7134 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7135 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7139 template <
typename Derived>
7141 TreeTransform<Derived>::TransformOMPCancelDirective(OMPCancelDirective *D) {
7142 DeclarationNameInfo DirName;
7143 getDerived().getSema().StartOpenMPDSABlock(OMPD_cancel, DirName,
nullptr,
7145 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7146 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7153 template <
typename Derived>
7154 OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *
C) {
7155 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
7156 if (Cond.isInvalid())
7158 return getDerived().RebuildOMPIfClause(Cond.get(), C->getLocStart(),
7159 C->getLParenLoc(), C->getLocEnd());
7162 template <
typename Derived>
7163 OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *C) {
7164 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
7165 if (Cond.isInvalid())
7167 return getDerived().RebuildOMPFinalClause(Cond.get(), C->getLocStart(),
7168 C->getLParenLoc(), C->getLocEnd());
7171 template <
typename Derived>
7173 TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *C) {
7174 ExprResult NumThreads = getDerived().TransformExpr(C->getNumThreads());
7175 if (NumThreads.isInvalid())
7177 return getDerived().RebuildOMPNumThreadsClause(
7178 NumThreads.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7181 template <
typename Derived>
7183 TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *C) {
7184 ExprResult E = getDerived().TransformExpr(C->getSafelen());
7187 return getDerived().RebuildOMPSafelenClause(
7188 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7191 template <
typename Derived>
7193 TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) {
7194 ExprResult E = getDerived().TransformExpr(C->getNumForLoops());
7197 return getDerived().RebuildOMPCollapseClause(
7198 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7201 template <
typename Derived>
7203 TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *C) {
7204 return getDerived().RebuildOMPDefaultClause(
7205 C->getDefaultKind(), C->getDefaultKindKwLoc(), C->getLocStart(),
7206 C->getLParenLoc(), C->getLocEnd());
7209 template <
typename Derived>
7211 TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *C) {
7212 return getDerived().RebuildOMPProcBindClause(
7213 C->getProcBindKind(), C->getProcBindKindKwLoc(), C->getLocStart(),
7214 C->getLParenLoc(), C->getLocEnd());
7217 template <
typename Derived>
7219 TreeTransform<Derived>::TransformOMPScheduleClause(OMPScheduleClause *C) {
7220 ExprResult E = getDerived().TransformExpr(C->getChunkSize());
7223 return getDerived().RebuildOMPScheduleClause(
7224 C->getScheduleKind(), E.get(), C->getLocStart(), C->getLParenLoc(),
7225 C->getScheduleKindLoc(), C->getCommaLoc(), C->getLocEnd());
7228 template <
typename Derived>
7230 TreeTransform<Derived>::TransformOMPOrderedClause(OMPOrderedClause *C) {
7235 template <
typename Derived>
7237 TreeTransform<Derived>::TransformOMPNowaitClause(OMPNowaitClause *C) {
7242 template <
typename Derived>
7244 TreeTransform<Derived>::TransformOMPUntiedClause(OMPUntiedClause *C) {
7249 template <
typename Derived>
7251 TreeTransform<Derived>::TransformOMPMergeableClause(OMPMergeableClause *C) {
7256 template <
typename Derived>
7257 OMPClause *TreeTransform<Derived>::TransformOMPReadClause(OMPReadClause *C) {
7262 template <
typename Derived>
7263 OMPClause *TreeTransform<Derived>::TransformOMPWriteClause(OMPWriteClause *C) {
7268 template <
typename Derived>
7270 TreeTransform<Derived>::TransformOMPUpdateClause(OMPUpdateClause *C) {
7275 template <
typename Derived>
7277 TreeTransform<Derived>::TransformOMPCaptureClause(OMPCaptureClause *C) {
7282 template <
typename Derived>
7284 TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *C) {
7289 template <
typename Derived>
7291 TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) {
7293 Vars.reserve(C->varlist_size());
7294 for (
auto *VE : C->varlists()) {
7295 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7296 if (EVar.isInvalid())
7298 Vars.push_back(EVar.get());
7300 return getDerived().RebuildOMPPrivateClause(
7301 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7304 template <
typename Derived>
7305 OMPClause *TreeTransform<Derived>::TransformOMPFirstprivateClause(
7306 OMPFirstprivateClause *C) {
7308 Vars.reserve(C->varlist_size());
7309 for (
auto *VE : C->varlists()) {
7310 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7311 if (EVar.isInvalid())
7313 Vars.push_back(EVar.get());
7315 return getDerived().RebuildOMPFirstprivateClause(
7316 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7319 template <
typename Derived>
7321 TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *C) {
7323 Vars.reserve(C->varlist_size());
7324 for (
auto *VE : C->varlists()) {
7325 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7326 if (EVar.isInvalid())
7328 Vars.push_back(EVar.get());
7330 return getDerived().RebuildOMPLastprivateClause(
7331 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7334 template <
typename Derived>
7336 TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *C) {
7338 Vars.reserve(C->varlist_size());
7339 for (
auto *VE : C->varlists()) {
7340 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7341 if (EVar.isInvalid())
7343 Vars.push_back(EVar.get());
7345 return getDerived().RebuildOMPSharedClause(Vars, C->getLocStart(),
7346 C->getLParenLoc(), C->getLocEnd());
7349 template <
typename Derived>
7351 TreeTransform<Derived>::TransformOMPReductionClause(OMPReductionClause *C) {
7353 Vars.reserve(C->varlist_size());
7354 for (
auto *VE : C->varlists()) {
7355 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7356 if (EVar.isInvalid())
7358 Vars.push_back(EVar.get());
7360 CXXScopeSpec ReductionIdScopeSpec;
7361 ReductionIdScopeSpec.Adopt(C->getQualifierLoc());
7363 DeclarationNameInfo NameInfo = C->getNameInfo();
7364 if (NameInfo.getName()) {
7365 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
7366 if (!NameInfo.getName())
7369 return getDerived().RebuildOMPReductionClause(
7370 Vars, C->getLocStart(), C->getLParenLoc(), C->getColonLoc(),
7371 C->getLocEnd(), ReductionIdScopeSpec, NameInfo);
7374 template <
typename Derived>
7376 TreeTransform<Derived>::TransformOMPLinearClause(
OMPLinearClause *C) {
7378 Vars.reserve(C->varlist_size());
7379 for (
auto *VE : C->varlists()) {
7380 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7381 if (EVar.isInvalid())
7383 Vars.push_back(EVar.get());
7386 if (Step.isInvalid())
7388 return getDerived().RebuildOMPLinearClause(Vars, Step.get(), C->getLocStart(),
7390 C->getColonLoc(), C->getLocEnd());
7393 template <
typename Derived>
7397 Vars.reserve(C->varlist_size());
7398 for (
auto *VE : C->varlists()) {
7399 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7400 if (EVar.isInvalid())
7402 Vars.push_back(EVar.get());
7405 if (Alignment.isInvalid())
7407 return getDerived().RebuildOMPAlignedClause(
7408 Vars, Alignment.get(), C->getLocStart(), C->getLParenLoc(),
7412 template <
typename Derived>
7414 TreeTransform<Derived>::TransformOMPCopyinClause(
OMPCopyinClause *C) {
7416 Vars.reserve(C->varlist_size());
7417 for (
auto *VE : C->varlists()) {
7418 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7419 if (EVar.isInvalid())
7421 Vars.push_back(EVar.get());
7423 return getDerived().RebuildOMPCopyinClause(Vars, C->getLocStart(),
7424 C->getLParenLoc(), C->getLocEnd());
7427 template <
typename Derived>
7431 Vars.reserve(C->varlist_size());
7432 for (
auto *VE : C->varlists()) {
7433 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7434 if (EVar.isInvalid())
7436 Vars.push_back(EVar.get());
7438 return getDerived().RebuildOMPCopyprivateClause(
7439 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7442 template <
typename Derived>
7443 OMPClause *TreeTransform<Derived>::TransformOMPFlushClause(
OMPFlushClause *C) {
7445 Vars.reserve(C->varlist_size());
7446 for (
auto *VE : C->varlists()) {
7447 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7448 if (EVar.isInvalid())
7450 Vars.push_back(EVar.get());
7452 return getDerived().RebuildOMPFlushClause(Vars, C->getLocStart(),
7453 C->getLParenLoc(), C->getLocEnd());
7456 template <
typename Derived>
7458 TreeTransform<Derived>::TransformOMPDependClause(
OMPDependClause *C) {
7460 Vars.reserve(C->varlist_size());
7461 for (
auto *VE : C->varlists()) {
7462 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7463 if (EVar.isInvalid())
7465 Vars.push_back(EVar.get());
7467 return getDerived().RebuildOMPDependClause(
7469 C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7475 template<
typename Derived>
7477 TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) {
7478 if (!E->isTypeDependent())
7481 return getDerived().RebuildPredefinedExpr(E->getLocation(),
7485 template<
typename Derived>
7487 TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) {
7488 NestedNameSpecifierLoc QualifierLoc;
7489 if (E->getQualifierLoc()) {
7491 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
7497 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
7502 DeclarationNameInfo NameInfo = E->getNameInfo();
7503 if (NameInfo.getName()) {
7504 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
7505 if (!NameInfo.getName())
7509 if (!getDerived().AlwaysRebuild() &&
7510 QualifierLoc == E->getQualifierLoc() &&
7511 ND == E->getDecl() &&
7512 NameInfo.getName() == E->getDecl()->getDeclName() &&
7513 !E->hasExplicitTemplateArgs()) {
7517 SemaRef.MarkDeclRefReferenced(E);
7522 TemplateArgumentListInfo TransArgs, *TemplateArgs =
nullptr;
7523 if (E->hasExplicitTemplateArgs()) {
7524 TemplateArgs = &TransArgs;
7525 TransArgs.setLAngleLoc(E->getLAngleLoc());
7526 TransArgs.setRAngleLoc(E->getRAngleLoc());
7527 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
7528 E->getNumTemplateArgs(),
7533 return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo,
7537 template<
typename Derived>
7539 TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) {
7543 template<
typename Derived>
7545 TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) {
7549 template<
typename Derived>
7551 TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) {
7555 template<
typename Derived>
7557 TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) {
7561 template<
typename Derived>
7563 TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) {
7567 template<
typename Derived>
7569 TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) {
7570 if (FunctionDecl *FD = E->getDirectCallee())
7571 SemaRef.MarkFunctionReferenced(E->getLocStart(), FD);
7572 return SemaRef.MaybeBindToTemporary(E);
7575 template<
typename Derived>
7577 TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) {
7579 getDerived().TransformExpr(E->getControllingExpr());
7580 if (ControllingExpr.isInvalid())
7583 SmallVector<Expr *, 4> AssocExprs;
7584 SmallVector<TypeSourceInfo *, 4> AssocTypes;
7585 for (
unsigned i = 0; i != E->getNumAssocs(); ++i) {
7586 TypeSourceInfo *TS = E->getAssocTypeSourceInfo(i);
7588 TypeSourceInfo *AssocType = getDerived().TransformType(TS);
7591 AssocTypes.push_back(AssocType);
7593 AssocTypes.push_back(
nullptr);
7596 ExprResult AssocExpr = getDerived().TransformExpr(E->getAssocExpr(i));
7597 if (AssocExpr.isInvalid())
7599 AssocExprs.push_back(AssocExpr.get());
7602 return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(),
7605 ControllingExpr.get(),
7610 template<
typename Derived>
7612 TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
7613 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
7614 if (SubExpr.isInvalid())
7617 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
7620 return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(),
7627 template<
typename Derived>
7631 return getDerived().TransformDependentScopeDeclRefExpr(DRE,
true,
nullptr);
7633 return getDerived().TransformExpr(E);
7636 template<
typename Derived>
7641 SubExpr = TransformAddressOfOperand(E->
getSubExpr());
7647 if (!getDerived().AlwaysRebuild() && SubExpr.
get() == E->
getSubExpr())
7655 template<
typename Derived>
7657 TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) {
7659 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
7669 bool ExprChanged =
false;
7670 typedef Sema::OffsetOfComponent Component;
7671 typedef OffsetOfExpr::OffsetOfNode
Node;
7672 SmallVector<Component, 4> Components;
7673 for (
unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
7674 const Node &ON = E->getComponent(I);
7676 Comp.isBrackets =
true;
7677 Comp.LocStart = ON.getSourceRange().getBegin();
7678 Comp.LocEnd = ON.getSourceRange().getEnd();
7679 switch (ON.getKind()) {
7681 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex());
7682 ExprResult Index = getDerived().TransformExpr(FromIndex);
7683 if (Index.isInvalid())
7686 ExprChanged = ExprChanged || Index.
get() != FromIndex;
7687 Comp.isBrackets =
true;
7688 Comp.U.E = Index.get();
7693 case Node::Identifier:
7694 Comp.isBrackets =
false;
7695 Comp.U.IdentInfo = ON.getFieldName();
7696 if (!Comp.U.IdentInfo)
7706 Components.push_back(Comp);
7710 if (!getDerived().AlwaysRebuild() &&
7711 Type == E->getTypeSourceInfo() &&
7716 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type,
7717 Components.data(), Components.size(),
7721 template<
typename Derived>
7723 TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) {
7724 assert(getDerived().AlreadyTransformed(E->getType()) &&
7725 "opaque value expression requires transformation");
7729 template<
typename Derived>
7731 TreeTransform<Derived>::TransformTypoExpr(TypoExpr *E) {
7735 template<
typename Derived>
7737 TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) {
7744 Expr *newSyntacticForm = SemaRef.recreateSyntacticForm(E);
7745 ExprResult result = getDerived().TransformExpr(newSyntacticForm);
7746 if (result.isInvalid())
return ExprError();
7751 if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject))
7752 result = SemaRef.checkPseudoObjectRValue(result.get());
7757 template<
typename Derived>
7759 TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr(
7760 UnaryExprOrTypeTraitExpr *E) {
7761 if (E->isArgumentType()) {
7762 TypeSourceInfo *OldT = E->getArgumentTypeInfo();
7764 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
7768 if (!getDerived().AlwaysRebuild() && OldT == NewT)
7771 return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(),
7773 E->getSourceRange());
7784 TypeSourceInfo *RecoveryTSI =
nullptr;
7786 auto *PE = dyn_cast<ParenExpr>(E->getArgumentExpr());
7788 PE ? dyn_cast<DependentScopeDeclRefExpr>(PE->getSubExpr()) :
nullptr)
7789 SubExpr = getDerived().TransformParenDependentScopeDeclRefExpr(
7790 PE, DRE,
false, &RecoveryTSI);
7792 SubExpr = getDerived().TransformExpr(E->getArgumentExpr());
7795 return getDerived().RebuildUnaryExprOrTypeTrait(
7796 RecoveryTSI, E->getOperatorLoc(), E->getKind(), E->getSourceRange());
7797 }
else if (SubExpr.isInvalid())
7800 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
7803 return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(),
7804 E->getOperatorLoc(),
7806 E->getSourceRange());
7809 template<
typename Derived>
7811 TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
7812 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
7813 if (LHS.isInvalid())
7816 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
7817 if (RHS.isInvalid())
7821 if (!getDerived().AlwaysRebuild() &&
7822 LHS.get() == E->getLHS() &&
7823 RHS.get() == E->getRHS())
7826 return getDerived().RebuildArraySubscriptExpr(LHS.get(),
7827 E->getLHS()->getLocStart(),
7829 E->getRBracketLoc());
7832 template<
typename Derived>
7834 TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
7836 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
7837 if (Callee.isInvalid())
7841 bool ArgChanged =
false;
7842 SmallVector<Expr*, 8> Args;
7843 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(),
true, Args,
7847 if (!getDerived().AlwaysRebuild() &&
7848 Callee.get() == E->getCallee() &&
7850 return SemaRef.MaybeBindToTemporary(E);
7853 SourceLocation FakeLParenLoc
7854 = ((Expr *)Callee.get())->getSourceRange().getBegin();
7855 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
7860 template<
typename Derived>
7862 TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
7863 ExprResult Base = getDerived().TransformExpr(E->getBase());
7864 if (Base.isInvalid())
7867 NestedNameSpecifierLoc QualifierLoc;
7868 if (E->hasQualifier()) {
7870 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
7875 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
7878 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
7879 E->getMemberDecl()));
7883 NamedDecl *FoundDecl = E->getFoundDecl();
7884 if (FoundDecl == E->getMemberDecl()) {
7887 FoundDecl = cast_or_null<NamedDecl>(
7888 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl));
7893 if (!getDerived().AlwaysRebuild() &&
7894 Base.get() == E->getBase() &&
7895 QualifierLoc == E->getQualifierLoc() &&
7896 Member == E->getMemberDecl() &&
7897 FoundDecl == E->getFoundDecl() &&
7898 !E->hasExplicitTemplateArgs()) {
7902 SemaRef.MarkMemberReferenced(E);
7907 TemplateArgumentListInfo TransArgs;
7908 if (E->hasExplicitTemplateArgs()) {
7909 TransArgs.setLAngleLoc(E->getLAngleLoc());
7910 TransArgs.setRAngleLoc(E->getRAngleLoc());
7911 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
7912 E->getNumTemplateArgs(),
7918 SourceLocation FakeOperatorLoc =
7919 SemaRef.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd());
7925 NamedDecl *FirstQualifierInScope =
nullptr;
7927 return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc,
7931 E->getMemberNameInfo(),
7934 (E->hasExplicitTemplateArgs()
7935 ? &TransArgs :
nullptr),
7936 FirstQualifierInScope);
7939 template<
typename Derived>
7941 TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
7942 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
7943 if (LHS.isInvalid())
7946 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
7947 if (RHS.isInvalid())
7950 if (!getDerived().AlwaysRebuild() &&
7951 LHS.get() == E->getLHS() &&
7952 RHS.get() == E->getRHS())
7955 Sema::FPContractStateRAII FPContractState(getSema());
7956 getSema().FPFeatures.fp_contract = E->isFPContractable();
7958 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
7959 LHS.get(), RHS.get());
7962 template<
typename Derived>
7964 TreeTransform<Derived>::TransformCompoundAssignOperator(
7965 CompoundAssignOperator *E) {
7966 return getDerived().TransformBinaryOperator(E);
7969 template<
typename Derived>
7971 TransformBinaryConditionalOperator(BinaryConditionalOperator *e) {
7975 ExprResult commonExpr = getDerived().TransformExpr(e->getCommon());
7976 if (commonExpr.isInvalid())
7979 ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr());
7980 if (rhs.isInvalid())
7983 if (!getDerived().AlwaysRebuild() &&
7984 commonExpr.get() == e->getCommon() &&
7985 rhs.get() == e->getFalseExpr())
7988 return getDerived().RebuildConditionalOperator(commonExpr.get(),
7989 e->getQuestionLoc(),
7995 template<
typename Derived>
7997 TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) {
7998 ExprResult Cond = getDerived().TransformExpr(E->getCond());
7999 if (Cond.isInvalid())
8002 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
8003 if (LHS.isInvalid())
8006 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
8007 if (RHS.isInvalid())
8010 if (!getDerived().AlwaysRebuild() &&
8011 Cond.get() == E->getCond() &&
8012 LHS.get() == E->getLHS() &&
8013 RHS.get() == E->getRHS())
8016 return getDerived().RebuildConditionalOperator(Cond.get(),
8017 E->getQuestionLoc(),
8023 template<
typename Derived>
8025 TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) {
8028 return getDerived().TransformExpr(E->getSubExprAsWritten());
8031 template<
typename Derived>
8033 TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
8034 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
8039 = getDerived().TransformExpr(E->getSubExprAsWritten());
8040 if (SubExpr.isInvalid())
8043 if (!getDerived().AlwaysRebuild() &&
8044 Type == E->getTypeInfoAsWritten() &&
8045 SubExpr.get() == E->getSubExpr())
8048 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
8054 template<
typename Derived>
8056 TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) {
8057 TypeSourceInfo *OldT = E->getTypeSourceInfo();
8058 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
8062 ExprResult Init = getDerived().TransformExpr(E->getInitializer());
8063 if (Init.isInvalid())
8066 if (!getDerived().AlwaysRebuild() &&
8068 Init.get() == E->getInitializer())
8069 return SemaRef.MaybeBindToTemporary(E);
8075 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT,
8076 E->getInitializer()->getLocEnd(),
8080 template<
typename Derived>
8082 TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) {
8083 ExprResult Base = getDerived().TransformExpr(E->getBase());
8084 if (Base.isInvalid())
8087 if (!getDerived().AlwaysRebuild() &&
8088 Base.get() == E->getBase())
8092 SourceLocation FakeOperatorLoc =
8093 SemaRef.getLocForEndOfToken(E->getBase()->getLocEnd());
8094 return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc,
8095 E->getAccessorLoc(),
8099 template<
typename Derived>
8101 TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) {
8102 if (InitListExpr *Syntactic = E->getSyntacticForm())
8105 bool InitChanged =
false;
8107 SmallVector<Expr*, 4>
Inits;
8108 if (getDerived().TransformExprs(E->getInits(), E->getNumInits(),
false,
8109 Inits, &InitChanged))
8112 if (!getDerived().AlwaysRebuild() && !InitChanged) {
8119 return getDerived().RebuildInitList(E->getLBraceLoc(),
Inits,
8120 E->getRBraceLoc(), E->getType());
8123 template<
typename Derived>
8125 TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) {
8129 ExprResult Init = getDerived().TransformExpr(E->getInit());
8130 if (Init.isInvalid())
8134 SmallVector<Expr*, 4> ArrayExprs;
8135 bool ExprChanged =
false;
8137 DEnd = E->designators_end();
8139 if (D->isFieldDesignator()) {
8146 if (D->isArrayDesignator()) {
8147 ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D));
8148 if (Index.isInvalid())
8152 D->getLBracketLoc()));
8154 ExprChanged = ExprChanged || Init.
get() != E->getArrayIndex(*D);
8155 ArrayExprs.push_back(Index.get());
8159 assert(D->isArrayRangeDesignator() &&
"New kind of designator?");
8161 = getDerived().TransformExpr(E->getArrayRangeStart(*D));
8162 if (Start.isInvalid())
8165 ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D));
8166 if (End.isInvalid())
8171 D->getLBracketLoc(),
8172 D->getEllipsisLoc()));
8174 ExprChanged = ExprChanged || Start.
get() != E->getArrayRangeStart(*D) ||
8175 End.get() != E->getArrayRangeEnd(*D);
8177 ArrayExprs.push_back(Start.get());
8178 ArrayExprs.push_back(End.get());
8181 if (!getDerived().AlwaysRebuild() &&
8182 Init.get() == E->getInit() &&
8186 return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs,
8187 E->getEqualOrColonLoc(),
8188 E->usesGNUSyntax(), Init.get());
8193 template<
typename Derived>
8195 TreeTransform<Derived>::TransformDesignatedInitUpdateExpr(
8196 DesignatedInitUpdateExpr *E) {
8197 llvm_unreachable(
"Unexpected DesignatedInitUpdateExpr in syntactic form of "
8202 template<
typename Derived>
8204 TreeTransform<Derived>::TransformNoInitExpr(
8206 llvm_unreachable(
"Unexpected NoInitExpr in syntactic form of initializer");
8210 template<
typename Derived>
8212 TreeTransform<Derived>::TransformImplicitValueInitExpr(
8213 ImplicitValueInitExpr *E) {
8214 TemporaryBase Rebase(*
this, E->getLocStart(), DeclarationName());
8218 QualType T = getDerived().TransformType(E->getType());
8222 if (!getDerived().AlwaysRebuild() &&
8226 return getDerived().RebuildImplicitValueInitExpr(T);
8229 template<
typename Derived>
8231 TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) {
8232 TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo());
8236 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
8237 if (SubExpr.isInvalid())
8240 if (!getDerived().AlwaysRebuild() &&
8241 TInfo == E->getWrittenTypeInfo() &&
8242 SubExpr.get() == E->getSubExpr())
8245 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(),
8246 TInfo, E->getRParenLoc());
8249 template<
typename Derived>
8251 TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) {
8252 bool ArgumentChanged =
false;
8253 SmallVector<Expr*, 4>
Inits;
8254 if (TransformExprs(E->getExprs(), E->getNumExprs(),
true,
Inits,
8258 return getDerived().RebuildParenListExpr(E->getLParenLoc(),
8268 template<
typename Derived>
8270 TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) {
8271 Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(),
8276 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
8277 cast<LabelDecl>(LD));
8280 template<
typename Derived>
8282 TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) {
8283 SemaRef.ActOnStartStmtExpr();
8285 = getDerived().TransformCompoundStmt(E->getSubStmt(),
true);
8286 if (SubStmt.isInvalid()) {
8287 SemaRef.ActOnStmtExprError();
8291 if (!getDerived().AlwaysRebuild() &&
8292 SubStmt.get() == E->getSubStmt()) {
8294 SemaRef.ActOnStmtExprError();
8295 return SemaRef.MaybeBindToTemporary(E);
8298 return getDerived().RebuildStmtExpr(E->getLParenLoc(),
8303 template<
typename Derived>
8305 TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) {
8306 ExprResult Cond = getDerived().TransformExpr(E->getCond());
8307 if (Cond.isInvalid())
8310 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
8311 if (LHS.isInvalid())
8314 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
8315 if (RHS.isInvalid())
8318 if (!getDerived().AlwaysRebuild() &&
8319 Cond.get() == E->getCond() &&
8320 LHS.get() == E->getLHS() &&
8321 RHS.get() == E->getRHS())
8324 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(),
8325 Cond.get(), LHS.get(), RHS.get(),
8329 template<
typename Derived>
8331 TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) {
8335 template<
typename Derived>
8337 TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
8338 switch (E->getOperator()) {
8342 case OO_Array_Delete:
8343 llvm_unreachable(
"new and delete operators cannot use CXXOperatorCallExpr");
8347 assert(E->getNumArgs() >= 1 &&
"Object call is missing arguments");
8350 ExprResult Object = getDerived().TransformExpr(E->getArg(0));
8351 if (Object.isInvalid())
8355 SourceLocation FakeLParenLoc = SemaRef.getLocForEndOfToken(
8356 static_cast<Expr *>(Object.get())->getLocEnd());
8359 SmallVector<Expr*, 8> Args;
8360 if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1,
true,
8364 return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc,
8369 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
8371 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
8372 #include "clang/Basic/OperatorKinds.def"
8377 case OO_Conditional:
8378 llvm_unreachable(
"conditional operator is not actually overloadable");
8382 llvm_unreachable(
"not an overloaded operator?");
8385 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
8386 if (Callee.isInvalid())
8390 if (E->getOperator() == OO_Amp)
8391 First = getDerived().TransformAddressOfOperand(E->getArg(0));
8393 First = getDerived().TransformExpr(E->getArg(0));
8394 if (First.isInvalid())
8398 if (E->getNumArgs() == 2) {
8399 Second = getDerived().TransformExpr(E->getArg(1));
8400 if (Second.isInvalid())
8404 if (!getDerived().AlwaysRebuild() &&
8405 Callee.get() == E->getCallee() &&
8406 First.get() == E->getArg(0) &&
8407 (E->getNumArgs() != 2 || Second.get() == E->getArg(1)))
8408 return SemaRef.MaybeBindToTemporary(E);
8410 Sema::FPContractStateRAII FPContractState(getSema());
8411 getSema().FPFeatures.fp_contract = E->isFPContractable();
8413 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(),
8414 E->getOperatorLoc(),
8420 template<
typename Derived>
8422 TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) {
8423 return getDerived().TransformCallExpr(E);
8426 template<
typename Derived>
8430 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
8431 if (Callee.isInvalid())
8435 ExprResult EC = getDerived().TransformCallExpr(E->getConfig());
8440 bool ArgChanged =
false;
8441 SmallVector<Expr*, 8> Args;
8442 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(),
true, Args,
8446 if (!getDerived().AlwaysRebuild() &&
8447 Callee.get() == E->getCallee() &&
8449 return SemaRef.MaybeBindToTemporary(E);
8452 SourceLocation FakeLParenLoc
8453 = ((Expr *)Callee.get())->getSourceRange().getBegin();
8454 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
8456 E->getRParenLoc(), EC.get());
8459 template<
typename Derived>
8471 if (!getDerived().AlwaysRebuild() &&
8475 return getDerived().RebuildCXXNamedCastExpr(
8482 template<
typename Derived>
8488 template<
typename Derived>
8490 TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
8491 return getDerived().TransformCXXNamedCastExpr(E);
8494 template<
typename Derived>
8496 TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
8497 CXXReinterpretCastExpr *E) {
8498 return getDerived().TransformCXXNamedCastExpr(E);
8501 template<
typename Derived>
8503 TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) {
8504 return getDerived().TransformCXXNamedCastExpr(E);
8507 template<
typename Derived>
8509 TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
8510 CXXFunctionalCastExpr *E) {
8511 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
8516 = getDerived().TransformExpr(E->getSubExprAsWritten());
8517 if (SubExpr.isInvalid())
8520 if (!getDerived().AlwaysRebuild() &&
8521 Type == E->getTypeInfoAsWritten() &&
8522 SubExpr.get() == E->getSubExpr())
8525 return getDerived().RebuildCXXFunctionalCastExpr(Type,
8531 template<
typename Derived>
8533 TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) {
8534 if (E->isTypeOperand()) {
8535 TypeSourceInfo *TInfo
8536 = getDerived().TransformType(E->getTypeOperandSourceInfo());
8540 if (!getDerived().AlwaysRebuild() &&
8541 TInfo == E->getTypeOperandSourceInfo())
8544 return getDerived().RebuildCXXTypeidExpr(E->getType(),
8557 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
8558 if (SubExpr.isInvalid())
8561 if (!getDerived().AlwaysRebuild() &&
8562 SubExpr.get() == E->getExprOperand())
8565 return getDerived().RebuildCXXTypeidExpr(E->getType(),
8571 template<
typename Derived>
8573 TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) {
8574 if (E->isTypeOperand()) {
8575 TypeSourceInfo *TInfo
8576 = getDerived().TransformType(E->getTypeOperandSourceInfo());
8580 if (!getDerived().AlwaysRebuild() &&
8581 TInfo == E->getTypeOperandSourceInfo())
8584 return getDerived().RebuildCXXUuidofExpr(E->getType(),
8592 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
8593 if (SubExpr.isInvalid())
8596 if (!getDerived().AlwaysRebuild() &&
8597 SubExpr.get() == E->getExprOperand())
8600 return getDerived().RebuildCXXUuidofExpr(E->getType(),
8606 template<
typename Derived>
8608 TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
8612 template<
typename Derived>
8614 TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
8615 CXXNullPtrLiteralExpr *E) {
8619 template<
typename Derived>
8621 TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) {
8622 QualType T = getSema().getCurrentThisType();
8624 if (!getDerived().AlwaysRebuild() && T == E->getType()) {
8626 getSema().CheckCXXThisCapture(E->getLocStart());
8630 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit());
8633 template<
typename Derived>
8635 TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) {
8636 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
8637 if (SubExpr.isInvalid())
8640 if (!getDerived().AlwaysRebuild() &&
8641 SubExpr.get() == E->getSubExpr())
8644 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(),
8645 E->isThrownVariableInScope());
8648 template<
typename Derived>
8650 TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
8652 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(),
8657 if (!getDerived().AlwaysRebuild() &&
8658 Param == E->getParam())
8661 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param);
8664 template<
typename Derived>
8666 TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
8668 = cast_or_null<FieldDecl>(getDerived().TransformDecl(E->getLocStart(),
8673 if (!getDerived().AlwaysRebuild() && Field == E->getField())
8676 return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field);
8679 template<
typename Derived>
8681 TreeTransform<Derived>::TransformCXXScalarValueInitExpr(
8682 CXXScalarValueInitExpr *E) {
8683 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
8687 if (!getDerived().AlwaysRebuild() &&
8688 T == E->getTypeSourceInfo())
8691 return getDerived().RebuildCXXScalarValueInitExpr(T,
8692 T->getTypeLoc().getEndLoc(),
8696 template<
typename Derived>
8698 TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) {
8700 TypeSourceInfo *AllocTypeInfo
8701 = getDerived().TransformType(E->getAllocatedTypeSourceInfo());
8706 ExprResult ArraySize = getDerived().TransformExpr(E->getArraySize());
8707 if (ArraySize.isInvalid())
8711 bool ArgumentChanged =
false;
8712 SmallVector<Expr*, 8> PlacementArgs;
8713 if (getDerived().TransformExprs(E->getPlacementArgs(),
8714 E->getNumPlacementArgs(),
true,
8715 PlacementArgs, &ArgumentChanged))
8719 Expr *OldInit = E->getInitializer();
8722 NewInit = getDerived().TransformInitializer(OldInit,
true);
8723 if (NewInit.isInvalid())
8727 FunctionDecl *OperatorNew =
nullptr;
8728 if (E->getOperatorNew()) {
8729 OperatorNew = cast_or_null<FunctionDecl>(
8730 getDerived().TransformDecl(E->getLocStart(),
8731 E->getOperatorNew()));
8736 FunctionDecl *OperatorDelete =
nullptr;
8737 if (E->getOperatorDelete()) {
8738 OperatorDelete = cast_or_null<FunctionDecl>(
8739 getDerived().TransformDecl(E->getLocStart(),
8740 E->getOperatorDelete()));
8741 if (!OperatorDelete)
8745 if (!getDerived().AlwaysRebuild() &&
8746 AllocTypeInfo == E->getAllocatedTypeSourceInfo() &&
8747 ArraySize.get() == E->getArraySize() &&
8748 NewInit.get() == OldInit &&
8749 OperatorNew == E->getOperatorNew() &&
8750 OperatorDelete == E->getOperatorDelete() &&
8755 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorNew);
8757 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete);
8759 if (E->isArray() && !E->getAllocatedType()->isDependentType()) {
8760 QualType ElementType
8761 = SemaRef.Context.getBaseElementType(E->getAllocatedType());
8762 if (
const RecordType *RecordT = ElementType->getAs<RecordType>()) {
8763 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordT->getDecl());
8764 if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(Record)) {
8765 SemaRef.MarkFunctionReferenced(E->getLocStart(), Destructor);
8773 QualType AllocType = AllocTypeInfo->getType();
8774 if (!ArraySize.get()) {
8780 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType);
8783 }
else if (
const ConstantArrayType *ConsArrayT
8784 = dyn_cast<ConstantArrayType>(ArrayT)) {
8786 SemaRef.Context.getSizeType(),
8788 AllocType = ConsArrayT->getElementType();
8789 }
else if (
const DependentSizedArrayType *DepArrayT
8790 = dyn_cast<DependentSizedArrayType>(ArrayT)) {
8791 if (DepArrayT->getSizeExpr()) {
8792 ArraySize = DepArrayT->getSizeExpr();
8793 AllocType = DepArrayT->getElementType();
8798 return getDerived().RebuildCXXNewExpr(E->getLocStart(),
8803 E->getTypeIdParens(),
8807 E->getDirectInitRange(),
8811 template<
typename Derived>
8813 TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) {
8814 ExprResult Operand = getDerived().TransformExpr(E->getArgument());
8815 if (Operand.isInvalid())
8819 FunctionDecl *OperatorDelete =
nullptr;
8820 if (E->getOperatorDelete()) {
8821 OperatorDelete = cast_or_null<FunctionDecl>(
8822 getDerived().TransformDecl(E->getLocStart(),
8823 E->getOperatorDelete()));
8824 if (!OperatorDelete)
8828 if (!getDerived().AlwaysRebuild() &&
8829 Operand.get() == E->getArgument() &&
8830 OperatorDelete == E->getOperatorDelete()) {
8834 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete);
8836 if (!E->getArgument()->isTypeDependent()) {
8837 QualType Destroyed = SemaRef.Context.getBaseElementType(
8838 E->getDestroyedType());
8839 if (
const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
8840 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
8841 SemaRef.MarkFunctionReferenced(E->getLocStart(),
8842 SemaRef.LookupDestructor(Record));
8849 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(),
8850 E->isGlobalDelete(),
8855 template<
typename Derived>
8857 TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
8858 CXXPseudoDestructorExpr *E) {
8859 ExprResult Base = getDerived().TransformExpr(E->getBase());
8860 if (Base.isInvalid())
8864 bool MayBePseudoDestructor =
false;
8865 Base = SemaRef.ActOnStartCXXMemberReference(
nullptr, Base.get(),
8866 E->getOperatorLoc(),
8867 E->isArrow()? tok::arrow : tok::period,
8869 MayBePseudoDestructor);
8870 if (Base.isInvalid())
8873 QualType ObjectType = ObjectTypePtr.
get();
8874 NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc();
8877 = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType);
8882 SS.Adopt(QualifierLoc);
8884 PseudoDestructorTypeStorage Destroyed;
8885 if (E->getDestroyedTypeInfo()) {
8886 TypeSourceInfo *DestroyedTypeInfo
8887 = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(),
8888 ObjectType,
nullptr, SS);
8889 if (!DestroyedTypeInfo)
8891 Destroyed = DestroyedTypeInfo;
8892 }
else if (!ObjectType.isNull() && ObjectType->isDependentType()) {
8895 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(),
8896 E->getDestroyedTypeLoc());
8899 ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(),
8900 *E->getDestroyedTypeIdentifier(),
8901 E->getDestroyedTypeLoc(),
8909 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T),
8910 E->getDestroyedTypeLoc());
8913 TypeSourceInfo *ScopeTypeInfo =
nullptr;
8914 if (E->getScopeTypeInfo()) {
8915 CXXScopeSpec EmptySS;
8916 ScopeTypeInfo = getDerived().TransformTypeInObjectScope(
8917 E->getScopeTypeInfo(), ObjectType,
nullptr, EmptySS);
8922 return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(),
8923 E->getOperatorLoc(),
8927 E->getColonColonLoc(),
8932 template<
typename Derived>
8934 TreeTransform<Derived>::TransformUnresolvedLookupExpr(
8935 UnresolvedLookupExpr *Old) {
8936 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(),
8941 E = Old->decls_end(); I != E; ++I) {
8942 NamedDecl *InstD =
static_cast<NamedDecl*
>(
8943 getDerived().TransformDecl(Old->getNameLoc(),
8948 if (isa<UsingShadowDecl>(*I))
8957 if (isa<UsingDecl>(InstD)) {
8958 UsingDecl *UD = cast<UsingDecl>(InstD);
8959 for (
auto *I : UD->shadows())
8973 if (Old->getQualifierLoc()) {
8974 NestedNameSpecifierLoc QualifierLoc
8975 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
8979 SS.Adopt(QualifierLoc);
8982 if (Old->getNamingClass()) {
8983 CXXRecordDecl *NamingClass
8984 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
8986 Old->getNamingClass()));
8992 R.setNamingClass(NamingClass);
8995 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
8999 if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid())
9000 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL());
9004 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc());
9005 if (Old->hasExplicitTemplateArgs() &&
9006 getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
9007 Old->getNumTemplateArgs(),
9013 return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R,
9014 Old->requiresADL(), &TransArgs);
9017 template<
typename Derived>
9019 TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) {
9020 bool ArgChanged =
false;
9021 SmallVector<TypeSourceInfo *, 4> Args;
9022 for (
unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
9023 TypeSourceInfo *From = E->getArg(I);
9024 TypeLoc FromTL = From->getTypeLoc();
9025 if (!FromTL.getAs<PackExpansionTypeLoc>()) {
9027 TLB.reserve(FromTL.getFullDataSize());
9028 QualType To = getDerived().TransformType(TLB, FromTL);
9032 if (To == From->getType())
9033 Args.push_back(From);
9035 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
9044 PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>();
9045 TypeLoc PatternTL = ExpansionTL.getPatternLoc();
9046 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
9047 SemaRef.collectUnexpandedParameterPacks(PatternTL, Unexpanded);
9052 bool RetainExpansion =
false;
9053 Optional<unsigned> OrigNumExpansions =
9054 ExpansionTL.getTypePtr()->getNumExpansions();
9055 Optional<unsigned> NumExpansions = OrigNumExpansions;
9056 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
9057 PatternTL.getSourceRange(),
9059 Expand, RetainExpansion,
9067 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
9070 TLB.reserve(From->getTypeLoc().getFullDataSize());
9072 QualType To = getDerived().TransformType(TLB, PatternTL);
9076 To = getDerived().RebuildPackExpansionType(To,
9077 PatternTL.getSourceRange(),
9078 ExpansionTL.getEllipsisLoc(),
9083 PackExpansionTypeLoc ToExpansionTL
9084 = TLB.push<PackExpansionTypeLoc>(To);
9085 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
9086 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
9092 for (
unsigned I = 0; I != *NumExpansions; ++I) {
9093 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
9095 TLB.reserve(PatternTL.getFullDataSize());
9096 QualType To = getDerived().TransformType(TLB, PatternTL);
9100 if (To->containsUnexpandedParameterPack()) {
9101 To = getDerived().RebuildPackExpansionType(To,
9102 PatternTL.getSourceRange(),
9103 ExpansionTL.getEllipsisLoc(),
9108 PackExpansionTypeLoc ToExpansionTL
9109 = TLB.push<PackExpansionTypeLoc>(To);
9110 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
9113 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
9116 if (!RetainExpansion)
9121 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
9124 TLB.reserve(From->getTypeLoc().getFullDataSize());
9126 QualType To = getDerived().TransformType(TLB, PatternTL);
9130 To = getDerived().RebuildPackExpansionType(To,
9131 PatternTL.getSourceRange(),
9132 ExpansionTL.getEllipsisLoc(),
9137 PackExpansionTypeLoc ToExpansionTL
9138 = TLB.push<PackExpansionTypeLoc>(To);
9139 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
9140 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
9143 if (!getDerived().AlwaysRebuild() && !ArgChanged)
9146 return getDerived().RebuildTypeTrait(E->getTrait(),
9152 template<
typename Derived>
9154 TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
9155 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo());
9159 if (!getDerived().AlwaysRebuild() &&
9160 T == E->getQueriedTypeSourceInfo())
9166 SubExpr = getDerived().TransformExpr(E->getDimensionExpression());
9167 if (SubExpr.isInvalid())
9170 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getDimensionExpression())
9174 return getDerived().RebuildArrayTypeTrait(E->getTrait(),
9181 template<
typename Derived>
9183 TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) {
9187 SubExpr = getDerived().TransformExpr(E->getQueriedExpression());
9188 if (SubExpr.isInvalid())
9191 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression())
9195 return getDerived().RebuildExpressionTrait(
9196 E->getTrait(), E->getLocStart(), SubExpr.get(), E->getLocEnd());
9199 template <
typename Derived>
9203 ExprResult NewDRE = getDerived().TransformDependentScopeDeclRefExpr(
9204 DRE, AddrTaken, RecoveryTSI);
9211 if (!getDerived().AlwaysRebuild() && NewDRE.
get() == DRE)
9213 return getDerived().RebuildParenExpr(NewDRE.
get(), PE->
getLParen(),
9217 template <
typename Derived>
9220 return TransformDependentScopeDeclRefExpr(E,
false,
9224 template<
typename Derived>
9228 bool IsAddressOfOperand,
9242 = getDerived().TransformDeclarationNameInfo(E->
getNameInfo());
9247 if (!getDerived().AlwaysRebuild() &&
9254 return getDerived().RebuildDependentScopeDeclRefExpr(
9255 QualifierLoc, TemplateKWLoc, NameInfo,
nullptr,
9256 IsAddressOfOperand, RecoveryTSI);
9265 return getDerived().RebuildDependentScopeDeclRefExpr(
9266 QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand,
9270 template<
typename Derived>
9272 TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) {
9276 if ((E->getNumArgs() == 1 ||
9277 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) &&
9278 (!getDerived().DropCallArgument(E->getArg(0))) &&
9279 !E->isListInitialization())
9280 return getDerived().TransformExpr(E->getArg(0));
9282 TemporaryBase Rebase(*
this, E->getLocStart(), DeclarationName());
9284 QualType T = getDerived().TransformType(E->getType());
9288 CXXConstructorDecl *Constructor
9289 = cast_or_null<CXXConstructorDecl>(
9290 getDerived().TransformDecl(E->getLocStart(),
9291 E->getConstructor()));
9295 bool ArgumentChanged =
false;
9296 SmallVector<Expr*, 8> Args;
9297 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(),
true, Args,
9301 if (!getDerived().AlwaysRebuild() &&
9302 T == E->getType() &&
9303 Constructor == E->getConstructor() &&
9307 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor);
9311 return getDerived().RebuildCXXConstructExpr(T, E->getLocStart(),
9312 Constructor, E->isElidable(),
9314 E->hadMultipleCandidates(),
9315 E->isListInitialization(),
9316 E->isStdInitListInitialization(),
9317 E->requiresZeroInitialization(),
9318 E->getConstructionKind(),
9319 E->getParenOrBraceRange());
9326 template<
typename Derived>
9328 TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
9329 return getDerived().TransformExpr(E->getSubExpr());
9337 template<
typename Derived>
9339 TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) {
9340 return getDerived().TransformExpr(E->getSubExpr());
9343 template<
typename Derived>
9345 TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
9346 CXXTemporaryObjectExpr *E) {
9347 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
9351 CXXConstructorDecl *Constructor
9352 = cast_or_null<CXXConstructorDecl>(
9353 getDerived().TransformDecl(E->getLocStart(),
9354 E->getConstructor()));
9358 bool ArgumentChanged =
false;
9359 SmallVector<Expr*, 8> Args;
9360 Args.reserve(E->getNumArgs());
9361 if (TransformExprs(E->getArgs(), E->getNumArgs(),
true, Args,
9365 if (!getDerived().AlwaysRebuild() &&
9366 T == E->getTypeSourceInfo() &&
9367 Constructor == E->getConstructor() &&
9370 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor);
9371 return SemaRef.MaybeBindToTemporary(E);
9375 return getDerived().RebuildCXXTemporaryObjectExpr(T,
9376 T->getTypeLoc().getEndLoc(),
9381 template<
typename Derived>
9383 TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
9386 typedef std::pair<ExprResult, QualType> InitCaptureInfoTy;
9387 SmallVector<InitCaptureInfoTy, 8> InitCaptureExprsAndTypes;
9388 InitCaptureExprsAndTypes.resize(E->explicit_capture_end() -
9389 E->explicit_capture_begin());
9391 CEnd = E->capture_end();
9393 if (!E->isInitCapture(C))
9395 EnterExpressionEvaluationContext EEEC(getSema(),
9397 ExprResult NewExprInitResult = getDerived().TransformInitializer(
9398 C->getCapturedVar()->getInit(),
9401 if (NewExprInitResult.isInvalid())
9403 Expr *NewExprInit = NewExprInitResult.
get();
9405 VarDecl *OldVD = C->getCapturedVar();
9406 QualType NewInitCaptureType =
9407 getSema().performLambdaInitCaptureInitialization(C->getLocation(),
9408 OldVD->getType()->isReferenceType(), OldVD->getIdentifier(),
9410 NewExprInitResult = NewExprInit;
9411 InitCaptureExprsAndTypes[C - E->capture_begin()] =
9412 std::make_pair(NewExprInitResult, NewInitCaptureType);
9417 auto TPL = getDerived().TransformTemplateParameterList(
9418 E->getTemplateParameterList());
9424 TypeSourceInfo *NewCallOpTSI =
nullptr;
9426 TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo();
9427 FunctionProtoTypeLoc OldCallOpFPTL =
9428 OldCallOpTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>();
9430 TypeLocBuilder NewCallOpTLBuilder;
9431 SmallVector<QualType, 4> ExceptionStorage;
9432 TreeTransform *This =
this;
9433 QualType NewCallOpType = TransformFunctionProtoType(
9434 NewCallOpTLBuilder, OldCallOpFPTL,
nullptr, 0,
9435 [&](FunctionProtoType::ExceptionSpecInfo &ESI,
bool &Changed) {
9436 return This->TransformExceptionSpec(OldCallOpFPTL.getBeginLoc(), ESI,
9437 ExceptionStorage, Changed);
9439 if (NewCallOpType.isNull())
9441 NewCallOpTSI = NewCallOpTLBuilder.getTypeSourceInfo(getSema().
Context,
9445 LambdaScopeInfo *LSI = getSema().PushLambdaScope();
9446 Sema::FunctionScopeRAII FuncScopeCleanup(getSema());
9447 LSI->GLTemplateParameterList = TPL;
9450 CXXRecordDecl *Class
9451 = getSema().createLambdaClosureType(E->getIntroducerRange(),
9454 E->getCaptureDefault());
9455 getDerived().transformedLocalDecl(E->getLambdaClass(), Class);
9458 CXXMethodDecl *NewCallOperator = getSema().startLambdaDefinition(
9459 Class, E->getIntroducerRange(), NewCallOpTSI,
9460 E->getCallOperator()->getLocEnd(),
9461 NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams());
9462 LSI->CallOperator = NewCallOperator;
9464 getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
9465 getDerived().transformedLocalDecl(E->getCallOperator(), NewCallOperator);
9468 Sema::ContextRAII SavedContext(getSema(), NewCallOperator,
9472 getSema().buildLambdaScope(LSI, NewCallOperator,
9473 E->getIntroducerRange(),
9474 E->getCaptureDefault(),
9475 E->getCaptureDefaultLoc(),
9476 E->hasExplicitParameters(),
9477 E->hasExplicitResultType(),
9480 bool Invalid =
false;
9483 bool FinishedExplicitCaptures =
false;
9485 CEnd = E->capture_end();
9489 if (!FinishedExplicitCaptures && C->isImplicit()) {
9490 getSema().finishLambdaExplicitCaptures(LSI);
9491 FinishedExplicitCaptures =
true;
9495 if (C->capturesThis()) {
9496 getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit());
9501 if (C->capturesVLAType())
9505 if (E->isInitCapture(C)) {
9506 InitCaptureInfoTy InitExprTypePair =
9507 InitCaptureExprsAndTypes[C - E->capture_begin()];
9509 QualType InitQualType = InitExprTypePair.second;
9510 if (Init.isInvalid() || InitQualType.isNull()) {
9514 VarDecl *OldVD = C->getCapturedVar();
9515 VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl(
9516 OldVD->getLocation(), InitExprTypePair.second,
9517 OldVD->getIdentifier(), Init.get());
9521 getDerived().transformedLocalDecl(OldVD, NewVD);
9523 getSema().buildInitCaptureField(LSI, NewVD);
9527 assert(C->capturesVariable() &&
"unexpected kind of lambda capture");
9535 SourceLocation EllipsisLoc;
9536 if (C->isPackExpansion()) {
9538 bool ShouldExpand =
false;
9539 bool RetainExpansion =
false;
9540 Optional<unsigned> NumExpansions;
9541 if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(),
9544 ShouldExpand, RetainExpansion,
9554 VarDecl *Pack = C->getCapturedVar();
9555 for (
unsigned I = 0; I != *NumExpansions; ++I) {
9556 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
9557 VarDecl *CapturedVar
9558 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
9566 getSema().tryCaptureVariable(CapturedVar, C->getLocation(),
Kind);
9574 EllipsisLoc = C->getEllipsisLoc();
9578 VarDecl *CapturedVar
9579 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
9580 C->getCapturedVar()));
9581 if (!CapturedVar || CapturedVar->isInvalidDecl()) {
9587 getSema().tryCaptureVariable(CapturedVar, C->getLocation(),
Kind,
9590 if (!FinishedExplicitCaptures)
9591 getSema().finishLambdaExplicitCaptures(LSI);
9599 Invalid ?
StmtError() : getDerived().TransformStmt(E->getBody());
9602 FuncScopeCleanup.disable();
9604 if (Body.isInvalid()) {
9606 getSema().ActOnLambdaError(E->getLocStart(),
nullptr,
9614 auto LSICopy = *LSI;
9615 getSema().ActOnFinishFunctionBody(NewCallOperator, Body.get(),
9619 return getSema().BuildLambdaExpr(E->getLocStart(), Body.get()->getLocEnd(),
9623 template<
typename Derived>
9625 TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
9626 CXXUnresolvedConstructExpr *E) {
9627 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
9631 bool ArgumentChanged =
false;
9632 SmallVector<Expr*, 8> Args;
9633 Args.reserve(E->arg_size());
9634 if (getDerived().TransformExprs(E->arg_begin(), E->arg_size(),
true, Args,
9638 if (!getDerived().AlwaysRebuild() &&
9639 T == E->getTypeSourceInfo() &&
9644 return getDerived().RebuildCXXUnresolvedConstructExpr(T,
9650 template<
typename Derived>
9652 TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
9653 CXXDependentScopeMemberExpr *E) {
9658 QualType ObjectType;
9659 if (!E->isImplicitAccess()) {
9660 OldBase = E->getBase();
9661 Base = getDerived().TransformExpr(OldBase);
9662 if (Base.isInvalid())
9667 bool MayBePseudoDestructor =
false;
9668 Base = SemaRef.ActOnStartCXXMemberReference(
nullptr, Base.get(),
9669 E->getOperatorLoc(),
9670 E->isArrow()? tok::arrow : tok::period,
9672 MayBePseudoDestructor);
9673 if (Base.isInvalid())
9676 ObjectType = ObjectTy.
get();
9677 BaseType = ((Expr*) Base.get())->getType();
9680 BaseType = getDerived().TransformType(E->getBaseType());
9681 ObjectType = BaseType->getAs<PointerType>()->getPointeeType();
9686 NamedDecl *FirstQualifierInScope
9687 = getDerived().TransformFirstQualifierInScope(
9688 E->getFirstQualifierFoundInScope(),
9689 E->getQualifierLoc().getBeginLoc());
9691 NestedNameSpecifierLoc QualifierLoc;
9692 if (E->getQualifier()) {
9694 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(),
9696 FirstQualifierInScope);
9701 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
9707 DeclarationNameInfo NameInfo
9708 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo());
9709 if (!NameInfo.getName())
9712 if (!E->hasExplicitTemplateArgs()) {
9715 if (!getDerived().AlwaysRebuild() &&
9716 Base.get() == OldBase &&
9717 BaseType == E->getBaseType() &&
9718 QualifierLoc == E->getQualifierLoc() &&
9719 NameInfo.getName() == E->getMember() &&
9720 FirstQualifierInScope == E->getFirstQualifierFoundInScope())
9723 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
9726 E->getOperatorLoc(),
9729 FirstQualifierInScope,
9734 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
9735 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
9736 E->getNumTemplateArgs(),
9740 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
9743 E->getOperatorLoc(),
9746 FirstQualifierInScope,
9751 template<
typename Derived>
9753 TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) {
9757 if (!Old->isImplicitAccess()) {
9758 Base = getDerived().TransformExpr(Old->getBase());
9759 if (Base.isInvalid())
9761 Base = getSema().PerformMemberExprBaseConversion(Base.get(),
9763 if (Base.isInvalid())
9765 BaseType = Base.
get()->getType();
9767 BaseType = getDerived().TransformType(Old->getBaseType());
9770 NestedNameSpecifierLoc QualifierLoc;
9771 if (Old->getQualifierLoc()) {
9773 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
9778 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
9780 LookupResult R(SemaRef, Old->getMemberNameInfo(),
9785 E = Old->decls_end(); I != E; ++I) {
9786 NamedDecl *InstD =
static_cast<NamedDecl*
>(
9787 getDerived().TransformDecl(Old->getMemberLoc(),
9792 if (isa<UsingShadowDecl>(*I))
9801 if (isa<UsingDecl>(InstD)) {
9802 UsingDecl *UD = cast<UsingDecl>(InstD);
9803 for (
auto *I : UD->shadows())
9814 if (Old->getNamingClass()) {
9815 CXXRecordDecl *NamingClass
9816 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
9817 Old->getMemberLoc(),
9818 Old->getNamingClass()));
9822 R.setNamingClass(NamingClass);
9825 TemplateArgumentListInfo TransArgs;
9826 if (Old->hasExplicitTemplateArgs()) {
9827 TransArgs.setLAngleLoc(Old->getLAngleLoc());
9828 TransArgs.setRAngleLoc(Old->getRAngleLoc());
9829 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
9830 Old->getNumTemplateArgs(),
9839 NamedDecl *FirstQualifierInScope =
nullptr;
9841 return getDerived().RebuildUnresolvedMemberExpr(Base.get(),
9843 Old->getOperatorLoc(),
9847 FirstQualifierInScope,
9849 (Old->hasExplicitTemplateArgs()
9850 ? &TransArgs :
nullptr));
9853 template<
typename Derived>
9855 TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) {
9857 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand());
9858 if (SubExpr.isInvalid())
9861 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand())
9864 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get());
9867 template<
typename Derived>
9869 TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) {
9870 ExprResult Pattern = getDerived().TransformExpr(E->getPattern());
9871 if (Pattern.isInvalid())
9874 if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern())
9877 return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(),
9878 E->getNumExpansions());
9881 template<
typename Derived>
9883 TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) {
9886 if (!E->isValueDependent())
9893 bool ShouldExpand =
false;
9894 bool RetainExpansion =
false;
9895 Optional<unsigned> NumExpansions;
9896 if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(),
9898 ShouldExpand, RetainExpansion,
9902 if (RetainExpansion)
9905 NamedDecl *Pack = E->getPack();
9906 if (!ShouldExpand) {
9907 Pack = cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getPackLoc(),
9916 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), Pack,
9917 E->getPackLoc(), E->getRParenLoc(),
9921 template<
typename Derived>
9923 TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr(
9924 SubstNonTypeTemplateParmPackExpr *E) {
9929 template<
typename Derived>
9931 TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr(
9932 SubstNonTypeTemplateParmExpr *E) {
9937 template<
typename Derived>
9939 TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
9944 template<
typename Derived>
9946 TreeTransform<Derived>::TransformMaterializeTemporaryExpr(
9947 MaterializeTemporaryExpr *E) {
9948 return getDerived().TransformExpr(E->GetTemporaryExpr());
9951 template<
typename Derived>
9953 TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) {
9954 Expr *Pattern = E->getPattern();
9956 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
9957 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
9958 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
9963 bool RetainExpansion =
false;
9964 Optional<unsigned> NumExpansions;
9965 if (getDerived().TryExpandParameterPacks(E->getEllipsisLoc(),
9966 Pattern->getSourceRange(),
9968 Expand, RetainExpansion,
9975 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
9978 E->getLHS() ? getDerived().TransformExpr(E->getLHS()) :
ExprResult();
9979 if (LHS.isInvalid())
9983 E->getRHS() ? getDerived().TransformExpr(E->getRHS()) :
ExprResult();
9984 if (RHS.isInvalid())
9987 if (!getDerived().AlwaysRebuild() &&
9988 LHS.get() == E->getLHS() && RHS.get() == E->getRHS())
9991 return getDerived().RebuildCXXFoldExpr(
9992 E->getLocStart(), LHS.get(), E->getOperator(), E->getEllipsisLoc(),
9993 RHS.get(), E->getLocEnd());
9998 ExprResult Result = getDerived().TransformExpr(E->getInit());
9999 if (Result.isInvalid())
10001 bool LeftFold = E->isLeftFold();
10005 if (!LeftFold && RetainExpansion) {
10006 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
10008 ExprResult Out = getDerived().TransformExpr(Pattern);
10009 if (Out.isInvalid())
10012 Result = getDerived().RebuildCXXFoldExpr(
10013 E->getLocStart(), Out.get(), E->getOperator(), E->getEllipsisLoc(),
10014 Result.get(), E->getLocEnd());
10015 if (Result.isInvalid())
10019 for (
unsigned I = 0; I != *NumExpansions; ++I) {
10020 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(
10021 getSema(), LeftFold ? I : *NumExpansions - I - 1);
10022 ExprResult Out = getDerived().TransformExpr(Pattern);
10023 if (Out.isInvalid())
10026 if (Out.get()->containsUnexpandedParameterPack()) {
10028 Result = getDerived().RebuildCXXFoldExpr(
10030 LeftFold ? Result.get() : Out.get(),
10031 E->getOperator(), E->getEllipsisLoc(),
10032 LeftFold ? Out.get() : Result.get(),
10034 }
else if (Result.isUsable()) {
10036 Result = getDerived().RebuildBinaryOperator(
10037 E->getEllipsisLoc(), E->getOperator(),
10038 LeftFold ? Result.get() : Out.get(),
10039 LeftFold ? Out.get() : Result.get());
10043 if (Result.isInvalid())
10049 if (LeftFold && RetainExpansion) {
10050 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
10052 ExprResult Out = getDerived().TransformExpr(Pattern);
10053 if (Out.isInvalid())
10056 Result = getDerived().RebuildCXXFoldExpr(
10057 E->getLocStart(), Result.get(),
10058 E->getOperator(), E->getEllipsisLoc(),
10059 Out.get(), E->getLocEnd());
10060 if (Result.isInvalid())
10066 if (Result.isUnset())
10067 return getDerived().RebuildEmptyCXXFoldExpr(E->getEllipsisLoc(),
10073 template<
typename Derived>
10075 TreeTransform<Derived>::TransformCXXStdInitializerListExpr(
10076 CXXStdInitializerListExpr *E) {
10077 return getDerived().TransformExpr(E->getSubExpr());
10080 template<
typename Derived>
10082 TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) {
10083 return SemaRef.MaybeBindToTemporary(E);
10086 template<
typename Derived>
10088 TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
10092 template<
typename Derived>
10094 TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) {
10095 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
10096 if (SubExpr.isInvalid())
10099 if (!getDerived().AlwaysRebuild() &&
10100 SubExpr.get() == E->getSubExpr())
10103 return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get());
10106 template<
typename Derived>
10108 TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *E) {
10110 SmallVector<Expr *, 8> Elements;
10111 bool ArgChanged =
false;
10112 if (getDerived().TransformExprs(E->getElements(), E->getNumElements(),
10113 false, Elements, &ArgChanged))
10116 if (!getDerived().AlwaysRebuild() && !ArgChanged)
10117 return SemaRef.MaybeBindToTemporary(E);
10119 return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(),
10124 template<
typename Derived>
10126 TreeTransform<Derived>::TransformObjCDictionaryLiteral(
10127 ObjCDictionaryLiteral *E) {
10129 SmallVector<ObjCDictionaryElement, 8> Elements;
10130 bool ArgChanged =
false;
10131 for (
unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
10132 ObjCDictionaryElement OrigElement = E->getKeyValueElement(I);
10134 if (OrigElement.isPackExpansion()) {
10136 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
10137 getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded);
10138 getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded);
10139 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
10143 bool Expand =
true;
10144 bool RetainExpansion =
false;
10145 Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions;
10146 Optional<unsigned> NumExpansions = OrigNumExpansions;
10147 SourceRange PatternRange(OrigElement.Key->getLocStart(),
10148 OrigElement.Value->getLocEnd());
10149 if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc,
10152 Expand, RetainExpansion,
10160 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
10161 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
10162 if (Key.isInvalid())
10165 if (Key.get() != OrigElement.Key)
10169 if (Value.isInvalid())
10172 if (Value.get() != OrigElement.Value)
10175 ObjCDictionaryElement Expansion = {
10176 Key.
get(), Value.get(), OrigElement.EllipsisLoc, NumExpansions
10178 Elements.push_back(Expansion);
10188 for (
unsigned I = 0; I != *NumExpansions; ++I) {
10189 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
10190 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
10191 if (Key.isInvalid())
10194 ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
10195 if (Value.isInvalid())
10198 ObjCDictionaryElement Element = {
10199 Key.
get(), Value.get(), SourceLocation(), NumExpansions
10205 if (Key.get()->containsUnexpandedParameterPack() ||
10206 Value.get()->containsUnexpandedParameterPack())
10207 Element.EllipsisLoc = OrigElement.EllipsisLoc;
10209 Elements.push_back(Element);
10219 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
10220 if (Key.isInvalid())
10223 if (Key.get() != OrigElement.Key)
10228 = getDerived().TransformExpr(OrigElement.Value);
10229 if (Value.isInvalid())
10232 if (Value.get() != OrigElement.Value)
10235 ObjCDictionaryElement Element = {
10236 Key.
get(), Value.get(), SourceLocation(),
None
10238 Elements.push_back(Element);
10241 if (!getDerived().AlwaysRebuild() && !ArgChanged)
10242 return SemaRef.MaybeBindToTemporary(E);
10244 return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(),
10249 template<
typename Derived>
10251 TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) {
10252 TypeSourceInfo *EncodedTypeInfo
10253 = getDerived().TransformType(E->getEncodedTypeSourceInfo());
10254 if (!EncodedTypeInfo)
10257 if (!getDerived().AlwaysRebuild() &&
10258 EncodedTypeInfo == E->getEncodedTypeSourceInfo())
10261 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(),
10263 E->getRParenLoc());
10266 template<
typename Derived>
10268 TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
10273 return getDerived().TransformExpr(E->getSubExpr());
10276 template<
typename Derived>
10278 TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
10279 TypeSourceInfo *TSInfo
10280 = getDerived().TransformType(E->getTypeInfoAsWritten());
10284 ExprResult Result = getDerived().TransformExpr(E->getSubExpr());
10285 if (Result.isInvalid())
10288 if (!getDerived().AlwaysRebuild() &&
10289 TSInfo == E->getTypeInfoAsWritten() &&
10290 Result.get() == E->getSubExpr())
10293 return SemaRef.BuildObjCBridgedCast(E->getLParenLoc(), E->getBridgeKind(),
10294 E->getBridgeKeywordLoc(), TSInfo,
10298 template<
typename Derived>
10300 TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) {
10302 bool ArgChanged =
false;
10303 SmallVector<Expr*, 8> Args;
10304 Args.reserve(E->getNumArgs());
10305 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(),
false, Args,
10311 TypeSourceInfo *ReceiverTypeInfo
10312 = getDerived().TransformType(E->getClassReceiverTypeInfo());
10313 if (!ReceiverTypeInfo)
10317 if (!getDerived().AlwaysRebuild() &&
10318 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged)
10319 return SemaRef.MaybeBindToTemporary(E);
10322 SmallVector<SourceLocation, 16> SelLocs;
10323 E->getSelectorLocs(SelLocs);
10324 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo,
10327 E->getMethodDecl(),
10335 SmallVector<SourceLocation, 16> SelLocs;
10336 E->getSelectorLocs(SelLocs);
10337 return getDerived().RebuildObjCMessageExpr(E->getSuperLoc(),
10340 E->getMethodDecl(),
10348 "Only class and instance messages may be instantiated");
10350 = getDerived().TransformExpr(E->getInstanceReceiver());
10351 if (Receiver.isInvalid())
10355 if (!getDerived().AlwaysRebuild() &&
10356 Receiver.get() == E->getInstanceReceiver() && !ArgChanged)
10357 return SemaRef.MaybeBindToTemporary(E);
10360 SmallVector<SourceLocation, 16> SelLocs;
10361 E->getSelectorLocs(SelLocs);
10362 return getDerived().RebuildObjCMessageExpr(Receiver.get(),
10365 E->getMethodDecl(),
10371 template<
typename Derived>
10373 TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) {
10377 template<
typename Derived>
10379 TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) {
10383 template<
typename Derived>
10385 TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) {
10387 ExprResult Base = getDerived().TransformExpr(E->getBase());
10388 if (Base.isInvalid())
10394 if (!getDerived().AlwaysRebuild() &&
10395 Base.get() == E->getBase())
10398 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(),
10400 E->isArrow(), E->isFreeIvar());
10403 template<
typename Derived>
10405 TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
10408 if (!E->isObjectReceiver())
10412 ExprResult Base = getDerived().TransformExpr(E->getBase());
10413 if (Base.isInvalid())
10419 if (!getDerived().AlwaysRebuild() &&
10420 Base.get() == E->getBase())
10423 if (E->isExplicitProperty())
10424 return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
10425 E->getExplicitProperty(),
10428 return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
10429 SemaRef.Context.PseudoObjectTy,
10430 E->getImplicitPropertyGetter(),
10431 E->getImplicitPropertySetter(),
10435 template<
typename Derived>
10437 TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
10439 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
10440 if (Base.isInvalid())
10444 ExprResult Key = getDerived().TransformExpr(E->getKeyExpr());
10445 if (Key.isInvalid())
10449 if (!getDerived().AlwaysRebuild() &&
10450 Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr())
10453 return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(),
10454 Base.get(), Key.get(),
10455 E->getAtIndexMethodDecl(),
10456 E->setAtIndexMethodDecl());
10459 template<
typename Derived>
10461 TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) {
10463 ExprResult Base = getDerived().TransformExpr(E->getBase());
10464 if (Base.isInvalid())
10468 if (!getDerived().AlwaysRebuild() &&
10469 Base.get() == E->getBase())
10472 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(),
10477 template<
typename Derived>
10479 TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) {
10480 bool ArgumentChanged =
false;
10481 SmallVector<Expr*, 8> SubExprs;
10482 SubExprs.reserve(E->getNumSubExprs());
10483 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(),
false,
10484 SubExprs, &ArgumentChanged))
10487 if (!getDerived().AlwaysRebuild() &&
10491 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(),
10493 E->getRParenLoc());
10496 template<
typename Derived>
10498 TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *E) {
10499 ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr());
10500 if (SrcExpr.isInvalid())
10503 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
10507 if (!getDerived().AlwaysRebuild() &&
10508 Type == E->getTypeSourceInfo() &&
10509 SrcExpr.get() == E->getSrcExpr())
10512 return getDerived().RebuildConvertVectorExpr(E->getBuiltinLoc(),
10513 SrcExpr.get(), Type,
10514 E->getRParenLoc());
10517 template<
typename Derived>
10519 TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) {
10520 BlockDecl *oldBlock = E->getBlockDecl();
10522 SemaRef.ActOnBlockStart(E->getCaretLocation(),
nullptr);
10523 BlockScopeInfo *blockScope = SemaRef.getCurBlock();
10525 blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic());
10526 blockScope->TheDecl->setBlockMissingReturnType(
10527 oldBlock->blockMissingReturnType());
10529 SmallVector<ParmVarDecl*, 4> params;
10530 SmallVector<QualType, 4> paramTypes;
10533 if (getDerived().TransformFunctionTypeParams(E->getCaretLocation(),
10534 oldBlock->param_begin(),
10535 oldBlock->param_size(),
10536 nullptr, paramTypes, ¶ms)) {
10537 getSema().ActOnBlockError(E->getCaretLocation(),
nullptr);
10541 const FunctionProtoType *exprFunctionType = E->getFunctionType();
10542 QualType exprResultType =
10543 getDerived().TransformType(exprFunctionType->getReturnType());
10545 QualType functionType =
10546 getDerived().RebuildFunctionProtoType(exprResultType, paramTypes,
10547 exprFunctionType->getExtProtoInfo());
10548 blockScope->FunctionType = functionType;
10551 if (!params.empty())
10552 blockScope->TheDecl->setParams(params);
10554 if (!oldBlock->blockMissingReturnType()) {
10555 blockScope->HasImplicitReturnType =
false;
10556 blockScope->ReturnType = exprResultType;
10560 StmtResult body = getDerived().TransformStmt(E->getBody());
10561 if (body.isInvalid()) {
10562 getSema().ActOnBlockError(E->getCaretLocation(),
nullptr);
10569 if (!SemaRef.getDiagnostics().hasErrorOccurred()) {
10570 for (
const auto &I : oldBlock->captures()) {
10571 VarDecl *oldCapture = I.getVariable();
10574 if (isa<ParmVarDecl>(oldCapture) &&
10575 cast<ParmVarDecl>(oldCapture)->isParameterPack())
10578 VarDecl *newCapture =
10579 cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(),
10581 assert(blockScope->CaptureMap.count(newCapture));
10583 assert(oldBlock->capturesCXXThis() == blockScope->isCXXThisCaptured());
10587 return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(),
10591 template<
typename Derived>
10593 TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) {
10594 llvm_unreachable(
"Cannot transform asType expressions yet");
10597 template<
typename Derived>
10599 TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) {
10600 QualType RetTy = getDerived().TransformType(E->getType());
10601 bool ArgumentChanged =
false;
10602 SmallVector<Expr*, 8> SubExprs;
10603 SubExprs.reserve(E->getNumSubExprs());
10604 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(),
false,
10605 SubExprs, &ArgumentChanged))
10608 if (!getDerived().AlwaysRebuild() &&
10612 return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs,
10613 RetTy, E->getOp(), E->getRParenLoc());
10620 template<
typename Derived>
10623 return SemaRef.BuildPointerType(PointeeType, Star,
10624 getDerived().getBaseEntity());
10627 template<
typename Derived>
10630 return SemaRef.BuildBlockPointerType(PointeeType, Star,
10631 getDerived().getBaseEntity());
10634 template<
typename Derived>
10637 bool WrittenAsLValue,
10639 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue,
10640 Sigil, getDerived().getBaseEntity());
10643 template<
typename Derived>
10648 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Sigil,
10649 getDerived().getBaseEntity());
10652 template<
typename Derived>
10663 return SemaRef.BuildObjCObjectType(BaseType, Loc, TypeArgsLAngleLoc,
10664 TypeArgs, TypeArgsRAngleLoc,
10665 ProtocolLAngleLoc, Protocols, ProtocolLocs,
10670 template<
typename Derived>
10674 return SemaRef.Context.getObjCObjectPointerType(PointeeType);
10677 template<
typename Derived>
10681 const llvm::APInt *Size,
10683 unsigned IndexTypeQuals,
10685 if (SizeExpr || !Size)
10686 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr,
10687 IndexTypeQuals, BracketsRange,
10688 getDerived().getBaseEntity());
10691 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy,
10692 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy,
10693 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty
10695 const unsigned NumTypes = llvm::array_lengthof(Types);
10697 for (
unsigned I = 0; I != NumTypes; ++I)
10698 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) {
10699 SizeType = Types[I];
10708 return SemaRef.BuildArrayType(ElementType, SizeMod, ArraySize,
10709 IndexTypeQuals, BracketsRange,
10710 getDerived().getBaseEntity());
10713 template<
typename Derived>
10717 const llvm::APInt &Size,
10718 unsigned IndexTypeQuals,
10720 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size,
nullptr,
10721 IndexTypeQuals, BracketsRange);
10724 template<
typename Derived>
10728 unsigned IndexTypeQuals,
10730 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
nullptr,
10731 IndexTypeQuals, BracketsRange);
10734 template<
typename Derived>
10739 unsigned IndexTypeQuals,
10741 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
10743 IndexTypeQuals, BracketsRange);
10746 template<
typename Derived>
10751 unsigned IndexTypeQuals,
10753 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
10755 IndexTypeQuals, BracketsRange);
10758 template<
typename Derived>
10760 unsigned NumElements,
10763 return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind);
10766 template<
typename Derived>
10768 unsigned NumElements,
10770 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
10771 NumElements,
true);
10775 return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc);
10778 template<
typename Derived>
10783 return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc);
10786 template<
typename Derived>
10791 return SemaRef.BuildFunctionType(T, ParamTypes,
10792 getDerived().getBaseLocation(),
10793 getDerived().getBaseEntity(),
10797 template<
typename Derived>
10799 return SemaRef.Context.getFunctionNoProtoType(T);
10802 template<
typename Derived>
10804 assert(D &&
"no decl found");
10809 if (isa<UsingDecl>(D)) {
10812 "UnresolvedUsingTypenameDecl transformed to non-typename using");
10816 Ty = cast<TypeDecl>((*Using->
shadow_begin())->getTargetDecl());
10819 assert(isa<UnresolvedUsingTypenameDecl>(D) &&
10820 "UnresolvedUsingTypenameDecl transformed to non-using decl");
10821 Ty = cast<UnresolvedUsingTypenameDecl>(D);
10824 return SemaRef.Context.getTypeDeclType(Ty);
10827 template<
typename Derived>
10830 return SemaRef.BuildTypeofExprType(E, Loc);
10833 template<
typename Derived>
10835 return SemaRef.Context.getTypeOfType(Underlying);
10838 template<
typename Derived>
10841 return SemaRef.BuildDecltypeType(E, Loc);
10844 template<
typename Derived>
10848 return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc);
10851 template<
typename Derived>
10856 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
10859 template<
typename Derived>
10862 return SemaRef.BuildAtomicType(ValueType, KWLoc);
10865 template<
typename Derived>
10870 return SemaRef.Context.getQualifiedTemplateName(SS.
getScopeRep(), TemplateKW,
10874 template<
typename Derived>
10885 getSema().ActOnDependentTemplateName(
nullptr,
10886 SS, TemplateKWLoc, TemplateName,
10890 return Template.
get();
10893 template<
typename Derived>
10901 SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc };
10905 getSema().ActOnDependentTemplateName(
nullptr,
10906 SS, TemplateKWLoc, Name,
10910 return Template.
get();
10913 template<
typename Derived>
10921 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus);
10926 return SemaRef.checkPseudoObjectAssignment(
nullptr, OpLoc, Opc,
10928 ExprResult Result = SemaRef.CheckPlaceholderExpr(First);
10931 First = Result.
get();
10935 ExprResult Result = SemaRef.CheckPlaceholderExpr(Second);
10938 Second = Result.
get();
10942 if (Op == OO_Subscript) {
10945 return getSema().CreateBuiltinArraySubscriptExpr(First,
10946 Callee->getLocStart(),
10948 }
else if (Op == OO_Arrow) {
10950 return SemaRef.BuildOverloadedArrowExpr(
nullptr, First, OpLoc);
10951 }
else if (Second ==
nullptr || isPostIncDec) {
10958 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First);
10967 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second);
10980 assert(ULE->requiresADL());
10981 Functions.
append(ULE->decls_begin(), ULE->decls_end());
10986 NamedDecl *ND = cast<DeclRefExpr>(Callee)->getDecl();
10987 if (!isa<CXXMethodDecl>(ND))
10992 Expr *Args[2] = { First, Second };
10993 unsigned NumArgs = 1 + (Second !=
nullptr);
10996 if (NumArgs == 1 || isPostIncDec) {
10999 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First);
11002 if (Op == OO_Subscript) {
11006 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) {
11013 LBrace = Callee->getLocStart();
11017 return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace,
11024 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]);
11031 template<
typename Derived>
11046 ->template getAs<RecordType>())){
11048 return SemaRef.BuildPseudoDestructorExpr(
11049 Base, OperatorLoc, isArrow ? tok::arrow : tok::period, SS, ScopeType,
11050 CCLoc, TildeLoc, Destroyed);
11054 DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName(
11055 SemaRef.Context.getCanonicalType(DestroyedType->
getType())));
11064 diag::err_expected_class_or_namespace)
11065 << ScopeType->
getType() << getSema().getLangOpts().CPlusPlus;
11073 return getSema().BuildMemberReferenceExpr(Base, BaseType,
11074 OperatorLoc, isArrow,
11081 template<
typename Derived>
11089 for (
unsigned I = 0; I < NumParams; ++I) {
11090 if (I != ContextParamPos) {
11096 Params.push_back(std::make_pair(StringRef(), QualType()));
11099 getSema().ActOnCapturedRegionStart(Loc,
nullptr,
11103 Sema::CompoundScopeRAII CompoundScope(getSema());
11107 if (Body.isInvalid()) {
11108 getSema().ActOnCapturedRegionError();
11112 return getSema().ActOnCapturedRegionEnd(Body.get());
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
CapturedDecl * getCapturedDecl()
Retrieve the outlined function declaration.
Name lookup found a set of overloaded functions that met the criteria.
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
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.
Stores the type being destroyed by a pseudo-destructor expression.
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()
ObjCInterfaceDecl * getClassInterface()
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
IdentifierInfo * getIdentifier() const
void setRParenLoc(SourceLocation Loc)
DeclClass * getAsSingle() const
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.
TemplateArgumentLoc reference
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
bool isRecordType() const
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++1y decltype(auto) type.
Represents an attribute applied to a statement.
bool isEnumeralType() const
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier.
SourceLocation getLocalRangeBegin() const
SourceLocation getLAngleLoc() const
Retrieve the location of the left angle bracket starting the explicit template argument list followin...
void setTemplateKeywordLoc(SourceLocation Loc)
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)
bool isDecltypeAuto() const
SourceLocation getColonLoc() const
Returns the location of ':'.
const TemplateArgumentLoc * operator->() const
std::input_iterator_tag iterator_category
A container of type source information.
Wrapper for void* pointer.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
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.
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.
ExtProtoInfo - Extra information about a function prototype.
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.
This represents implicit clause 'flush' for the '#pragma omp flush' directive. This clause does not e...
Defines the Objective-C statement AST node classes.
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)
A C++ static_cast expression (C++ [expr.static.cast]).
OpenMPDirectiveKind getDirectiveKind() const
Base wrapper for a particular "section" of type source info.
unsigned getNumParams() const
DeclarationName getName() const
getName - Returns the embedded declaration name.
void setLocalRangeEnd(SourceLocation L)
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
OpaquePtr< QualType > ParsedType
An element in an Objective-C dictionary literal.
This represents '#pragma omp parallel' directive.
TypeLoc getPointeeLoc() const
A C++ nested-name-specifier augmented with source location information.
Represents a dependent template name that cannot be resolved prior to template instantiation.
The results of name lookup within a DeclContext. This is either a single result (with no stable stora...
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
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.
SourceLocation getLBracLoc() const
TypeSourceInfo * getTypeSourceInfo() const
SourceRange getSourceRange() const LLVM_READONLY
Fetches the full source range of the argument.
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
std::pair< NullabilityKind, bool > DiagNullabilityKind
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
TypeSourceInfo * getNamedTypeInfo() const
StorageClass getStorageClass() const
Returns the storage class as written in the source. For the computed linkage of symbol, see getLinkage.
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.
SourceLocation getBeginLoc() const
Get the begin source location.
Describes an C or C++ initializer list.
bool isNull() const
Determine whether this template name is NULL.
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)
unsigned location_size() const
Retrieve the size of the data associated with source-location information.
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
QualType getReturnType() const
shadow_iterator shadow_begin() const
SourceLocation getLParen() const
Get the location of the left parentheses '('.
bool isObjCLifetimeType() const
NestedNameSpecifierLoc getTemplateQualifierLoc() const
char * location_data() const
Retrieve the data associated with the source-location information.
bool isValueDependent() const
TemplateArgumentLocContainerIterator & operator++()
Expr * IgnoreParenCasts() LLVM_READONLY
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
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.
Represents an ObjC class declaration.
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access. Does not test the acceptance criteria...
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)
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
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
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...
Qualifiers::ObjCLifetime getObjCLifetime() const
getObjCLifetime - 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.
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.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
SourceLocation getElaboratedKeywordLoc() const
pointer(TemplateArgumentLoc Arg)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
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.
TemplateArgumentLocInventIterator(TreeTransform< Derived > &Self, InputIterator Iter)
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Inits[]
Gets the list of initial values for linear variables.
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()
Represents an expression that computes the length of a parameter pack.
unsigned getContextParamPosition() const
Represents a C++ template name within the type system.
A namespace alias, stored as a NamespaceAliasDecl*.
SourceRange getAngleBrackets() const LLVM_READONLY
OMPLinearClause(SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, unsigned NumVars)
Build 'linear' clause with given number of variables NumVars.
SourceLocation getTemplateNameLoc() const
QualType getType() const
Get the type for which this source info wrapper provides information.
Expr * getSubExpr() const
bool isDependentType() const
pointer operator->() const
static QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T)
bool isInstanceMethod() const
bool hasTrailingReturn() const
void setEllipsisLoc(SourceLocation Loc)
QualType getCXXNameType() const
Expr * getSubExprAsWritten()
Retrieve the cast subexpression as it was written in the source code, looking through any implicit ca...
struct CXXOpName CXXOperatorName
DeclarationName getDeclName() const
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 TypeClass * getTypePtr() const
static SEHFinallyStmt * Create(const ASTContext &C, SourceLocation FinallyLoc, Stmt *Block)
bool hasObjCLifetime() const
TemplateArgumentLocInventIterator operator++(int)
SourceLocation getLocStart() const
Returns starting location of directive kind.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
unsigned getNumTemplateArgs() const
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
Simple iterator that traverses the template arguments in a container that provides a getArgLoc() memb...
const IdentifierInfo * getIdentifier() const
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)
Retrieve the binary opcode that corresponds to the given overloaded operator.
friend bool operator==(const TemplateArgumentLocContainerIterator &X, const TemplateArgumentLocContainerIterator &Y)
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
This captures a statement into a function. For example, the following pragma annotated compound state...
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. The SourceManager can decode this to get at the full include stack...
OpenMPDependClauseKind
OpenMP attributes for 'depend' clause.
const Type * getTypePtr() const
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
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...
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
OpenMPDirectiveKind
OpenMP directives.
SourceLocation getLocalBeginLoc() const
Retrieve the location of the beginning of this component of the nested-name-specifier.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Name lookup found an unresolvable value declaration and cannot yet complete. This only happens in C++...
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.
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)
Represents one property declaration in an Objective-C interface.
void setElaboratedKeywordLoc(SourceLocation Loc)
Stmt * getCapturedStmt()
Retrieve the statement being captured.
TypeLocClass getTypeLocClass() const
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
SourceLocation getBegin() const
bool isTypeDependent() const
TypeLoc getReturnLoc() const
lookup_result lookup(DeclarationName Name) const
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)
getTagTypeKindForKeyword - Converts an elaborated type keyword into
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
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.
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.
ast_type_traits::DynTypedNode Node
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.
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
bool hasTypename() const
Return true if the using declaration has 'typename'.
not evaluated yet, for special member function
The base class of all kinds of template declarations (e.g., class, function, etc.).
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
TemplateArgumentLoc const * getTemplateArgs() const
SourceLocation getEllipsisLoc() const
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
const internal::VariadicDynCastAllOfMatcher< Stmt, CUDAKernelCallExpr > CUDAKernelCallExpr
Matches CUDA kernel call expression.
Represents a C++11 pack expansion that produces a sequence of expressions.
param_type_iterator param_type_end() const
A set of unresolved declarations.
pointer operator->() const
bool isNull() const
Determine whether this template argument has no value.
unsigned getFunctionScopeDepth() const
void setSigilLoc(SourceLocation Loc)
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.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Name lookup found a single declaration that met the criteria. getFoundDecl() will return this declara...
Not an overloaded operator.
QualType getCanonicalType() const
This file defines OpenMP AST classes for executable directives and clauses.
unsigned getNumArgs() const
UnqualTypeLoc getUnqualifiedLoc() const
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.
ActionResult< Stmt * > StmtResult
The template argument is a type.
SourceLocation getLocStart() const LLVM_READONLY
OpenMPDefaultClauseKind
OpenMP attributes for 'default' clause.
const TypeClass * getTypePtr() const
void setNamedTypeInfo(TypeSourceInfo *TInfo)
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
bool hasAssociatedStmt() const
Returns true if directive has associated statement.
ArrayRef< const Attr * > getAttrs() const
SourceLocation getAttrLoc() const
Expr * NoexceptExpr
Noexcept expression, if this is EST_ComputedNoexcept.
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...
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
bool isObjCObjectPointerType() const
Designator * designators_iterator
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
SourceLocation getTemplateNameLoc() const
void setParam(unsigned i, ParmVarDecl *VD)
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
ElaboratedTypeKeyword getKeyword() const
const Capture * capture_iterator
An iterator that walks over the captures of the lambda, both implicit and explicit.
CapturedRegionKind getCapturedRegionKind() const
Retrieve the captured region kind.
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.
pack_iterator pack_end() const
Iterator referencing one past the last argument of a template argument pack.
LookupResultKind getResultKind() const
void setRAngleLoc(SourceLocation Loc)
QualType getPointeeTypeAsWritten() const
SourceLocation getRBracLoc() const
Abstract class common to all of the C++ "named"/"keyword" casts.
static OpaquePtr make(QualTypeP)
TranslationUnitDecl - The top declaration context.
A reference to a declared variable, function, enum, etc. [C99 6.5.1p2].
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Represents a type template specialization; the template must be a class template, a type alias templa...
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
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
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
isNull - 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 ...