diff options
Diffstat (limited to 'lib/Sema/TreeTransform.h')
| -rw-r--r-- | lib/Sema/TreeTransform.h | 1737 |
1 files changed, 1142 insertions, 595 deletions
diff --git a/lib/Sema/TreeTransform.h b/lib/Sema/TreeTransform.h index 4351c2530719..312811d2c008 100644 --- a/lib/Sema/TreeTransform.h +++ b/lib/Sema/TreeTransform.h @@ -25,7 +25,6 @@ #include "clang/AST/StmtCXX.h" #include "clang/AST/StmtObjC.h" #include "clang/AST/StmtOpenMP.h" -#include "clang/Lex/Preprocessor.h" #include "clang/Sema/Designator.h" #include "clang/Sema/Lookup.h" #include "clang/Sema/Ownership.h" @@ -345,7 +344,7 @@ public: /// TransformExpr or TransformExprs. /// /// \returns the transformed initializer. - ExprResult TransformInitializer(Expr *Init, bool CXXDirectInit); + ExprResult TransformInitializer(Expr *Init, bool NotCopyInit); /// \brief Transform the given list of expressions. /// @@ -372,7 +371,7 @@ public: /// \returns true if an error occurred, false otherwise. bool TransformExprs(Expr **Inputs, unsigned NumInputs, bool IsCall, SmallVectorImpl<Expr *> &Outputs, - bool *ArgChanged = 0); + bool *ArgChanged = nullptr); /// \brief Transform the given declaration, which is referenced from a type /// or expression. @@ -434,10 +433,10 @@ public: /// By default, transforms all of the types and declarations within the /// nested-name-specifier. Subclasses may override this function to provide /// alternate behavior. - NestedNameSpecifierLoc TransformNestedNameSpecifierLoc( - NestedNameSpecifierLoc NNS, - QualType ObjectType = QualType(), - NamedDecl *FirstQualifierInScope = 0); + NestedNameSpecifierLoc + TransformNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, + QualType ObjectType = QualType(), + NamedDecl *FirstQualifierInScope = nullptr); /// \brief Transform the given declaration name. /// @@ -468,11 +467,11 @@ public: /// By default, transforms the template name by transforming the declarations /// and nested-name-specifiers that occur within the template name. /// Subclasses may override this function to provide alternate behavior. - TemplateName TransformTemplateName(CXXScopeSpec &SS, - TemplateName Name, - SourceLocation NameLoc, - QualType ObjectType = QualType(), - NamedDecl *FirstQualifierInScope = 0); + TemplateName + TransformTemplateName(CXXScopeSpec &SS, TemplateName Name, + SourceLocation NameLoc, + QualType ObjectType = QualType(), + NamedDecl *FirstQualifierInScope = nullptr); /// \brief Transform the given template argument. /// @@ -605,8 +604,16 @@ public: } ExprResult TransformAddressOfOperand(Expr *E); + ExprResult TransformDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E, - bool IsAddressOfOperand); + bool IsAddressOfOperand, + TypeSourceInfo **RecoveryTSI); + + ExprResult TransformParenDependentScopeDeclRefExpr( + ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool IsAddressOfOperand, + TypeSourceInfo **RecoveryTSI); + + StmtResult TransformOMPExecutableDirective(OMPExecutableDirective *S); // FIXME: We use LLVM_ATTRIBUTE_NOINLINE because inlining causes a ridiculous // amount of stack usage with clang. @@ -743,7 +750,7 @@ public: /// By default, performs semantic analysis when building the function type. /// Subclasses may override this routine to provide different behavior. QualType RebuildFunctionProtoType(QualType T, - llvm::MutableArrayRef<QualType> ParamTypes, + MutableArrayRef<QualType> ParamTypes, const FunctionProtoType::ExtProtoInfo &EPI); /// \brief Build a new unprototyped function type. @@ -848,7 +855,8 @@ public: CXXScopeSpec SS; SS.Adopt(QualifierLoc); TemplateName InstName - = getDerived().RebuildTemplateName(SS, *Name, NameLoc, QualType(), 0); + = getDerived().RebuildTemplateName(SS, *Name, NameLoc, QualType(), + nullptr); if (InstName.isNull()) return QualType(); @@ -866,7 +874,7 @@ public: getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args); if (T.isNull()) return QualType(); - if (Keyword == ETK_None && QualifierLoc.getNestedNameSpecifier() == 0) + if (Keyword == ETK_None && QualifierLoc.getNestedNameSpecifier() == nullptr) return T; return SemaRef.Context.getElaboratedType(Keyword, @@ -912,7 +920,7 @@ public: if (SemaRef.RequireCompleteDeclContext(SS, DC)) return QualType(); - TagDecl *Tag = 0; + TagDecl *Tag = nullptr; SemaRef.LookupQualifiedName(Result, DC); switch (Result.getResultKind()) { case LookupResult::NotFound: @@ -951,9 +959,8 @@ public: break; } default: - // FIXME: Would be nice to highlight just the source range. SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope) - << Kind << Id << DC; + << Kind << Id << DC << QualifierLoc.getSourceRange(); break; } return QualType(); @@ -1080,7 +1087,7 @@ public: SourceLocation ColonLoc, Stmt *SubStmt) { return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt, - /*CurScope=*/0); + /*CurScope=*/nullptr); } /// \brief Build a new label statement. @@ -1187,14 +1194,14 @@ public: /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, Expr *Result) { - return getSema().ActOnReturnStmt(ReturnLoc, Result); + return getSema().BuildReturnStmt(ReturnLoc, Result); } /// \brief Build a new declaration statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. - StmtResult RebuildDeclStmt(llvm::MutableArrayRef<Decl *> Decls, + StmtResult RebuildDeclStmt(MutableArrayRef<Decl *> Decls, SourceLocation StartLoc, SourceLocation EndLoc) { Sema::DeclGroupPtrTy DG = getSema().BuildDeclaratorGroup(Decls); return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc); @@ -1286,21 +1293,78 @@ public: return getSema().BuildObjCAtThrowStmt(AtLoc, Operand); } - /// \brief Build a new OpenMP parallel directive. + /// \brief Build a new OpenMP executable directive. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. - StmtResult RebuildOMPParallelDirective(ArrayRef<OMPClause *> Clauses, - Stmt *AStmt, - SourceLocation StartLoc, - SourceLocation EndLoc) { - return getSema().ActOnOpenMPParallelDirective(Clauses, AStmt, - StartLoc, EndLoc); + StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind, + DeclarationNameInfo DirName, + ArrayRef<OMPClause *> Clauses, + Stmt *AStmt, SourceLocation StartLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPExecutableDirective(Kind, DirName, Clauses, + AStmt, StartLoc, EndLoc); + } + + /// \brief Build a new OpenMP 'if' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPIfClause(Expr *Condition, + SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPIfClause(Condition, StartLoc, + LParenLoc, EndLoc); + } + + /// \brief Build a new OpenMP 'final' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPFinalClause(Expr *Condition, SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPFinalClause(Condition, StartLoc, LParenLoc, + EndLoc); + } + + /// \brief Build a new OpenMP 'num_threads' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPNumThreadsClause(Expr *NumThreads, + SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPNumThreadsClause(NumThreads, StartLoc, + LParenLoc, EndLoc); + } + + /// \brief Build a new OpenMP 'safelen' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPSafelenClause(Expr *Len, SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc); + } + + /// \brief Build a new OpenMP 'collapse' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPCollapseClause(Expr *Num, SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc, + EndLoc); } /// \brief Build a new OpenMP 'default' clause. /// - /// By default, performs semantic analysis to build the new statement. + /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. OMPClause *RebuildOMPDefaultClause(OpenMPDefaultClauseKind Kind, SourceLocation KindKwLoc, @@ -1311,9 +1375,37 @@ public: StartLoc, LParenLoc, EndLoc); } + /// \brief Build a new OpenMP 'proc_bind' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPProcBindClause(OpenMPProcBindClauseKind Kind, + SourceLocation KindKwLoc, + SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPProcBindClause(Kind, KindKwLoc, + StartLoc, LParenLoc, EndLoc); + } + + /// \brief Build a new OpenMP 'schedule' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPScheduleClause(OpenMPScheduleClauseKind Kind, + Expr *ChunkSize, + SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation KindLoc, + SourceLocation CommaLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPScheduleClause( + Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc); + } + /// \brief Build a new OpenMP 'private' clause. /// - /// By default, performs semantic analysis to build the new statement. + /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. OMPClause *RebuildOMPPrivateClause(ArrayRef<Expr *> VarList, SourceLocation StartLoc, @@ -1325,7 +1417,7 @@ public: /// \brief Build a new OpenMP 'firstprivate' clause. /// - /// By default, performs semantic analysis to build the new statement. + /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. OMPClause *RebuildOMPFirstprivateClause(ArrayRef<Expr *> VarList, SourceLocation StartLoc, @@ -1335,6 +1427,22 @@ public: EndLoc); } + /// \brief Build a new OpenMP 'lastprivate' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPLastprivateClause(ArrayRef<Expr *> VarList, + SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPLastprivateClause(VarList, StartLoc, LParenLoc, + EndLoc); + } + + /// \brief Build a new OpenMP 'shared' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. OMPClause *RebuildOMPSharedClause(ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc, @@ -1343,6 +1451,84 @@ public: EndLoc); } + /// \brief Build a new OpenMP 'reduction' clause. + /// + /// By default, performs semantic analysis to build the new statement. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPReductionClause(ArrayRef<Expr *> VarList, + SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation ColonLoc, + SourceLocation EndLoc, + CXXScopeSpec &ReductionIdScopeSpec, + const DeclarationNameInfo &ReductionId) { + return getSema().ActOnOpenMPReductionClause( + VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec, + ReductionId); + } + + /// \brief Build a new OpenMP 'linear' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step, + SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation ColonLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc, + ColonLoc, EndLoc); + } + + /// \brief Build a new OpenMP 'aligned' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPAlignedClause(ArrayRef<Expr *> VarList, Expr *Alignment, + SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation ColonLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPAlignedClause(VarList, Alignment, StartLoc, + LParenLoc, ColonLoc, EndLoc); + } + + /// \brief Build a new OpenMP 'copyin' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPCopyinClause(ArrayRef<Expr *> VarList, + SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc, + EndLoc); + } + + /// \brief Build a new OpenMP 'copyprivate' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPCopyprivateClause(ArrayRef<Expr *> VarList, + SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc, + EndLoc); + } + + /// \brief Build a new OpenMP 'flush' pseudo clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPFlushClause(ArrayRef<Expr *> VarList, + SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc, + EndLoc); + } + /// \brief Rebuild the operand to an Objective-C \@synchronized statement. /// /// By default, performs semantic analysis to build the new statement. @@ -1386,7 +1572,7 @@ public: if (ForEachStmt.isInvalid()) return StmtError(); - return getSema().FinishObjCForCollectionStmt(ForEachStmt.take(), Body); + return getSema().FinishObjCForCollectionStmt(ForEachStmt.get(), Body); } /// \brief Build a new C++ exception declaration. @@ -1398,7 +1584,7 @@ public: SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id) { - VarDecl *Var = getSema().BuildExceptionDeclaration(0, Declarator, + VarDecl *Var = getSema().BuildExceptionDeclaration(nullptr, Declarator, StartLoc, IdLoc, Id); if (Var) getSema().CurContext->addDecl(Var); @@ -1479,8 +1665,10 @@ public: } StmtResult RebuildSEHTryStmt(bool IsCXXTry, SourceLocation TryLoc, - Stmt *TryBlock, Stmt *Handler) { - return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler); + Stmt *TryBlock, Stmt *Handler, int HandlerIndex, + int HandlerParentIndex) { + return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler, + HandlerIndex, HandlerParentIndex); } StmtResult RebuildSEHExceptStmt(SourceLocation Loc, Expr *FilterExpr, @@ -1548,7 +1736,7 @@ public: ExprResult RebuildUnaryOperator(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *SubExpr) { - return getSema().BuildUnaryOp(/*Scope=*/0, OpLoc, Opc, SubExpr); + return getSema().BuildUnaryOp(/*Scope=*/nullptr, OpLoc, Opc, SubExpr); } /// \brief Build a new builtin offsetof expression. @@ -1600,7 +1788,7 @@ public: SourceLocation LBracketLoc, Expr *RHS, SourceLocation RBracketLoc) { - return getSema().ActOnArraySubscriptExpr(/*Scope=*/0, LHS, + return getSema().ActOnArraySubscriptExpr(/*Scope=*/nullptr, LHS, LBracketLoc, RHS, RBracketLoc); } @@ -1612,8 +1800,8 @@ public: ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, - Expr *ExecConfig = 0) { - return getSema().ActOnCallExpr(/*Scope=*/0, Callee, LParenLoc, + Expr *ExecConfig = nullptr) { + return getSema().ActOnCallExpr(/*Scope=*/nullptr, Callee, LParenLoc, Args, RParenLoc, ExecConfig); } @@ -1641,25 +1829,25 @@ public: "unnamed member not of record type?"); BaseResult = - getSema().PerformObjectMemberConversion(BaseResult.take(), + getSema().PerformObjectMemberConversion(BaseResult.get(), QualifierLoc.getNestedNameSpecifier(), FoundDecl, Member); if (BaseResult.isInvalid()) return ExprError(); - Base = BaseResult.take(); + Base = BaseResult.get(); ExprValueKind VK = isArrow ? VK_LValue : Base->getValueKind(); MemberExpr *ME = new (getSema().Context) MemberExpr(Base, isArrow, Member, MemberNameInfo, cast<FieldDecl>(Member)->getType(), VK, OK_Ordinary); - return getSema().Owned(ME); + return ME; } CXXScopeSpec SS; SS.Adopt(QualifierLoc); - Base = BaseResult.take(); + Base = BaseResult.get(); QualType BaseType = Base->getType(); // FIXME: this involves duplicating earlier analysis in a lot of @@ -1681,7 +1869,7 @@ public: ExprResult RebuildBinaryOperator(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHS, Expr *RHS) { - return getSema().BuildBinOp(/*Scope=*/0, OpLoc, Opc, LHS, RHS); + return getSema().BuildBinOp(/*Scope=*/nullptr, OpLoc, Opc, LHS, RHS); } /// \brief Build a new conditional operator expression. @@ -1735,9 +1923,9 @@ public: return getSema().BuildMemberReferenceExpr(Base, Base->getType(), OpLoc, /*IsArrow*/ false, SS, SourceLocation(), - /*FirstQualifierInScope*/ 0, + /*FirstQualifierInScope*/ nullptr, NameInfo, - /* TemplateArgs */ 0); + /* TemplateArgs */ nullptr); } /// \brief Build a new initializer list expression. @@ -1784,7 +1972,7 @@ public: /// any semantic analysis. Subclasses may override this routine to provide /// different behavior. ExprResult RebuildImplicitValueInitExpr(QualType T) { - return SemaRef.Owned(new (SemaRef.Context) ImplicitValueInitExpr(T)); + return new (SemaRef.Context) ImplicitValueInitExpr(T); } /// \brief Build a new \c va_arg expression. @@ -2049,9 +2237,7 @@ public: QualType ThisType, bool isImplicit) { getSema().CheckCXXThisCapture(ThisLoc); - return getSema().Owned( - new (getSema().Context) CXXThisExpr(ThisLoc, ThisType, - isImplicit)); + return new (getSema().Context) CXXThisExpr(ThisLoc, ThisType, isImplicit); } /// \brief Build a new C++ throw expression. @@ -2070,8 +2256,7 @@ public: /// provide different behavior. ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc, ParmVarDecl *Param) { - return getSema().Owned(CXXDefaultArgExpr::Create(getSema().Context, Loc, - Param)); + return CXXDefaultArgExpr::Create(getSema().Context, Loc, Param); } /// \brief Build a new C++11 default-initialization expression. @@ -2081,8 +2266,7 @@ public: /// routine to provide different behavior. ExprResult RebuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) { - return getSema().Owned(CXXDefaultInitExpr::Create(getSema().Context, Loc, - Field)); + return CXXDefaultInitExpr::Create(getSema().Context, Loc, Field); } /// \brief Build a new C++ zero-initialization expression. @@ -2135,29 +2319,6 @@ public: Operand); } - /// \brief Build a new unary type trait expression. - /// - /// By default, performs semantic analysis to build the new expression. - /// Subclasses may override this routine to provide different behavior. - ExprResult RebuildUnaryTypeTrait(UnaryTypeTrait Trait, - SourceLocation StartLoc, - TypeSourceInfo *T, - SourceLocation RParenLoc) { - return getSema().BuildUnaryTypeTrait(Trait, StartLoc, T, RParenLoc); - } - - /// \brief Build a new binary type trait expression. - /// - /// By default, performs semantic analysis to build the new expression. - /// Subclasses may override this routine to provide different behavior. - ExprResult RebuildBinaryTypeTrait(BinaryTypeTrait Trait, - SourceLocation StartLoc, - TypeSourceInfo *LhsT, - TypeSourceInfo *RhsT, - SourceLocation RParenLoc) { - return getSema().BuildBinaryTypeTrait(Trait, StartLoc, LhsT, RhsT, RParenLoc); - } - /// \brief Build a new type trait expression. /// /// By default, performs semantic analysis to build the new expression. @@ -2202,16 +2363,17 @@ public: SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, - bool IsAddressOfOperand) { + bool IsAddressOfOperand, + TypeSourceInfo **RecoveryTSI) { CXXScopeSpec SS; SS.Adopt(QualifierLoc); if (TemplateArgs || TemplateKWLoc.isValid()) - return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc, - NameInfo, TemplateArgs); + return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc, NameInfo, + TemplateArgs); - return getSema().BuildQualifiedDeclarationNameExpr(SS, NameInfo, - IsAddressOfOperand); + return getSema().BuildQualifiedDeclarationNameExpr( + SS, NameInfo, IsAddressOfOperand, RecoveryTSI); } /// \brief Build a new template-id expression. @@ -2238,6 +2400,7 @@ public: MultiExprArg Args, bool HadMultipleCandidates, bool ListInitialization, + bool StdInitListInitialization, bool RequiresZeroInit, CXXConstructExpr::ConstructionKind ConstructKind, SourceRange ParenRange) { @@ -2250,6 +2413,7 @@ public: ConvertedArgs, HadMultipleCandidates, ListInitialization, + StdInitListInitialization, RequiresZeroInit, ConstructKind, ParenRange); } @@ -2394,8 +2558,7 @@ public: ExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc, TypeSourceInfo *EncodeTypeInfo, SourceLocation RParenLoc) { - return SemaRef.Owned(SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo, - RParenLoc)); + return SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo, RParenLoc); } /// \brief Build a new Objective-C class message. @@ -2437,25 +2600,13 @@ public: bool IsArrow, bool IsFreeIvar) { // FIXME: We lose track of the IsFreeIvar bit. CXXScopeSpec SS; - ExprResult Base = getSema().Owned(BaseArg); - LookupResult R(getSema(), Ivar->getDeclName(), IvarLoc, - Sema::LookupMemberName); - ExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow, - /*FIME:*/IvarLoc, - SS, 0, - false); - if (Result.isInvalid() || Base.isInvalid()) - return ExprError(); - - if (Result.get()) - return Result; - - return getSema().BuildMemberReferenceExpr(Base.get(), Base.get()->getType(), + DeclarationNameInfo NameInfo(Ivar->getDeclName(), IvarLoc); + return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(), /*FIXME:*/IvarLoc, IsArrow, SS, SourceLocation(), - /*FirstQualifierInScope=*/0, - R, - /*TemplateArgs=*/0); + /*FirstQualifierInScope=*/nullptr, + NameInfo, + /*TemplateArgs=*/nullptr); } /// \brief Build a new Objective-C property reference expression. @@ -2466,25 +2617,14 @@ public: ObjCPropertyDecl *Property, SourceLocation PropertyLoc) { CXXScopeSpec SS; - ExprResult Base = getSema().Owned(BaseArg); - LookupResult R(getSema(), Property->getDeclName(), PropertyLoc, - Sema::LookupMemberName); - bool IsArrow = false; - ExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow, - /*FIME:*/PropertyLoc, - SS, 0, false); - if (Result.isInvalid() || Base.isInvalid()) - return ExprError(); - - if (Result.get()) - return Result; - - return getSema().BuildMemberReferenceExpr(Base.get(), Base.get()->getType(), - /*FIXME:*/PropertyLoc, IsArrow, + DeclarationNameInfo NameInfo(Property->getDeclName(), PropertyLoc); + return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(), + /*FIXME:*/PropertyLoc, + /*IsArrow=*/false, SS, SourceLocation(), - /*FirstQualifierInScope=*/0, - R, - /*TemplateArgs=*/0); + /*FirstQualifierInScope=*/nullptr, + NameInfo, + /*TemplateArgs=*/nullptr); } /// \brief Build a new Objective-C property reference expression. @@ -2508,27 +2648,15 @@ public: /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. ExprResult RebuildObjCIsaExpr(Expr *BaseArg, SourceLocation IsaLoc, - SourceLocation OpLoc, - bool IsArrow) { + SourceLocation OpLoc, bool IsArrow) { CXXScopeSpec SS; - ExprResult Base = getSema().Owned(BaseArg); - LookupResult R(getSema(), &getSema().Context.Idents.get("isa"), IsaLoc, - Sema::LookupMemberName); - ExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow, - OpLoc, - SS, 0, false); - if (Result.isInvalid() || Base.isInvalid()) - return ExprError(); - - if (Result.get()) - return Result; - - return getSema().BuildMemberReferenceExpr(Base.get(), Base.get()->getType(), + DeclarationNameInfo NameInfo(&getSema().Context.Idents.get("isa"), IsaLoc); + return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(), OpLoc, IsArrow, SS, SourceLocation(), - /*FirstQualifierInScope=*/0, - R, - /*TemplateArgs=*/0); + /*FirstQualifierInScope=*/nullptr, + NameInfo, + /*TemplateArgs=*/nullptr); } /// \brief Build a new shuffle vector expression. @@ -2552,17 +2680,15 @@ public: VK_RValue, BuiltinLoc); QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType()); Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy, - CK_BuiltinFnToFnPtr).take(); + CK_BuiltinFnToFnPtr).get(); // Build the CallExpr - ExprResult TheCall = SemaRef.Owned( - new (SemaRef.Context) CallExpr(SemaRef.Context, Callee, SubExprs, - Builtin->getCallResultType(), - Expr::getValueKindForType(Builtin->getResultType()), - RParenLoc)); + ExprResult TheCall = new (SemaRef.Context) CallExpr( + SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(), + Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc); // Type-check the __builtin_shufflevector expression. - return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.take())); + return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.get())); } /// \brief Build a new convert vector expression. @@ -2657,12 +2783,16 @@ private: QualType ObjectType, NamedDecl *FirstQualifierInScope, CXXScopeSpec &SS); + + TypeSourceInfo *TransformTSIInObjectScope(TypeLoc TL, QualType ObjectType, + NamedDecl *FirstQualifierInScope, + CXXScopeSpec &SS); }; template<typename Derived> StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) { if (!S) - return SemaRef.Owned(S); + return S; switch (S->getStmtClass()) { case Stmt::NoStmtClass: break; @@ -2688,7 +2818,7 @@ StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) { } } - return SemaRef.Owned(S); + return S; } template<typename Derived> @@ -2712,7 +2842,7 @@ OMPClause *TreeTransform<Derived>::TransformOMPClause(OMPClause *S) { template<typename Derived> ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) { if (!E) - return SemaRef.Owned(E); + return E; switch (E->getStmtClass()) { case Stmt::NoStmtClass: break; @@ -2723,16 +2853,16 @@ ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) { #include "clang/AST/StmtNodes.inc" } - return SemaRef.Owned(E); + return E; } template<typename Derived> ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init, - bool CXXDirectInit) { + bool NotCopyInit) { // Initializers are instantiated like expressions, except that various outer // layers are stripped. if (!Init) - return SemaRef.Owned(Init); + return Init; if (ExprWithCleanups *ExprTemp = dyn_cast<ExprWithCleanups>(Init)) Init = ExprTemp->getSubExpr(); @@ -2748,13 +2878,13 @@ ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init, if (CXXStdInitializerListExpr *ILE = dyn_cast<CXXStdInitializerListExpr>(Init)) - return TransformInitializer(ILE->getSubExpr(), CXXDirectInit); + return TransformInitializer(ILE->getSubExpr(), NotCopyInit); - // If this is not a direct-initializer, we only need to reconstruct + // If this is copy-initialization, we only need to reconstruct // InitListExprs. Other forms of copy-initialization will be a no-op if // the initializer is already the right type. CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init); - if (!CXXDirectInit && !(Construct && Construct->isListInitialization())) + if (!NotCopyInit && !(Construct && Construct->isListInitialization())) return getDerived().TransformExpr(Init); // Revert value-initialization back to empty parens. @@ -2774,10 +2904,15 @@ ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init, if (!Construct || isa<CXXTemporaryObjectExpr>(Construct)) return getDerived().TransformExpr(Init); + // If the initialization implicitly converted an initializer list to a + // std::initializer_list object, unwrap the std::initializer_list too. + if (Construct && Construct->isStdInitListInitialization()) + return TransformInitializer(Construct->getArg(0), NotCopyInit); + SmallVector<Expr*, 8> NewArgs; bool ArgChanged = false; if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(), - /*IsCall*/true, NewArgs, &ArgChanged)) + /*IsCall*/true, NewArgs, &ArgChanged)) return ExprError(); // If this was list initialization, revert to list form. @@ -2788,6 +2923,13 @@ ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init, // Build a ParenListExpr to represent anything else. SourceRange Parens = Construct->getParenOrBraceRange(); + if (Parens.isInvalid()) { + // This was a variable declaration's initialization for which no initializer + // was specified. + assert(NewArgs.empty() && + "no parens or braces but have direct init with arguments?"); + return ExprEmpty(); + } return getDerived().RebuildParenListExpr(Parens.getBegin(), NewArgs, Parens.getEnd()); } @@ -2860,9 +3002,11 @@ bool TreeTransform<Derived>::TransformExprs(Expr **Inputs, if (Out.isInvalid()) return true; + // FIXME: Can this happen? We should not try to expand the pack + // in this case. if (Out.get()->containsUnexpandedParameterPack()) { - Out = RebuildPackExpansion(Out.get(), Expansion->getEllipsisLoc(), - OrigNumExpansions); + Out = getDerived().RebuildPackExpansion( + Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions); if (Out.isInvalid()) return true; } @@ -2870,6 +3014,23 @@ bool TreeTransform<Derived>::TransformExprs(Expr **Inputs, Outputs.push_back(Out.get()); } + // If we're supposed to retain a pack expansion, do so by temporarily + // forgetting the partially-substituted parameter pack. + if (RetainExpansion) { + ForgetPartiallySubstitutedPackRAII Forget(getDerived()); + + ExprResult Out = getDerived().TransformExpr(Pattern); + if (Out.isInvalid()) + return true; + + Out = getDerived().RebuildPackExpansion( + Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions); + if (Out.isInvalid()) + return true; + + Outputs.push_back(Out.get()); + } + continue; } @@ -2906,7 +3067,7 @@ TreeTransform<Derived>::TransformNestedNameSpecifierLoc( switch (QNNS->getKind()) { case NestedNameSpecifier::Identifier: - if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/0, + if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/nullptr, *QNNS->getAsIdentifier(), Q.getLocalBeginLoc(), Q.getLocalEndLoc(), @@ -2974,7 +3135,7 @@ TreeTransform<Derived>::TransformNestedNameSpecifierLoc( } // The qualifier-in-scope and object type only apply to the leftmost entity. - FirstQualifierInScope = 0; + FirstQualifierInScope = nullptr; ObjectType = QualType(); } @@ -3023,7 +3184,7 @@ TreeTransform<Derived> NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->getType()); } else { - NewTInfo = 0; + NewTInfo = nullptr; TemporaryBase Rebase(*this, NameInfo.getLoc(), Name); QualType NewT = getDerived().TransformType(Name.getCXXNameType()); if (NewT.isNull()) @@ -3074,7 +3235,7 @@ TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS, if (SS.getScopeRep()) { // These apply to the scope specifier, not the template. ObjectType = QualType(); - FirstQualifierInScope = 0; + FirstQualifierInScope = nullptr; } if (!getDerived().AlwaysRebuild() && @@ -3193,7 +3354,7 @@ bool TreeTransform<Derived>::TransformTemplateArgument( case TemplateArgument::Type: { TypeSourceInfo *DI = Input.getTypeSourceInfo(); - if (DI == NULL) + if (!DI) DI = InventTypeSourceInfo(Input.getArgument().getAsType()); DI = getDerived().TransformType(DI); @@ -3238,7 +3399,7 @@ bool TreeTransform<Derived>::TransformTemplateArgument( ExprResult E = getDerived().TransformExpr(InputExpr); E = SemaRef.ActOnConstantExpression(E); if (E.isInvalid()) return true; - Output = TemplateArgumentLoc(TemplateArgument(E.take()), E.take()); + Output = TemplateArgumentLoc(TemplateArgument(E.get()), E.get()); return false; } } @@ -3463,7 +3624,7 @@ TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *DI) { QualType Result = getDerived().TransformType(TLB, TL); if (Result.isNull()) - return 0; + return nullptr; return TLB.getTypeSourceInfo(SemaRef.Context, Result); } @@ -3564,52 +3725,14 @@ TreeTransform<Derived>::TransformTypeInObjectScope(TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup, CXXScopeSpec &SS) { - QualType T = TL.getType(); - if (getDerived().AlreadyTransformed(T)) + if (getDerived().AlreadyTransformed(TL.getType())) return TL; - TypeLocBuilder TLB; - QualType Result; - - if (isa<TemplateSpecializationType>(T)) { - TemplateSpecializationTypeLoc SpecTL = - TL.castAs<TemplateSpecializationTypeLoc>(); - - TemplateName Template = - getDerived().TransformTemplateName(SS, - SpecTL.getTypePtr()->getTemplateName(), - SpecTL.getTemplateNameLoc(), - ObjectType, UnqualLookup); - if (Template.isNull()) - return TypeLoc(); - - Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL, - Template); - } else if (isa<DependentTemplateSpecializationType>(T)) { - DependentTemplateSpecializationTypeLoc SpecTL = - TL.castAs<DependentTemplateSpecializationTypeLoc>(); - - TemplateName Template - = getDerived().RebuildTemplateName(SS, - *SpecTL.getTypePtr()->getIdentifier(), - SpecTL.getTemplateNameLoc(), - ObjectType, UnqualLookup); - if (Template.isNull()) - return TypeLoc(); - - Result = getDerived().TransformDependentTemplateSpecializationType(TLB, - SpecTL, - Template, - SS); - } else { - // Nothing special needs to be done for these. - Result = getDerived().TransformType(TLB, TL); - } - - if (Result.isNull()) - return TypeLoc(); - - return TLB.getTypeSourceInfo(SemaRef.Context, Result)->getTypeLoc(); + TypeSourceInfo *TSI = + TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS); + if (TSI) + return TSI->getTypeLoc(); + return TypeLoc(); } template<typename Derived> @@ -3618,16 +3741,23 @@ TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo, QualType ObjectType, NamedDecl *UnqualLookup, CXXScopeSpec &SS) { - // FIXME: Painfully copy-paste from the above! - - QualType T = TSInfo->getType(); - if (getDerived().AlreadyTransformed(T)) + if (getDerived().AlreadyTransformed(TSInfo->getType())) return TSInfo; + return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType, + UnqualLookup, SS); +} + +template <typename Derived> +TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope( + TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup, + CXXScopeSpec &SS) { + QualType T = TL.getType(); + assert(!getDerived().AlreadyTransformed(T)); + TypeLocBuilder TLB; QualType Result; - TypeLoc TL = TSInfo->getTypeLoc(); if (isa<TemplateSpecializationType>(T)) { TemplateSpecializationTypeLoc SpecTL = TL.castAs<TemplateSpecializationTypeLoc>(); @@ -3638,7 +3768,7 @@ TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo, SpecTL.getTemplateNameLoc(), ObjectType, UnqualLookup); if (Template.isNull()) - return 0; + return nullptr; Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL, Template); @@ -3652,7 +3782,7 @@ TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo, SpecTL.getTemplateNameLoc(), ObjectType, UnqualLookup); if (Template.isNull()) - return 0; + return nullptr; Result = getDerived().TransformDependentTemplateSpecializationType(TLB, SpecTL, @@ -3664,7 +3794,7 @@ TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo, } if (Result.isNull()) - return 0; + return nullptr; return TLB.getTypeSourceInfo(SemaRef.Context, Result); } @@ -3693,6 +3823,13 @@ QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB, return TransformTypeSpecType(TLB, T); } +template <typename Derived> +QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB, + AdjustedTypeLoc TL) { + // Adjustments applied during transformation are handled elsewhere. + return getDerived().TransformType(TLB, TL.getOriginalLoc()); +} + template<typename Derived> QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB, DecayedTypeLoc TL) { @@ -3833,7 +3970,7 @@ TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB, return QualType(); TypeSourceInfo* OldClsTInfo = TL.getClassTInfo(); - TypeSourceInfo* NewClsTInfo = 0; + TypeSourceInfo *NewClsTInfo = nullptr; if (OldClsTInfo) { NewClsTInfo = getDerived().TransformType(OldClsTInfo); if (!NewClsTInfo) @@ -3861,6 +3998,14 @@ TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB, return QualType(); } + // If we had to adjust the pointee type when building a member pointer, make + // sure to push TypeLoc info for it. + const MemberPointerType *MPT = Result->getAs<MemberPointerType>(); + if (MPT && PointeeType != MPT->getPointeeType()) { + assert(isa<AdjustedType>(MPT->getPointeeType())); + TLB.push<AdjustedTypeLoc>(MPT->getPointeeType()); + } + MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result); NewTL.setSigilLoc(TL.getSigilLoc()); NewTL.setClassTInfo(NewClsTInfo); @@ -3901,8 +4046,8 @@ TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB, if (Size) { EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::ConstantEvaluated); - Size = getDerived().TransformExpr(Size).template takeAs<Expr>(); - Size = SemaRef.ActOnConstantExpression(Size).take(); + Size = getDerived().TransformExpr(Size).template getAs<Expr>(); + Size = SemaRef.ActOnConstantExpression(Size).get(); } NewTL.setSizeExpr(Size); @@ -3932,7 +4077,7 @@ QualType TreeTransform<Derived>::TransformIncompleteArrayType( IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result); NewTL.setLBracketLoc(TL.getLBracketLoc()); NewTL.setRBracketLoc(TL.getRBracketLoc()); - NewTL.setSizeExpr(0); + NewTL.setSizeExpr(nullptr); return Result; } @@ -3951,7 +4096,7 @@ TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB, if (SizeResult.isInvalid()) return QualType(); - Expr *Size = SizeResult.take(); + Expr *Size = SizeResult.get(); QualType Result = TL.getType(); if (getDerived().AlwaysRebuild() || @@ -3966,7 +4111,9 @@ TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB, return QualType(); } - VariableArrayTypeLoc NewTL = TLB.push<VariableArrayTypeLoc>(Result); + // We might have constant size array now, but fortunately it has the same + // location layout. + ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); NewTL.setLBracketLoc(TL.getLBracketLoc()); NewTL.setRBracketLoc(TL.getRBracketLoc()); NewTL.setSizeExpr(Size); @@ -4047,7 +4194,7 @@ QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType( ElementType != T->getElementType() || Size.get() != T->getSizeExpr()) { Result = getDerived().RebuildDependentSizedExtVectorType(ElementType, - Size.take(), + Size.get(), T->getAttributeLoc()); if (Result.isNull()) return QualType(); @@ -4118,7 +4265,7 @@ ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam( ParmVarDecl *OldParm, int indexAdjustment, Optional<unsigned> NumExpansions, bool ExpectParameterPack) { TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo(); - TypeSourceInfo *NewDI = 0; + TypeSourceInfo *NewDI = nullptr; if (NumExpansions && isa<PackExpansionType>(OldDI->getType())) { // If we're substituting into a pack expansion type and we know the @@ -4133,14 +4280,14 @@ ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam( QualType Result = getDerived().TransformType(TLB, OldExpansionTL.getPatternLoc()); if (Result.isNull()) - return 0; + return nullptr; Result = RebuildPackExpansionType(Result, OldExpansionTL.getPatternLoc().getSourceRange(), OldExpansionTL.getEllipsisLoc(), NumExpansions); if (Result.isNull()) - return 0; + return nullptr; PackExpansionTypeLoc NewExpansionTL = TLB.push<PackExpansionTypeLoc>(Result); @@ -4149,7 +4296,7 @@ ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam( } else NewDI = getDerived().TransformType(OldDI); if (!NewDI) - return 0; + return nullptr; if (NewDI == OldDI && indexAdjustment == 0) return OldParm; @@ -4162,7 +4309,7 @@ ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam( NewDI->getType(), NewDI, OldParm->getStorageClass(), - /* DefArg */ NULL); + /* DefArg */ nullptr); newParm->setScopeInfo(OldParm->getFunctionScopeDepth(), OldParm->getFunctionScopeIndex() + indexAdjustment); return newParm; @@ -4182,7 +4329,7 @@ bool TreeTransform<Derived>:: assert(OldParm->getFunctionScopeIndex() == i); Optional<unsigned> NumExpansions; - ParmVarDecl *NewParm = 0; + ParmVarDecl *NewParm = nullptr; if (OldParm->isParameterPack()) { // We have a function parameter pack that may need to be expanded. SmallVector<UnexpandedParameterPack, 2> Unexpanded; @@ -4311,7 +4458,7 @@ bool TreeTransform<Derived>:: OutParamTypes.push_back(NewType); if (PVars) - PVars->push_back(0); + PVars->push_back(nullptr); } // We're done with the pack expansion. @@ -4328,7 +4475,7 @@ bool TreeTransform<Derived>:: OutParamTypes.push_back(NewType); if (PVars) - PVars->push_back(0); + PVars->push_back(nullptr); } // We'll substitute the parameter now without expanding the pack @@ -4350,7 +4497,7 @@ bool TreeTransform<Derived>:: OutParamTypes.push_back(NewType); if (PVars) - PVars->push_back(0); + PVars->push_back(nullptr); } #ifndef NDEBUG @@ -4368,7 +4515,7 @@ template<typename Derived> QualType TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, FunctionProtoTypeLoc TL) { - return getDerived().TransformFunctionProtoType(TLB, TL, 0, 0); + return getDerived().TransformFunctionProtoType(TLB, TL, nullptr, 0); } template<typename Derived> @@ -4391,11 +4538,9 @@ TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, QualType ResultType; if (T->hasTrailingReturn()) { - if (getDerived().TransformFunctionTypeParams(TL.getBeginLoc(), - TL.getParmArray(), - TL.getNumArgs(), - TL.getTypePtr()->arg_type_begin(), - ParamTypes, &ParamDecls)) + if (getDerived().TransformFunctionTypeParams( + TL.getBeginLoc(), TL.getParmArray(), TL.getNumParams(), + TL.getTypePtr()->param_type_begin(), ParamTypes, &ParamDecls)) return QualType(); { @@ -4407,31 +4552,29 @@ TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, // declarator. Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, ThisTypeQuals); - ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); + ResultType = getDerived().TransformType(TLB, TL.getReturnLoc()); if (ResultType.isNull()) return QualType(); } } else { - ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); + ResultType = getDerived().TransformType(TLB, TL.getReturnLoc()); if (ResultType.isNull()) return QualType(); - if (getDerived().TransformFunctionTypeParams(TL.getBeginLoc(), - TL.getParmArray(), - TL.getNumArgs(), - TL.getTypePtr()->arg_type_begin(), - ParamTypes, &ParamDecls)) + if (getDerived().TransformFunctionTypeParams( + TL.getBeginLoc(), TL.getParmArray(), TL.getNumParams(), + TL.getTypePtr()->param_type_begin(), ParamTypes, &ParamDecls)) return QualType(); } // FIXME: Need to transform the exception-specification too. QualType Result = TL.getType(); - if (getDerived().AlwaysRebuild() || - ResultType != T->getResultType() || - T->getNumArgs() != ParamTypes.size() || - !std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) { + if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType() || + T->getNumParams() != ParamTypes.size() || + !std::equal(T->param_type_begin(), T->param_type_end(), + ParamTypes.begin())) { Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, T->getExtProtoInfo()); if (Result.isNull()) @@ -4443,8 +4586,8 @@ TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, NewTL.setLParenLoc(TL.getLParenLoc()); NewTL.setRParenLoc(TL.getRParenLoc()); NewTL.setLocalRangeEnd(TL.getLocalRangeEnd()); - for (unsigned i = 0, e = NewTL.getNumArgs(); i != e; ++i) - NewTL.setArg(i, ParamDecls[i]); + for (unsigned i = 0, e = NewTL.getNumParams(); i != e; ++i) + NewTL.setParam(i, ParamDecls[i]); return Result; } @@ -4454,13 +4597,12 @@ QualType TreeTransform<Derived>::TransformFunctionNoProtoType( TypeLocBuilder &TLB, FunctionNoProtoTypeLoc TL) { const FunctionNoProtoType *T = TL.getTypePtr(); - QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); + QualType ResultType = getDerived().TransformType(TLB, TL.getReturnLoc()); if (ResultType.isNull()) return QualType(); QualType Result = TL.getType(); - if (getDerived().AlwaysRebuild() || - ResultType != T->getResultType()) + if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType()) Result = getDerived().RebuildFunctionNoProtoType(ResultType); FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result); @@ -4541,7 +4683,7 @@ QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, if (Result.isNull()) return QualType(); } - else E.take(); + else E.get(); TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result); NewTL.setTypeofLoc(TL.getTypeofLoc()); @@ -4581,14 +4723,14 @@ QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB, const DecltypeType *T = TL.getTypePtr(); // decltype expressions are not potentially evaluated contexts - EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 0, - /*IsDecltype=*/ true); + EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, + nullptr, /*IsDecltype=*/ true); ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); if (E.isInvalid()) return QualType(); - E = getSema().ActOnDecltypeExpression(E.take()); + E = getSema().ActOnDecltypeExpression(E.get()); if (E.isInvalid()) return QualType(); @@ -4599,7 +4741,7 @@ QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB, if (Result.isNull()) return QualType(); } - else E.take(); + else E.get(); DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result); NewTL.setNameLoc(TL.getNameLoc()); @@ -5266,7 +5408,7 @@ TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB, template<typename Derived> StmtResult TreeTransform<Derived>::TransformNullStmt(NullStmt *S) { - return SemaRef.Owned(S); + return S; } template<typename Derived> @@ -5284,13 +5426,12 @@ TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, bool SubStmtInvalid = false; bool SubStmtChanged = false; SmallVector<Stmt*, 8> Statements; - for (CompoundStmt::body_iterator B = S->body_begin(), BEnd = S->body_end(); - B != BEnd; ++B) { - StmtResult Result = getDerived().TransformStmt(*B); + for (auto *B : S->body()) { + StmtResult Result = getDerived().TransformStmt(B); if (Result.isInvalid()) { // Immediately fail if this was a DeclStmt, since it's very // likely that this will cause problems for future statements. - if (isa<DeclStmt>(*B)) + if (isa<DeclStmt>(B)) return StmtError(); // Otherwise, just keep processing substatements and fail later. @@ -5298,8 +5439,8 @@ TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, continue; } - SubStmtChanged = SubStmtChanged || Result.get() != *B; - Statements.push_back(Result.takeAs<Stmt>()); + SubStmtChanged = SubStmtChanged || Result.get() != B; + Statements.push_back(Result.getAs<Stmt>()); } if (SubStmtInvalid) @@ -5307,7 +5448,7 @@ TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, if (!getDerived().AlwaysRebuild() && !SubStmtChanged) - return SemaRef.Owned(S); + return S; return getDerived().RebuildCompoundStmt(S->getLBracLoc(), Statements, @@ -5409,7 +5550,7 @@ StmtResult TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { // Transform the condition ExprResult Cond; - VarDecl *ConditionVar = 0; + VarDecl *ConditionVar = nullptr; if (S->getConditionVariable()) { ConditionVar = cast_or_null<VarDecl>( @@ -5426,7 +5567,7 @@ TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { // Convert the condition to a boolean value. if (S->getCond()) { - ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getIfLoc(), + ExprResult CondE = getSema().ActOnBooleanCondition(nullptr, S->getIfLoc(), Cond.get()); if (CondE.isInvalid()) return StmtError(); @@ -5435,7 +5576,7 @@ TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { } } - Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); + Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.get())); if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) return StmtError(); @@ -5454,7 +5595,7 @@ TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { ConditionVar == S->getConditionVariable() && Then.get() == S->getThen() && Else.get() == S->getElse()) - return SemaRef.Owned(S); + return S; return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar, Then.get(), @@ -5466,7 +5607,7 @@ StmtResult TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { // Transform the condition. ExprResult Cond; - VarDecl *ConditionVar = 0; + VarDecl *ConditionVar = nullptr; if (S->getConditionVariable()) { ConditionVar = cast_or_null<VarDecl>( @@ -5504,7 +5645,7 @@ StmtResult TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { // Transform the condition ExprResult Cond; - VarDecl *ConditionVar = 0; + VarDecl *ConditionVar = nullptr; if (S->getConditionVariable()) { ConditionVar = cast_or_null<VarDecl>( @@ -5521,7 +5662,8 @@ TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { if (S->getCond()) { // Convert the condition to a boolean value. - ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getWhileLoc(), + ExprResult CondE = getSema().ActOnBooleanCondition(nullptr, + S->getWhileLoc(), Cond.get()); if (CondE.isInvalid()) return StmtError(); @@ -5529,7 +5671,7 @@ TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { } } - Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); + Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.get())); if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) return StmtError(); @@ -5564,7 +5706,7 @@ TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { if (!getDerived().AlwaysRebuild() && Cond.get() == S->getCond() && Body.get() == S->getBody()) - return SemaRef.Owned(S); + return S; return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(), /*FIXME:*/S->getWhileLoc(), Cond.get(), @@ -5581,7 +5723,7 @@ TreeTransform<Derived>::TransformForStmt(ForStmt *S) { // Transform the condition ExprResult Cond; - VarDecl *ConditionVar = 0; + VarDecl *ConditionVar = nullptr; if (S->getConditionVariable()) { ConditionVar = cast_or_null<VarDecl>( @@ -5598,7 +5740,8 @@ TreeTransform<Derived>::TransformForStmt(ForStmt *S) { if (S->getCond()) { // Convert the condition to a boolean value. - ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getForLoc(), + ExprResult CondE = getSema().ActOnBooleanCondition(nullptr, + S->getForLoc(), Cond.get()); if (CondE.isInvalid()) return StmtError(); @@ -5607,7 +5750,7 @@ TreeTransform<Derived>::TransformForStmt(ForStmt *S) { } } - Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); + Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.get())); if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) return StmtError(); @@ -5630,7 +5773,7 @@ TreeTransform<Derived>::TransformForStmt(ForStmt *S) { FullCond.get() == S->getCond() && Inc.get() == S->getInc() && Body.get() == S->getBody()) - return SemaRef.Owned(S); + return S; return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(), Init.get(), FullCond, ConditionVar, @@ -5656,11 +5799,11 @@ TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { ExprResult Target = getDerived().TransformExpr(S->getTarget()); if (Target.isInvalid()) return StmtError(); - Target = SemaRef.MaybeCreateExprWithCleanups(Target.take()); + Target = SemaRef.MaybeCreateExprWithCleanups(Target.get()); if (!getDerived().AlwaysRebuild() && Target.get() == S->getTarget()) - return SemaRef.Owned(S); + return S; return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(), Target.get()); @@ -5669,13 +5812,13 @@ TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { template<typename Derived> StmtResult TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { - return SemaRef.Owned(S); + return S; } template<typename Derived> StmtResult TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { - return SemaRef.Owned(S); + return S; } template<typename Derived> @@ -5695,21 +5838,19 @@ StmtResult TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { bool DeclChanged = false; SmallVector<Decl *, 4> Decls; - for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); - D != DEnd; ++D) { - Decl *Transformed = getDerived().TransformDefinition((*D)->getLocation(), - *D); + for (auto *D : S->decls()) { + Decl *Transformed = getDerived().TransformDefinition(D->getLocation(), D); if (!Transformed) return StmtError(); - if (Transformed != *D) + if (Transformed != D) DeclChanged = true; Decls.push_back(Transformed); } if (!getDerived().AlwaysRebuild() && !DeclChanged) - return SemaRef.Owned(S); + return S; return getDerived().RebuildDeclStmt(Decls, S->getStartLoc(), S->getEndLoc()); } @@ -5764,14 +5905,14 @@ TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) { } if (!getDerived().AlwaysRebuild() && !ExprsChanged) - return SemaRef.Owned(S); + return S; // Go through the clobbers. for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I) Clobbers.push_back(S->getClobberStringLiteral(I)); // No need to transform the asm string literal. - AsmString = SemaRef.Owned(S->getAsmString()); + AsmString = S->getAsmString(); return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(), S->isVolatile(), S->getNumOutputs(), S->getNumInputs(), Names.data(), @@ -5796,7 +5937,7 @@ TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) { HadError = true; } else { HadChange |= (Result.get() != SrcExprs[i]); - TransformedExprs.push_back(Result.take()); + TransformedExprs.push_back(Result.get()); } } @@ -5828,7 +5969,7 @@ TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { return StmtError(); if (Catch.get() != S->getCatchStmt(I)) AnyCatchChanged = true; - CatchStmts.push_back(Catch.release()); + CatchStmts.push_back(Catch.get()); } // Transform the @finally statement (if present). @@ -5844,7 +5985,7 @@ TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { TryBody.get() == S->getTryBody() && !AnyCatchChanged && Finally.get() == S->getFinallyStmt()) - return SemaRef.Owned(S); + return S; // Build a new statement. return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(), @@ -5855,9 +5996,9 @@ template<typename Derived> StmtResult TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { // Transform the @catch parameter, if there is one. - VarDecl *Var = 0; + VarDecl *Var = nullptr; if (VarDecl *FromVar = S->getCatchParamDecl()) { - TypeSourceInfo *TSInfo = 0; + TypeSourceInfo *TSInfo = nullptr; if (FromVar->getTypeSourceInfo()) { TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo()); if (!TSInfo) @@ -5898,7 +6039,7 @@ TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { // If nothing changed, just retain this statement. if (!getDerived().AlwaysRebuild() && Body.get() == S->getFinallyBody()) - return SemaRef.Owned(S); + return S; // Build a new statement. return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(), @@ -5917,7 +6058,7 @@ TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { if (!getDerived().AlwaysRebuild() && Operand.get() == S->getThrowExpr()) - return getSema().Owned(S); + return S; return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get()); } @@ -5945,7 +6086,7 @@ TreeTransform<Derived>::TransformObjCAtSynchronizedStmt( if (!getDerived().AlwaysRebuild() && Object.get() == S->getSynchExpr() && Body.get() == S->getSynchBody()) - return SemaRef.Owned(S); + return S; // Build a new statement. return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(), @@ -5964,7 +6105,7 @@ TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt( // If nothing changed, just retain this statement. if (!getDerived().AlwaysRebuild() && Body.get() == S->getSubStmt()) - return SemaRef.Owned(S); + return S; // Build a new statement. return getDerived().RebuildObjCAutoreleasePoolStmt( @@ -5995,7 +6136,7 @@ TreeTransform<Derived>::TransformObjCForCollectionStmt( Element.get() == S->getElement() && Collection.get() == S->getCollection() && Body.get() == S->getBody()) - return SemaRef.Owned(S); + return S; // Build a new statement. return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(), @@ -6008,7 +6149,7 @@ TreeTransform<Derived>::TransformObjCForCollectionStmt( template <typename Derived> StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { // Transform the exception declaration, if any. - VarDecl *Var = 0; + VarDecl *Var = nullptr; if (VarDecl *ExceptionDecl = S->getExceptionDecl()) { TypeSourceInfo *T = getDerived().TransformType(ExceptionDecl->getTypeSourceInfo()); @@ -6029,7 +6170,7 @@ StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { if (!getDerived().AlwaysRebuild() && !Var && Handler.get() == S->getHandlerBlock()) - return SemaRef.Owned(S); + return S; return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get()); } @@ -6050,12 +6191,12 @@ StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) { return StmtError(); HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); - Handlers.push_back(Handler.takeAs<Stmt>()); + Handlers.push_back(Handler.getAs<Stmt>()); } if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() && !HandlerChanged) - return SemaRef.Owned(S); + return S; return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(), Handlers); @@ -6076,17 +6217,17 @@ TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) { if (Cond.isInvalid()) return StmtError(); if (Cond.get()) - Cond = SemaRef.CheckBooleanCondition(Cond.take(), S->getColonLoc()); + Cond = SemaRef.CheckBooleanCondition(Cond.get(), S->getColonLoc()); if (Cond.isInvalid()) return StmtError(); if (Cond.get()) - Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.take()); + Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.get()); ExprResult Inc = getDerived().TransformExpr(S->getInc()); if (Inc.isInvalid()) return StmtError(); if (Inc.get()) - Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.take()); + Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.get()); StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt()); if (LoopVar.isInvalid()) @@ -6125,7 +6266,7 @@ TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) { } if (NewStmt.get() == S) - return SemaRef.Owned(S); + return S; return FinishCXXForRangeStmt(NewStmt.get(), Body.get()); } @@ -6161,7 +6302,7 @@ TreeTransform<Derived>::TransformMSDependentExistsStmt( CXXScopeSpec SS; SS.Adopt(QualifierLoc); bool Dependent = false; - switch (getSema().CheckMicrosoftIfExistsSymbol(/*S=*/0, SS, NameInfo)) { + switch (getSema().CheckMicrosoftIfExistsSymbol(/*S=*/nullptr, SS, NameInfo)) { case Sema::IER_Exists: if (S->isIfExists()) break; @@ -6237,10 +6378,11 @@ StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) { if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() && Handler.get() == S->getHandler()) - return SemaRef.Owned(S); + return S; - return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(), - TryBlock.take(), Handler.take()); + return getDerived().RebuildSEHTryStmt( + S->getIsCXXTry(), S->getTryLoc(), TryBlock.get(), Handler.get(), + S->getHandlerIndex(), S->getHandlerParentIndex()); } template <typename Derived> @@ -6249,7 +6391,7 @@ StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) { if (Block.isInvalid()) return StmtError(); - return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.take()); + return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.get()); } template <typename Derived> @@ -6262,8 +6404,8 @@ StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) { if (Block.isInvalid()) return StmtError(); - return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.take(), - Block.take()); + return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(), + Block.get()); } template <typename Derived> @@ -6276,9 +6418,16 @@ StmtResult TreeTransform<Derived>::TransformSEHHandler(Stmt *Handler) { template<typename Derived> StmtResult -TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) { - DeclarationNameInfo DirName; - getSema().StartOpenMPDSABlock(OMPD_parallel, DirName, 0); +TreeTransform<Derived>::TransformSEHLeaveStmt(SEHLeaveStmt *S) { + return S; +} + +//===----------------------------------------------------------------------===// +// OpenMP directive transformation +//===----------------------------------------------------------------------===// +template <typename Derived> +StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective( + OMPExecutableDirective *D) { // Transform the clauses llvm::SmallVector<OMPClause *, 16> TClauses; @@ -6288,101 +6437,473 @@ TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) { I != E; ++I) { if (*I) { OMPClause *Clause = getDerived().TransformOMPClause(*I); - if (!Clause) { - getSema().EndOpenMPDSABlock(0); - return StmtError(); - } - TClauses.push_back(Clause); + if (Clause) + TClauses.push_back(Clause); + } else { + TClauses.push_back(nullptr); } - else { - TClauses.push_back(0); + } + StmtResult AssociatedStmt; + if (D->hasAssociatedStmt()) { + if (!D->getAssociatedStmt()) { + return StmtError(); + } + AssociatedStmt = getDerived().TransformStmt(D->getAssociatedStmt()); + if (AssociatedStmt.isInvalid()) { + return StmtError(); } } - if (!D->getAssociatedStmt()) { - getSema().EndOpenMPDSABlock(0); + if (TClauses.size() != Clauses.size()) { return StmtError(); } - StmtResult AssociatedStmt = - getDerived().TransformStmt(D->getAssociatedStmt()); - if (AssociatedStmt.isInvalid()) { - getSema().EndOpenMPDSABlock(0); - return StmtError(); + + // Transform directive name for 'omp critical' directive. + DeclarationNameInfo DirName; + if (D->getDirectiveKind() == OMPD_critical) { + DirName = cast<OMPCriticalDirective>(D)->getDirectiveName(); + DirName = getDerived().TransformDeclarationNameInfo(DirName); } - StmtResult Res = getDerived().RebuildOMPParallelDirective(TClauses, - AssociatedStmt.take(), - D->getLocStart(), - D->getLocEnd()); - getSema().EndOpenMPDSABlock(Res.get()); + return getDerived().RebuildOMPExecutableDirective( + D->getDirectiveKind(), DirName, TClauses, AssociatedStmt.get(), + D->getLocStart(), D->getLocEnd()); +} + +template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel, DirName, nullptr, + D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); return Res; } -template<typename Derived> +template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_simd, DirName, nullptr, + D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPForDirective(OMPForDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_for, DirName, nullptr, + D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_sections, DirName, nullptr, + D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_section, DirName, nullptr, + D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_single, DirName, nullptr, + D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPMasterDirective(OMPMasterDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_master, DirName, nullptr, + D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPCriticalDirective(OMPCriticalDirective *D) { + getDerived().getSema().StartOpenMPDSABlock( + OMPD_critical, D->getDirectiveName(), nullptr, D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective( + OMPParallelForDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for, DirName, + nullptr, D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective( + OMPParallelSectionsDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_sections, DirName, + nullptr, D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_task, DirName, nullptr, + D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult TreeTransform<Derived>::TransformOMPTaskyieldDirective( + OMPTaskyieldDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_taskyield, DirName, nullptr, + D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_barrier, DirName, nullptr, + D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_taskwait, DirName, nullptr, + D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_flush, DirName, nullptr, + D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +//===----------------------------------------------------------------------===// +// OpenMP clause transformation +//===----------------------------------------------------------------------===// +template <typename Derived> +OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *C) { + ExprResult Cond = getDerived().TransformExpr(C->getCondition()); + if (Cond.isInvalid()) + return nullptr; + return getDerived().RebuildOMPIfClause(Cond.get(), C->getLocStart(), + C->getLParenLoc(), C->getLocEnd()); +} + +template <typename Derived> +OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *C) { + ExprResult Cond = getDerived().TransformExpr(C->getCondition()); + if (Cond.isInvalid()) + return nullptr; + return getDerived().RebuildOMPFinalClause(Cond.get(), C->getLocStart(), + C->getLParenLoc(), C->getLocEnd()); +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *C) { + ExprResult NumThreads = getDerived().TransformExpr(C->getNumThreads()); + if (NumThreads.isInvalid()) + return nullptr; + return getDerived().RebuildOMPNumThreadsClause( + NumThreads.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *C) { + ExprResult E = getDerived().TransformExpr(C->getSafelen()); + if (E.isInvalid()) + return nullptr; + return getDerived().RebuildOMPSafelenClause( + E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) { + ExprResult E = getDerived().TransformExpr(C->getNumForLoops()); + if (E.isInvalid()) + return 0; + return getDerived().RebuildOMPCollapseClause( + E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); +} + +template <typename Derived> OMPClause * TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *C) { - return getDerived().RebuildOMPDefaultClause(C->getDefaultKind(), - C->getDefaultKindKwLoc(), - C->getLocStart(), - C->getLParenLoc(), - C->getLocEnd()); + return getDerived().RebuildOMPDefaultClause( + C->getDefaultKind(), C->getDefaultKindKwLoc(), C->getLocStart(), + C->getLParenLoc(), C->getLocEnd()); } -template<typename Derived> +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *C) { + return getDerived().RebuildOMPProcBindClause( + C->getProcBindKind(), C->getProcBindKindKwLoc(), C->getLocStart(), + C->getLParenLoc(), C->getLocEnd()); +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPScheduleClause(OMPScheduleClause *C) { + ExprResult E = getDerived().TransformExpr(C->getChunkSize()); + if (E.isInvalid()) + return nullptr; + return getDerived().RebuildOMPScheduleClause( + C->getScheduleKind(), E.get(), C->getLocStart(), C->getLParenLoc(), + C->getScheduleKindLoc(), C->getCommaLoc(), C->getLocEnd()); +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPOrderedClause(OMPOrderedClause *C) { + // No need to rebuild this clause, no template-dependent parameters. + return C; +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPNowaitClause(OMPNowaitClause *C) { + // No need to rebuild this clause, no template-dependent parameters. + return C; +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPUntiedClause(OMPUntiedClause *C) { + // No need to rebuild this clause, no template-dependent parameters. + return C; +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPMergeableClause(OMPMergeableClause *C) { + // No need to rebuild this clause, no template-dependent parameters. + return C; +} + +template <typename Derived> OMPClause * TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) { llvm::SmallVector<Expr *, 16> Vars; Vars.reserve(C->varlist_size()); - for (OMPPrivateClause::varlist_iterator I = C->varlist_begin(), - E = C->varlist_end(); - I != E; ++I) { - ExprResult EVar = getDerived().TransformExpr(cast<Expr>(*I)); + for (auto *VE : C->varlists()) { + ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); if (EVar.isInvalid()) - return 0; - Vars.push_back(EVar.take()); + return nullptr; + Vars.push_back(EVar.get()); } - return getDerived().RebuildOMPPrivateClause(Vars, - C->getLocStart(), - C->getLParenLoc(), - C->getLocEnd()); + return getDerived().RebuildOMPPrivateClause( + Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); } -template<typename Derived> +template <typename Derived> +OMPClause *TreeTransform<Derived>::TransformOMPFirstprivateClause( + OMPFirstprivateClause *C) { + llvm::SmallVector<Expr *, 16> Vars; + Vars.reserve(C->varlist_size()); + for (auto *VE : C->varlists()) { + ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); + if (EVar.isInvalid()) + return nullptr; + Vars.push_back(EVar.get()); + } + return getDerived().RebuildOMPFirstprivateClause( + Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); +} + +template <typename Derived> OMPClause * -TreeTransform<Derived>::TransformOMPFirstprivateClause( - OMPFirstprivateClause *C) { +TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *C) { llvm::SmallVector<Expr *, 16> Vars; Vars.reserve(C->varlist_size()); - for (OMPFirstprivateClause::varlist_iterator I = C->varlist_begin(), - E = C->varlist_end(); - I != E; ++I) { - ExprResult EVar = getDerived().TransformExpr(cast<Expr>(*I)); + for (auto *VE : C->varlists()) { + ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); if (EVar.isInvalid()) - return 0; - Vars.push_back(EVar.take()); + return nullptr; + Vars.push_back(EVar.get()); } - return getDerived().RebuildOMPFirstprivateClause(Vars, - C->getLocStart(), - C->getLParenLoc(), - C->getLocEnd()); + return getDerived().RebuildOMPLastprivateClause( + Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); } -template<typename Derived> +template <typename Derived> OMPClause * TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *C) { llvm::SmallVector<Expr *, 16> Vars; Vars.reserve(C->varlist_size()); - for (OMPSharedClause::varlist_iterator I = C->varlist_begin(), - E = C->varlist_end(); - I != E; ++I) { - ExprResult EVar = getDerived().TransformExpr(cast<Expr>(*I)); + for (auto *VE : C->varlists()) { + ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); + if (EVar.isInvalid()) + return nullptr; + Vars.push_back(EVar.get()); + } + return getDerived().RebuildOMPSharedClause(Vars, C->getLocStart(), + C->getLParenLoc(), C->getLocEnd()); +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPReductionClause(OMPReductionClause *C) { + llvm::SmallVector<Expr *, 16> Vars; + Vars.reserve(C->varlist_size()); + for (auto *VE : C->varlists()) { + ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); + if (EVar.isInvalid()) + return nullptr; + Vars.push_back(EVar.get()); + } + CXXScopeSpec ReductionIdScopeSpec; + ReductionIdScopeSpec.Adopt(C->getQualifierLoc()); + + DeclarationNameInfo NameInfo = C->getNameInfo(); + if (NameInfo.getName()) { + NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); + if (!NameInfo.getName()) + return nullptr; + } + return getDerived().RebuildOMPReductionClause( + Vars, C->getLocStart(), C->getLParenLoc(), C->getColonLoc(), + C->getLocEnd(), ReductionIdScopeSpec, NameInfo); +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPLinearClause(OMPLinearClause *C) { + llvm::SmallVector<Expr *, 16> Vars; + Vars.reserve(C->varlist_size()); + for (auto *VE : C->varlists()) { + ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); if (EVar.isInvalid()) - return 0; - Vars.push_back(EVar.take()); + return nullptr; + Vars.push_back(EVar.get()); } - return getDerived().RebuildOMPSharedClause(Vars, - C->getLocStart(), + ExprResult Step = getDerived().TransformExpr(C->getStep()); + if (Step.isInvalid()) + return nullptr; + return getDerived().RebuildOMPLinearClause(Vars, Step.get(), C->getLocStart(), C->getLParenLoc(), - C->getLocEnd()); + C->getColonLoc(), C->getLocEnd()); +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPAlignedClause(OMPAlignedClause *C) { + llvm::SmallVector<Expr *, 16> Vars; + Vars.reserve(C->varlist_size()); + for (auto *VE : C->varlists()) { + ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); + if (EVar.isInvalid()) + return nullptr; + Vars.push_back(EVar.get()); + } + ExprResult Alignment = getDerived().TransformExpr(C->getAlignment()); + if (Alignment.isInvalid()) + return nullptr; + return getDerived().RebuildOMPAlignedClause( + Vars, Alignment.get(), C->getLocStart(), C->getLParenLoc(), + C->getColonLoc(), C->getLocEnd()); +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPCopyinClause(OMPCopyinClause *C) { + llvm::SmallVector<Expr *, 16> Vars; + Vars.reserve(C->varlist_size()); + for (auto *VE : C->varlists()) { + ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); + if (EVar.isInvalid()) + return nullptr; + Vars.push_back(EVar.get()); + } + return getDerived().RebuildOMPCopyinClause(Vars, C->getLocStart(), + C->getLParenLoc(), C->getLocEnd()); +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPCopyprivateClause(OMPCopyprivateClause *C) { + llvm::SmallVector<Expr *, 16> Vars; + Vars.reserve(C->varlist_size()); + for (auto *VE : C->varlists()) { + ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); + if (EVar.isInvalid()) + return nullptr; + Vars.push_back(EVar.get()); + } + return getDerived().RebuildOMPCopyprivateClause( + Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); +} + +template <typename Derived> +OMPClause *TreeTransform<Derived>::TransformOMPFlushClause(OMPFlushClause *C) { + llvm::SmallVector<Expr *, 16> Vars; + Vars.reserve(C->varlist_size()); + for (auto *VE : C->varlists()) { + ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); + if (EVar.isInvalid()) + return nullptr; + Vars.push_back(EVar.get()); + } + return getDerived().RebuildOMPFlushClause(Vars, C->getLocStart(), + C->getLParenLoc(), C->getLocEnd()); } //===----------------------------------------------------------------------===// @@ -6391,7 +6912,7 @@ TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *C) { template<typename Derived> ExprResult TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) { - return SemaRef.Owned(E); + return E; } template<typename Derived> @@ -6428,10 +6949,10 @@ TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { // FIXME: this is a bit instantiation-specific. SemaRef.MarkDeclRefReferenced(E); - return SemaRef.Owned(E); + return E; } - TemplateArgumentListInfo TransArgs, *TemplateArgs = 0; + TemplateArgumentListInfo TransArgs, *TemplateArgs = nullptr; if (E->hasExplicitTemplateArgs()) { TemplateArgs = &TransArgs; TransArgs.setLAngleLoc(E->getLAngleLoc()); @@ -6449,31 +6970,31 @@ TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { template<typename Derived> ExprResult TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) { - return SemaRef.Owned(E); + return E; } template<typename Derived> ExprResult TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) { - return SemaRef.Owned(E); + return E; } template<typename Derived> ExprResult TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) { - return SemaRef.Owned(E); + return E; } template<typename Derived> ExprResult TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) { - return SemaRef.Owned(E); + return E; } template<typename Derived> ExprResult TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { - return SemaRef.Owned(E); + return E; } template<typename Derived> @@ -6502,19 +7023,19 @@ TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) { return ExprError(); AssocTypes.push_back(AssocType); } else { - AssocTypes.push_back(0); + AssocTypes.push_back(nullptr); } ExprResult AssocExpr = getDerived().TransformExpr(E->getAssocExpr(i)); if (AssocExpr.isInvalid()) return ExprError(); - AssocExprs.push_back(AssocExpr.release()); + AssocExprs.push_back(AssocExpr.get()); } return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(), E->getDefaultLoc(), E->getRParenLoc(), - ControllingExpr.release(), + ControllingExpr.get(), AssocTypes, AssocExprs); } @@ -6527,7 +7048,7 @@ TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) { return ExprError(); if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(), E->getRParen()); @@ -6540,7 +7061,7 @@ template<typename Derived> ExprResult TreeTransform<Derived>::TransformAddressOfOperand(Expr *E) { if (DependentScopeDeclRefExpr *DRE = dyn_cast<DependentScopeDeclRefExpr>(E)) - return getDerived().TransformDependentScopeDeclRefExpr(DRE, true); + return getDerived().TransformDependentScopeDeclRefExpr(DRE, true, nullptr); else return getDerived().TransformExpr(E); } @@ -6557,7 +7078,7 @@ TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) { return ExprError(); if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), E->getOpcode(), @@ -6622,7 +7143,7 @@ TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) { if (!getDerived().AlwaysRebuild() && Type == E->getTypeSourceInfo() && !ExprChanged) - return SemaRef.Owned(E); + return E; // Build a new offsetof expression. return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type, @@ -6635,7 +7156,7 @@ ExprResult TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) { assert(getDerived().AlreadyTransformed(E->getType()) && "opaque value expression requires transformation"); - return SemaRef.Owned(E); + return E; } template<typename Derived> @@ -6655,7 +7176,7 @@ TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) { // expression must have been an lvalue-to-rvalue conversion which we // should reapply. if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject)) - result = SemaRef.checkPseudoObjectRValue(result.take()); + result = SemaRef.checkPseudoObjectRValue(result.get()); return result; } @@ -6672,7 +7193,7 @@ TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr( return ExprError(); if (!getDerived().AlwaysRebuild() && OldT == NewT) - return SemaRef.Owned(E); + return E; return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(), E->getKind(), @@ -6685,12 +7206,26 @@ TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr( EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, Sema::ReuseLambdaContextDecl); - ExprResult SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); - if (SubExpr.isInvalid()) + // Try to recover if we have something like sizeof(T::X) where X is a type. + // Notably, there must be *exactly* one set of parens if X is a type. + TypeSourceInfo *RecoveryTSI = nullptr; + ExprResult SubExpr; + auto *PE = dyn_cast<ParenExpr>(E->getArgumentExpr()); + if (auto *DRE = + PE ? dyn_cast<DependentScopeDeclRefExpr>(PE->getSubExpr()) : nullptr) + SubExpr = getDerived().TransformParenDependentScopeDeclRefExpr( + PE, DRE, false, &RecoveryTSI); + else + SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); + + if (RecoveryTSI) { + return getDerived().RebuildUnaryExprOrTypeTrait( + RecoveryTSI, E->getOperatorLoc(), E->getKind(), E->getSourceRange()); + } else if (SubExpr.isInvalid()) return ExprError(); if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(), E->getOperatorLoc(), @@ -6713,7 +7248,7 @@ TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) { if (!getDerived().AlwaysRebuild() && LHS.get() == E->getLHS() && RHS.get() == E->getRHS()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildArraySubscriptExpr(LHS.get(), /*FIXME:*/E->getLHS()->getLocStart(), @@ -6793,7 +7328,7 @@ TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { // FIXME: this is a bit instantiation-specific. SemaRef.MarkMemberReferenced(E); - return SemaRef.Owned(E); + return E; } TemplateArgumentListInfo TransArgs; @@ -6807,14 +7342,14 @@ TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { } // FIXME: Bogus source location for the operator - SourceLocation FakeOperatorLoc - = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); + SourceLocation FakeOperatorLoc = + SemaRef.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); // FIXME: to do this check properly, we will need to preserve the // first-qualifier-in-scope here, just in case we had a dependent // base (and therefore couldn't do the check) and a // nested-name-qualifier (and therefore could do the lookup). - NamedDecl *FirstQualifierInScope = 0; + NamedDecl *FirstQualifierInScope = nullptr; return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc, E->isArrow(), @@ -6824,7 +7359,7 @@ TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { Member, FoundDecl, (E->hasExplicitTemplateArgs() - ? &TransArgs : 0), + ? &TransArgs : nullptr), FirstQualifierInScope); } @@ -6842,7 +7377,7 @@ TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { if (!getDerived().AlwaysRebuild() && LHS.get() == E->getLHS() && RHS.get() == E->getRHS()) - return SemaRef.Owned(E); + return E; Sema::FPContractStateRAII FPContractState(getSema()); getSema().FPFeatures.fp_contract = E->isFPContractable(); @@ -6875,11 +7410,11 @@ TransformBinaryConditionalOperator(BinaryConditionalOperator *e) { if (!getDerived().AlwaysRebuild() && commonExpr.get() == e->getCommon() && rhs.get() == e->getFalseExpr()) - return SemaRef.Owned(e); + return e; - return getDerived().RebuildConditionalOperator(commonExpr.take(), + return getDerived().RebuildConditionalOperator(commonExpr.get(), e->getQuestionLoc(), - 0, + nullptr, e->getColonLoc(), rhs.get()); } @@ -6903,7 +7438,7 @@ TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) { Cond.get() == E->getCond() && LHS.get() == E->getLHS() && RHS.get() == E->getRHS()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildConditionalOperator(Cond.get(), E->getQuestionLoc(), @@ -6935,7 +7470,7 @@ TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) { if (!getDerived().AlwaysRebuild() && Type == E->getTypeInfoAsWritten() && SubExpr.get() == E->getSubExpr()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(), Type, @@ -6978,11 +7513,11 @@ TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase()) - return SemaRef.Owned(E); + return E; // FIXME: Bad source location - SourceLocation FakeOperatorLoc - = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd()); + SourceLocation FakeOperatorLoc = + SemaRef.getLocForEndOfToken(E->getBase()->getLocEnd()); return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc, E->getAccessorLoc(), E->getAccessor()); @@ -6999,7 +7534,7 @@ TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) { return ExprError(); if (!getDerived().AlwaysRebuild() && !InitChanged) - return SemaRef.Owned(E); + return E; return getDerived().RebuildInitList(E->getLBraceLoc(), Inits, E->getRBraceLoc(), E->getType()); @@ -7037,7 +7572,7 @@ TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { D->getLBracketLoc())); ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); - ArrayExprs.push_back(Index.release()); + ArrayExprs.push_back(Index.get()); continue; } @@ -7059,14 +7594,14 @@ TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || End.get() != E->getArrayRangeEnd(*D); - ArrayExprs.push_back(Start.release()); - ArrayExprs.push_back(End.release()); + ArrayExprs.push_back(Start.get()); + ArrayExprs.push_back(End.get()); } if (!getDerived().AlwaysRebuild() && Init.get() == E->getInit() && !ExprChanged) - return SemaRef.Owned(E); + return E; return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs, E->getEqualOrColonLoc(), @@ -7087,7 +7622,7 @@ TreeTransform<Derived>::TransformImplicitValueInitExpr( if (!getDerived().AlwaysRebuild() && T == E->getType()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildImplicitValueInitExpr(T); } @@ -7106,7 +7641,7 @@ TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) { if (!getDerived().AlwaysRebuild() && TInfo == E->getWrittenTypeInfo() && SubExpr.get() == E->getSubExpr()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(), TInfo, E->getRParenLoc()); @@ -7185,7 +7720,7 @@ TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { Cond.get() == E->getCond() && LHS.get() == E->getLHS() && RHS.get() == E->getRHS()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), Cond.get(), LHS.get(), RHS.get(), @@ -7195,7 +7730,7 @@ TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { template<typename Derived> ExprResult TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) { - return SemaRef.Owned(E); + return E; } template<typename Derived> @@ -7218,9 +7753,8 @@ TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { return ExprError(); // FIXME: Poor location information - SourceLocation FakeLParenLoc - = SemaRef.PP.getLocForEndOfToken( - static_cast<Expr *>(Object.get())->getLocEnd()); + SourceLocation FakeLParenLoc = SemaRef.getLocForEndOfToken( + static_cast<Expr *>(Object.get())->getLocEnd()); // Transform the call arguments. SmallVector<Expr*, 8> Args; @@ -7338,7 +7872,7 @@ TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) { if (!getDerived().AlwaysRebuild() && Type == E->getTypeInfoAsWritten() && SubExpr.get() == E->getSubExpr()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(), E->getStmtClass(), E->getAngleBrackets().getBegin(), @@ -7391,7 +7925,7 @@ TreeTransform<Derived>::TransformCXXFunctionalCastExpr( if (!getDerived().AlwaysRebuild() && Type == E->getTypeInfoAsWritten() && SubExpr.get() == E->getSubExpr()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildCXXFunctionalCastExpr(Type, E->getLParenLoc(), @@ -7410,7 +7944,7 @@ TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { if (!getDerived().AlwaysRebuild() && TInfo == E->getTypeOperandSourceInfo()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildCXXTypeidExpr(E->getType(), E->getLocStart(), @@ -7431,7 +7965,7 @@ TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getExprOperand()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildCXXTypeidExpr(E->getType(), E->getLocStart(), @@ -7450,7 +7984,7 @@ TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) { if (!getDerived().AlwaysRebuild() && TInfo == E->getTypeOperandSourceInfo()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildCXXUuidofExpr(E->getType(), E->getLocStart(), @@ -7466,7 +8000,7 @@ TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) { if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getExprOperand()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildCXXUuidofExpr(E->getType(), E->getLocStart(), @@ -7477,14 +8011,14 @@ TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) { template<typename Derived> ExprResult TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { - return SemaRef.Owned(E); + return E; } template<typename Derived> ExprResult TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( CXXNullPtrLiteralExpr *E) { - return SemaRef.Owned(E); + return E; } template<typename Derived> @@ -7495,7 +8029,7 @@ TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) { if (!getDerived().AlwaysRebuild() && T == E->getType()) { // Make sure that we capture 'this'. getSema().CheckCXXThisCapture(E->getLocStart()); - return SemaRef.Owned(E); + return E; } return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit()); @@ -7510,7 +8044,7 @@ TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) { if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(), E->isThrownVariableInScope()); @@ -7527,7 +8061,7 @@ TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { if (!getDerived().AlwaysRebuild() && Param == E->getParam()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param); } @@ -7542,7 +8076,7 @@ TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) { return ExprError(); if (!getDerived().AlwaysRebuild() && Field == E->getField()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field); } @@ -7557,7 +8091,7 @@ TreeTransform<Derived>::TransformCXXScalarValueInitExpr( if (!getDerived().AlwaysRebuild() && T == E->getTypeSourceInfo()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildCXXScalarValueInitExpr(T, /*FIXME:*/T->getTypeLoc().getEndLoc(), @@ -7590,12 +8124,12 @@ TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { Expr *OldInit = E->getInitializer(); ExprResult NewInit; if (OldInit) - NewInit = getDerived().TransformExpr(OldInit); + NewInit = getDerived().TransformInitializer(OldInit, true); if (NewInit.isInvalid()) return ExprError(); // Transform new operator and delete operator. - FunctionDecl *OperatorNew = 0; + FunctionDecl *OperatorNew = nullptr; if (E->getOperatorNew()) { OperatorNew = cast_or_null<FunctionDecl>( getDerived().TransformDecl(E->getLocStart(), @@ -7604,7 +8138,7 @@ TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { return ExprError(); } - FunctionDecl *OperatorDelete = 0; + FunctionDecl *OperatorDelete = nullptr; if (E->getOperatorDelete()) { OperatorDelete = cast_or_null<FunctionDecl>( getDerived().TransformDecl(E->getLocStart(), @@ -7638,7 +8172,7 @@ TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { } } - return SemaRef.Owned(E); + return E; } QualType AllocType = AllocTypeInfo->getType(); @@ -7653,16 +8187,14 @@ TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { // Do nothing } else if (const ConstantArrayType *ConsArrayT = dyn_cast<ConstantArrayType>(ArrayT)) { - ArraySize - = SemaRef.Owned(IntegerLiteral::Create(SemaRef.Context, - ConsArrayT->getSize(), - SemaRef.Context.getSizeType(), - /*FIXME:*/E->getLocStart())); + ArraySize = IntegerLiteral::Create(SemaRef.Context, ConsArrayT->getSize(), + SemaRef.Context.getSizeType(), + /*FIXME:*/ E->getLocStart()); AllocType = ConsArrayT->getElementType(); } else if (const DependentSizedArrayType *DepArrayT = dyn_cast<DependentSizedArrayType>(ArrayT)) { if (DepArrayT->getSizeExpr()) { - ArraySize = SemaRef.Owned(DepArrayT->getSizeExpr()); + ArraySize = DepArrayT->getSizeExpr(); AllocType = DepArrayT->getElementType(); } } @@ -7678,7 +8210,7 @@ TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { AllocTypeInfo, ArraySize.get(), E->getDirectInitRange(), - NewInit.take()); + NewInit.get()); } template<typename Derived> @@ -7689,7 +8221,7 @@ TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) { return ExprError(); // Transform the delete operator, if known. - FunctionDecl *OperatorDelete = 0; + FunctionDecl *OperatorDelete = nullptr; if (E->getOperatorDelete()) { OperatorDelete = cast_or_null<FunctionDecl>( getDerived().TransformDecl(E->getLocStart(), @@ -7716,7 +8248,7 @@ TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) { } } - return SemaRef.Owned(E); + return E; } return getDerived().RebuildCXXDeleteExpr(E->getLocStart(), @@ -7735,7 +8267,7 @@ TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( ParsedType ObjectTypePtr; bool MayBePseudoDestructor = false; - Base = SemaRef.ActOnStartCXXMemberReference(0, Base.get(), + Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(), E->getOperatorLoc(), E->isArrow()? tok::arrow : tok::period, ObjectTypePtr, @@ -7758,7 +8290,7 @@ TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( if (E->getDestroyedTypeInfo()) { TypeSourceInfo *DestroyedTypeInfo = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(), - ObjectType, 0, SS); + ObjectType, nullptr, SS); if (!DestroyedTypeInfo) return ExprError(); Destroyed = DestroyedTypeInfo; @@ -7772,7 +8304,7 @@ TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(), *E->getDestroyedTypeIdentifier(), E->getDestroyedTypeLoc(), - /*Scope=*/0, + /*Scope=*/nullptr, SS, ObjectTypePtr, false); if (!T) @@ -7783,11 +8315,11 @@ TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( E->getDestroyedTypeLoc()); } - TypeSourceInfo *ScopeTypeInfo = 0; + TypeSourceInfo *ScopeTypeInfo = nullptr; if (E->getScopeTypeInfo()) { CXXScopeSpec EmptySS; ScopeTypeInfo = getDerived().TransformTypeInObjectScope( - E->getScopeTypeInfo(), ObjectType, 0, EmptySS); + E->getScopeTypeInfo(), ObjectType, nullptr, EmptySS); if (!ScopeTypeInfo) return ExprError(); } @@ -7829,9 +8361,8 @@ TreeTransform<Derived>::TransformUnresolvedLookupExpr( // Expand using declarations. if (isa<UsingDecl>(InstD)) { UsingDecl *UD = cast<UsingDecl>(InstD); - for (UsingDecl::shadow_iterator I = UD->shadow_begin(), - E = UD->shadow_end(); I != E; ++I) - R.addDecl(*I); + for (auto *I : UD->shadows()) + R.addDecl(I); continue; } @@ -7890,44 +8421,6 @@ TreeTransform<Derived>::TransformUnresolvedLookupExpr( template<typename Derived> ExprResult -TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { - TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo()); - if (!T) - return ExprError(); - - if (!getDerived().AlwaysRebuild() && - T == E->getQueriedTypeSourceInfo()) - return SemaRef.Owned(E); - - return getDerived().RebuildUnaryTypeTrait(E->getTrait(), - E->getLocStart(), - T, - E->getLocEnd()); -} - -template<typename Derived> -ExprResult -TreeTransform<Derived>::TransformBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) { - TypeSourceInfo *LhsT = getDerived().TransformType(E->getLhsTypeSourceInfo()); - if (!LhsT) - return ExprError(); - - TypeSourceInfo *RhsT = getDerived().TransformType(E->getRhsTypeSourceInfo()); - if (!RhsT) - return ExprError(); - - if (!getDerived().AlwaysRebuild() && - LhsT == E->getLhsTypeSourceInfo() && RhsT == E->getRhsTypeSourceInfo()) - return SemaRef.Owned(E); - - return getDerived().RebuildBinaryTypeTrait(E->getTrait(), - E->getLocStart(), - LhsT, RhsT, - E->getLocEnd()); -} - -template<typename Derived> -ExprResult TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) { bool ArgChanged = false; SmallVector<TypeSourceInfo *, 4> Args; @@ -8053,7 +8546,7 @@ TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) { } if (!getDerived().AlwaysRebuild() && !ArgChanged) - return SemaRef.Owned(E); + return E; return getDerived().RebuildTypeTrait(E->getTrait(), E->getLocStart(), @@ -8070,7 +8563,7 @@ TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { if (!getDerived().AlwaysRebuild() && T == E->getQueriedTypeSourceInfo()) - return SemaRef.Owned(E); + return E; ExprResult SubExpr; { @@ -8080,7 +8573,7 @@ TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { return ExprError(); if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getDimensionExpression()) - return SemaRef.Owned(E); + return E; } return getDerived().RebuildArrayTypeTrait(E->getTrait(), @@ -8101,25 +8594,44 @@ TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) { return ExprError(); if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression()) - return SemaRef.Owned(E); + return E; } return getDerived().RebuildExpressionTrait( E->getTrait(), E->getLocStart(), SubExpr.get(), E->getLocEnd()); } -template<typename Derived> -ExprResult -TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( - DependentScopeDeclRefExpr *E) { - return TransformDependentScopeDeclRefExpr(E, /*IsAddressOfOperand*/false); +template <typename Derived> +ExprResult TreeTransform<Derived>::TransformParenDependentScopeDeclRefExpr( + ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool AddrTaken, + TypeSourceInfo **RecoveryTSI) { + ExprResult NewDRE = getDerived().TransformDependentScopeDeclRefExpr( + DRE, AddrTaken, RecoveryTSI); + + // Propagate both errors and recovered types, which return ExprEmpty. + if (!NewDRE.isUsable()) + return NewDRE; + + // We got an expr, wrap it up in parens. + if (!getDerived().AlwaysRebuild() && NewDRE.get() == DRE) + return PE; + return getDerived().RebuildParenExpr(NewDRE.get(), PE->getLParen(), + PE->getRParen()); +} + +template <typename Derived> +ExprResult TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( + DependentScopeDeclRefExpr *E) { + return TransformDependentScopeDeclRefExpr(E, /*IsAddressOfOperand=*/false, + nullptr); } template<typename Derived> ExprResult TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( DependentScopeDeclRefExpr *E, - bool IsAddressOfOperand) { + bool IsAddressOfOperand, + TypeSourceInfo **RecoveryTSI) { assert(E->getQualifierLoc()); NestedNameSpecifierLoc QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); @@ -8142,13 +8654,11 @@ TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( // Note: it is sufficient to compare the Name component of NameInfo: // if name has not changed, DNLoc has not changed either. NameInfo.getName() == E->getDeclName()) - return SemaRef.Owned(E); + return E; - return getDerived().RebuildDependentScopeDeclRefExpr(QualifierLoc, - TemplateKWLoc, - NameInfo, - /*TemplateArgs*/ 0, - IsAddressOfOperand); + return getDerived().RebuildDependentScopeDeclRefExpr( + QualifierLoc, TemplateKWLoc, NameInfo, /*TemplateArgs=*/nullptr, + IsAddressOfOperand, RecoveryTSI); } TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); @@ -8157,11 +8667,9 @@ TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( TransArgs)) return ExprError(); - return getDerived().RebuildDependentScopeDeclRefExpr(QualifierLoc, - TemplateKWLoc, - NameInfo, - &TransArgs, - IsAddressOfOperand); + return getDerived().RebuildDependentScopeDeclRefExpr( + QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand, + RecoveryTSI); } template<typename Derived> @@ -8202,7 +8710,7 @@ TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { // Mark the constructor as referenced. // FIXME: Instantiation-specific SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor); - return SemaRef.Owned(E); + return E; } return getDerived().RebuildCXXConstructExpr(T, /*FIXME:*/E->getLocStart(), @@ -8210,6 +8718,7 @@ TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { Args, E->hadMultipleCandidates(), E->isListInitialization(), + E->isStdInitListInitialization(), E->requiresZeroInitialization(), E->getConstructionKind(), E->getParenOrBraceRange()); @@ -8323,8 +8832,8 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo(); FunctionProtoTypeLoc OldCallOpFPTL = OldCallOpTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>(); - TypeSourceInfo *NewCallOpTSI = 0; - + TypeSourceInfo *NewCallOpTSI = nullptr; + const bool CallOpWasAlreadyTransformed = getDerived().AlreadyTransformed(OldCallOpTSI->getType()); @@ -8340,7 +8849,7 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { TypeLocBuilder NewCallOpTLBuilder; QualType NewCallOpType = TransformFunctionProtoType(NewCallOpTLBuilder, OldCallOpFPTL, - 0, 0); + nullptr, 0); NewCallOpTSI = NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context, NewCallOpType); } @@ -8353,7 +8862,7 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { FunctionProtoTypeLoc NewCallOpFPTL = NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>(); ParmVarDecl **NewParamDeclArray = NewCallOpFPTL.getParmArray(); - const unsigned NewNumArgs = NewCallOpFPTL.getNumArgs(); + const unsigned NewNumArgs = NewCallOpFPTL.getNumParams(); for (unsigned I = 0; I < NewNumArgs; ++I) { // If this call operator's type does not require transformation, @@ -8416,7 +8925,8 @@ TreeTransform<Derived>::TransformLambdaScope(LambdaExpr *E, bool Invalid = false; // Introduce the context of the call operator. - Sema::ContextRAII SavedContext(getSema(), CallOperator); + Sema::ContextRAII SavedContext(getSema(), CallOperator, + /*NewThisContext*/false); LambdaScopeInfo *const LSI = getSema().getCurLambda(); // Enter the scope of the lambda. @@ -8510,6 +9020,9 @@ TreeTransform<Derived>::TransformLambdaScope(LambdaExpr *E, // Capture the transformed variable. getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind); } + + // FIXME: Retain a pack expansion if RetainExpansion is true. + continue; } @@ -8537,7 +9050,7 @@ TreeTransform<Derived>::TransformLambdaScope(LambdaExpr *E, getSema().PushExpressionEvaluationContext(Sema::PotentiallyEvaluated); if (Invalid) { - getSema().ActOnLambdaError(E->getLocStart(), /*CurScope=*/0, + getSema().ActOnLambdaError(E->getLocStart(), /*CurScope=*/nullptr, /*IsInstantiation=*/true); return ExprError(); } @@ -8545,13 +9058,14 @@ TreeTransform<Derived>::TransformLambdaScope(LambdaExpr *E, // Instantiate the body of the lambda expression. StmtResult Body = getDerived().TransformStmt(E->getBody()); if (Body.isInvalid()) { - getSema().ActOnLambdaError(E->getLocStart(), /*CurScope=*/0, + getSema().ActOnLambdaError(E->getLocStart(), /*CurScope=*/nullptr, /*IsInstantiation=*/true); return ExprError(); } - return getSema().ActOnLambdaExpr(E->getLocStart(), Body.take(), - /*CurScope=*/0, /*IsInstantiation=*/true); + return getSema().ActOnLambdaExpr(E->getLocStart(), Body.get(), + /*CurScope=*/nullptr, + /*IsInstantiation=*/true); } template<typename Derived> @@ -8572,7 +9086,7 @@ TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( if (!getDerived().AlwaysRebuild() && T == E->getTypeSourceInfo() && !ArgumentChanged) - return SemaRef.Owned(E); + return E; // FIXME: we're faking the locations of the commas return getDerived().RebuildCXXUnresolvedConstructExpr(T, @@ -8586,7 +9100,7 @@ ExprResult TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( CXXDependentScopeMemberExpr *E) { // Transform the base of the expression. - ExprResult Base((Expr*) 0); + ExprResult Base((Expr*) nullptr); Expr *OldBase; QualType BaseType; QualType ObjectType; @@ -8599,7 +9113,7 @@ TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( // Start the member reference and compute the object's type. ParsedType ObjectTy; bool MayBePseudoDestructor = false; - Base = SemaRef.ActOnStartCXXMemberReference(0, Base.get(), + Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(), E->getOperatorLoc(), E->isArrow()? tok::arrow : tok::period, ObjectTy, @@ -8610,7 +9124,7 @@ TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( ObjectType = ObjectTy.get(); BaseType = ((Expr*) Base.get())->getType(); } else { - OldBase = 0; + OldBase = nullptr; BaseType = getDerived().TransformType(E->getBaseType()); ObjectType = BaseType->getAs<PointerType>()->getPointeeType(); } @@ -8652,7 +9166,7 @@ TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( QualifierLoc == E->getQualifierLoc() && NameInfo.getName() == E->getMember() && FirstQualifierInScope == E->getFirstQualifierFoundInScope()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), BaseType, @@ -8662,7 +9176,7 @@ TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( TemplateKWLoc, FirstQualifierInScope, NameInfo, - /*TemplateArgs*/ 0); + /*TemplateArgs*/nullptr); } TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); @@ -8686,13 +9200,13 @@ template<typename Derived> ExprResult TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) { // Transform the base of the expression. - ExprResult Base((Expr*) 0); + ExprResult Base((Expr*) nullptr); QualType BaseType; if (!Old->isImplicitAccess()) { Base = getDerived().TransformExpr(Old->getBase()); if (Base.isInvalid()) return ExprError(); - Base = getSema().PerformMemberExprBaseConversion(Base.take(), + Base = getSema().PerformMemberExprBaseConversion(Base.get(), Old->isArrow()); if (Base.isInvalid()) return ExprError(); @@ -8734,9 +9248,8 @@ TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) // Expand using declarations. if (isa<UsingDecl>(InstD)) { UsingDecl *UD = cast<UsingDecl>(InstD); - for (UsingDecl::shadow_iterator I = UD->shadow_begin(), - E = UD->shadow_end(); I != E; ++I) - R.addDecl(*I); + for (auto *I : UD->shadows()) + R.addDecl(I); continue; } @@ -8771,7 +9284,7 @@ TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) // first-qualifier-in-scope here, just in case we had a dependent // base (and therefore couldn't do the check) and a // nested-name-qualifier (and therefore could do the lookup). - NamedDecl *FirstQualifierInScope = 0; + NamedDecl *FirstQualifierInScope = nullptr; return getDerived().RebuildUnresolvedMemberExpr(Base.get(), BaseType, @@ -8782,7 +9295,7 @@ TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) FirstQualifierInScope, R, (Old->hasExplicitTemplateArgs() - ? &TransArgs : 0)); + ? &TransArgs : nullptr)); } template<typename Derived> @@ -8794,7 +9307,7 @@ TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) { return ExprError(); if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get()); } @@ -8807,7 +9320,7 @@ TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) { return ExprError(); if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(), E->getNumExpansions()); @@ -8819,7 +9332,7 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { // If E is not value-dependent, then nothing will change when we transform it. // Note: This is an instantiation-centric view. if (!E->isValueDependent()) - return SemaRef.Owned(E); + return E; // Note: None of the implementations of TryExpandParameterPacks can ever // produce a diagnostic when given only a single unexpanded parameter pack, @@ -8835,7 +9348,7 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { return ExprError(); if (RetainExpansion) - return SemaRef.Owned(E); + return E; NamedDecl *Pack = E->getPack(); if (!ShouldExpand) { @@ -8858,7 +9371,7 @@ ExprResult TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr( SubstNonTypeTemplateParmPackExpr *E) { // Default behavior is to do nothing with this transformation. - return SemaRef.Owned(E); + return E; } template<typename Derived> @@ -8866,14 +9379,14 @@ ExprResult TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr( SubstNonTypeTemplateParmExpr *E) { // Default behavior is to do nothing with this transformation. - return SemaRef.Owned(E); + return E; } template<typename Derived> ExprResult TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) { // Default behavior is to do nothing with this transformation. - return SemaRef.Owned(E); + return E; } template<typename Derived> @@ -8899,7 +9412,7 @@ TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { template<typename Derived> ExprResult TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { - return SemaRef.Owned(E); + return E; } template<typename Derived> @@ -8911,7 +9424,7 @@ TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) { if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get()); } @@ -9014,6 +9527,7 @@ TreeTransform<Derived>::TransformObjCDictionaryLiteral( // If any unexpanded parameter packs remain, we still have a // pack expansion. + // FIXME: Can this really happen? if (Key.get()->containsUnexpandedParameterPack() || Value.get()->containsUnexpandedParameterPack()) Element.EllipsisLoc = OrigElement.EllipsisLoc; @@ -9021,6 +9535,8 @@ TreeTransform<Derived>::TransformObjCDictionaryLiteral( Elements.push_back(Element); } + // FIXME: Retain a pack expansion if RetainExpansion is true. + // We've finished with this pack expansion. continue; } @@ -9066,7 +9582,7 @@ TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { if (!getDerived().AlwaysRebuild() && EncodedTypeInfo == E->getEncodedTypeSourceInfo()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), EncodedTypeInfo, @@ -9098,7 +9614,7 @@ TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { if (!getDerived().AlwaysRebuild() && TSInfo == E->getTypeInfoAsWritten() && Result.get() == E->getSubExpr()) - return SemaRef.Owned(E); + return E; return SemaRef.BuildObjCBridgedCast(E->getLParenLoc(), E->getBridgeKind(), E->getBridgeKeywordLoc(), TSInfo, @@ -9168,13 +9684,13 @@ TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { template<typename Derived> ExprResult TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { - return SemaRef.Owned(E); + return E; } template<typename Derived> ExprResult TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { - return SemaRef.Owned(E); + return E; } template<typename Derived> @@ -9190,7 +9706,7 @@ TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { // If nothing changed, just retain the existing expression. if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(), E->getLocation(), @@ -9203,7 +9719,7 @@ TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { // 'super' and types never change. Property never changes. Just // retain the existing expression. if (!E->isObjectReceiver()) - return SemaRef.Owned(E); + return E; // Transform the base expression. ExprResult Base = getDerived().TransformExpr(E->getBase()); @@ -9215,7 +9731,7 @@ TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { // If nothing changed, just retain the existing expression. if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase()) - return SemaRef.Owned(E); + return E; if (E->isExplicitProperty()) return getDerived().RebuildObjCPropertyRefExpr(Base.get(), @@ -9245,7 +9761,7 @@ TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { // If nothing changed, just retain the existing expression. if (!getDerived().AlwaysRebuild() && Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(), Base.get(), Key.get(), @@ -9264,7 +9780,7 @@ TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) { // If nothing changed, just retain the existing expression. if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(), E->getOpLoc(), @@ -9283,7 +9799,7 @@ TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { if (!getDerived().AlwaysRebuild() && !ArgumentChanged) - return SemaRef.Owned(E); + return E; return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), SubExprs, @@ -9304,7 +9820,7 @@ TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *E) { if (!getDerived().AlwaysRebuild() && Type == E->getTypeSourceInfo() && SrcExpr.get() == E->getSrcExpr()) - return SemaRef.Owned(E); + return E; return getDerived().RebuildConvertVectorExpr(E->getBuiltinLoc(), SrcExpr.get(), Type, @@ -9316,7 +9832,7 @@ ExprResult TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { BlockDecl *oldBlock = E->getBlockDecl(); - SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/0); + SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/nullptr); BlockScopeInfo *blockScope = SemaRef.getCurBlock(); blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic()); @@ -9330,14 +9846,14 @@ TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { if (getDerived().TransformFunctionTypeParams(E->getCaretLocation(), oldBlock->param_begin(), oldBlock->param_size(), - 0, paramTypes, ¶ms)) { - getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/0); + nullptr, paramTypes, ¶ms)) { + getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr); return ExprError(); } const FunctionProtoType *exprFunctionType = E->getFunctionType(); QualType exprResultType = - getDerived().TransformType(exprFunctionType->getResultType()); + getDerived().TransformType(exprFunctionType->getReturnType()); QualType functionType = getDerived().RebuildFunctionProtoType(exprResultType, paramTypes, @@ -9356,7 +9872,7 @@ TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { // Transform the body StmtResult body = getDerived().TransformStmt(E->getBody()); if (body.isInvalid()) { - getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/0); + getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr); return ExprError(); } @@ -9364,9 +9880,8 @@ TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { // In builds with assertions, make sure that we captured everything we // captured before. if (!SemaRef.getDiagnostics().hasErrorOccurred()) { - for (BlockDecl::capture_iterator i = oldBlock->capture_begin(), - e = oldBlock->capture_end(); i != e; ++i) { - VarDecl *oldCapture = i->getVariable(); + for (const auto &I : oldBlock->captures()) { + VarDecl *oldCapture = I.getVariable(); // Ignore parameter packs. if (isa<ParmVarDecl>(oldCapture) && @@ -9383,7 +9898,7 @@ TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { #endif return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(), - /*Scope=*/0); + /*Scope=*/nullptr); } template<typename Derived> @@ -9405,7 +9920,7 @@ TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) { if (!getDerived().AlwaysRebuild() && !ArgumentChanged) - return SemaRef.Owned(E); + return E; return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs, RetTy, E->getOp(), E->getRParenLoc()); @@ -9443,8 +9958,8 @@ QualType TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, QualType ClassType, SourceLocation Sigil) { - return SemaRef.BuildMemberPointerType(PointeeType, ClassType, - Sigil, getDerived().getBaseEntity()); + return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Sigil, + getDerived().getBaseEntity()); } template<typename Derived> @@ -9490,7 +10005,7 @@ TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, const llvm::APInt &Size, unsigned IndexTypeQuals, SourceRange BracketsRange) { - return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, + return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, nullptr, IndexTypeQuals, BracketsRange); } @@ -9500,7 +10015,7 @@ TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, ArrayType::ArraySizeModifier SizeMod, unsigned IndexTypeQuals, SourceRange BracketsRange) { - return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0, + return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, nullptr, IndexTypeQuals, BracketsRange); } @@ -9511,7 +10026,7 @@ TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, Expr *SizeExpr, unsigned IndexTypeQuals, SourceRange BracketsRange) { - return getDerived().RebuildArrayType(ElementType, SizeMod, 0, + return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, SizeExpr, IndexTypeQuals, BracketsRange); } @@ -9523,7 +10038,7 @@ TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, Expr *SizeExpr, unsigned IndexTypeQuals, SourceRange BracketsRange) { - return getDerived().RebuildArrayType(ElementType, SizeMod, 0, + return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, SizeExpr, IndexTypeQuals, BracketsRange); } @@ -9559,7 +10074,7 @@ TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, template<typename Derived> QualType TreeTransform<Derived>::RebuildFunctionProtoType( QualType T, - llvm::MutableArrayRef<QualType> ParamTypes, + MutableArrayRef<QualType> ParamTypes, const FunctionProtoType::ExtProtoInfo &EPI) { return SemaRef.BuildFunctionType(T, ParamTypes, getDerived().getBaseLocation(), @@ -9655,7 +10170,7 @@ TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, TemplateName.setIdentifier(&Name, NameLoc); Sema::TemplateTy Template; SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller. - getSema().ActOnDependentTemplateName(/*Scope=*/0, + getSema().ActOnDependentTemplateName(/*Scope=*/nullptr, SS, TemplateKWLoc, TemplateName, ParsedType::make(ObjectType), /*EnteringContext=*/false, @@ -9675,7 +10190,7 @@ TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, Name.setOperatorFunctionId(NameLoc, Operator, SymbolLocations); SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller. Sema::TemplateTy Template; - getSema().ActOnDependentTemplateName(/*Scope=*/0, + getSema().ActOnDependentTemplateName(/*Scope=*/nullptr, SS, TemplateKWLoc, Name, ParsedType::make(ObjectType), /*EnteringContext=*/false, @@ -9693,6 +10208,24 @@ TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, Expr *Callee = OrigCallee->IgnoreParenCasts(); bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus); + if (First->getObjectKind() == OK_ObjCProperty) { + BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); + if (BinaryOperator::isAssignmentOp(Opc)) + return SemaRef.checkPseudoObjectAssignment(/*Scope=*/nullptr, OpLoc, Opc, + First, Second); + ExprResult Result = SemaRef.CheckPlaceholderExpr(First); + if (Result.isInvalid()) + return ExprError(); + First = Result.get(); + } + + if (Second && Second->getObjectKind() == OK_ObjCProperty) { + ExprResult Result = SemaRef.CheckPlaceholderExpr(Second); + if (Result.isInvalid()) + return ExprError(); + Second = Result.get(); + } + // Determine whether this should be a builtin operation. if (Op == OO_Subscript) { if (!First->getType()->isOverloadableType() && @@ -9702,8 +10235,8 @@ TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, Second, OpLoc); } else if (Op == OO_Arrow) { // -> is never a builtin operation. - return SemaRef.BuildOverloadedArrowExpr(0, First, OpLoc); - } else if (Second == 0 || isPostIncDec) { + return SemaRef.BuildOverloadedArrowExpr(nullptr, First, OpLoc); + } else if (Second == nullptr || isPostIncDec) { if (!First->getType()->isOverloadableType()) { // The argument is not of overloadable type, so try to create a // built-in unary operation. @@ -9733,9 +10266,6 @@ TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) { assert(ULE->requiresADL()); - - // FIXME: Do we have to check - // IsAcceptableNonMemberOperatorCandidate for each of these? Functions.append(ULE->decls_begin(), ULE->decls_end()); } else { // If we've resolved this to a particular non-member function, just call @@ -9748,7 +10278,7 @@ TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, // Add any functions found via argument-dependent lookup. Expr *Args[2] = { First, Second }; - unsigned NumArgs = 1 + (Second != 0); + unsigned NumArgs = 1 + (Second != nullptr); // Create the overloaded operator invocation for unary operators. if (NumArgs == 1 || isPostIncDec) { @@ -9826,26 +10356,43 @@ TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base, return getSema().BuildMemberReferenceExpr(Base, BaseType, OperatorLoc, isArrow, SS, TemplateKWLoc, - /*FIXME: FirstQualifier*/ 0, + /*FIXME: FirstQualifier*/ nullptr, NameInfo, - /*TemplateArgs*/ 0); + /*TemplateArgs*/ nullptr); } template<typename Derived> StmtResult TreeTransform<Derived>::TransformCapturedStmt(CapturedStmt *S) { SourceLocation Loc = S->getLocStart(); - unsigned NumParams = S->getCapturedDecl()->getNumParams(); - getSema().ActOnCapturedRegionStart(Loc, /*CurScope*/0, - S->getCapturedRegionKind(), NumParams); - StmtResult Body = getDerived().TransformStmt(S->getCapturedStmt()); + CapturedDecl *CD = S->getCapturedDecl(); + unsigned NumParams = CD->getNumParams(); + unsigned ContextParamPos = CD->getContextParamPosition(); + SmallVector<Sema::CapturedParamNameType, 4> Params; + for (unsigned I = 0; I < NumParams; ++I) { + if (I != ContextParamPos) { + Params.push_back( + std::make_pair( + CD->getParam(I)->getName(), + getDerived().TransformType(CD->getParam(I)->getType()))); + } else { + Params.push_back(std::make_pair(StringRef(), QualType())); + } + } + getSema().ActOnCapturedRegionStart(Loc, /*CurScope*/nullptr, + S->getCapturedRegionKind(), Params); + StmtResult Body; + { + Sema::CompoundScopeRAII CompoundScope(getSema()); + Body = getDerived().TransformStmt(S->getCapturedStmt()); + } if (Body.isInvalid()) { getSema().ActOnCapturedRegionError(); return StmtError(); } - return getSema().ActOnCapturedRegionEnd(Body.take()); + return getSema().ActOnCapturedRegionEnd(Body.get()); } } // end namespace clang |