From ca0408fb49c1370430672acf2d770b7151cf71de Mon Sep 17 00:00:00 2001 From: John McCall Date: Mon, 23 Aug 2010 06:44:23 +0000 Subject: [PATCH] Sundry incremental steps towards killing off Action. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@111795 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/Parse/Parser.h | 42 ++--- include/clang/Sema/Action.h | 49 +++--- include/clang/Sema/AttributeList.h | 3 +- include/clang/Sema/DeclSpec.h | 9 +- include/clang/Sema/Ownership.h | 194 +++++++++++------------ include/clang/Sema/ParsedTemplate.h | 4 +- include/clang/Sema/Sema.h | 8 +- lib/Parse/ParseDecl.cpp | 10 +- lib/Parse/ParseDeclCXX.cpp | 8 +- lib/Parse/ParseExpr.cpp | 27 ++-- lib/Parse/ParseExprCXX.cpp | 9 +- lib/Parse/ParseInit.cpp | 8 +- lib/Parse/ParseObjc.cpp | 10 +- lib/Parse/ParsePragma.cpp | 2 +- lib/Parse/ParseStmt.cpp | 32 ++-- lib/Parse/ParseTemplate.cpp | 2 +- lib/Sema/SemaCXXCast.cpp | 2 +- lib/Sema/SemaDecl.cpp | 4 +- lib/Sema/SemaDeclCXX.cpp | 20 +-- lib/Sema/SemaExpr.cpp | 8 +- lib/Sema/SemaExprCXX.cpp | 22 +-- lib/Sema/SemaInit.cpp | 23 ++- lib/Sema/SemaOverload.cpp | 2 +- lib/Sema/SemaTemplateInstantiateDecl.cpp | 10 +- lib/Sema/TreeTransform.h | 64 ++++---- 25 files changed, 283 insertions(+), 289 deletions(-) diff --git a/include/clang/Parse/Parser.h b/include/clang/Parse/Parser.h index fd91acff7f..87e0b42a37 100644 --- a/include/clang/Parse/Parser.h +++ b/include/clang/Parse/Parser.h @@ -145,17 +145,17 @@ public: // Type forwarding. All of these are statically 'void*', but they may all be // different actual classes based on the actions in place. - typedef Action::ExprTy ExprTy; - typedef Action::StmtTy StmtTy; + typedef Expr ExprTy; + typedef Stmt StmtTy; typedef Action::DeclGroupPtrTy DeclGroupPtrTy; typedef Action::TypeTy TypeTy; - typedef Action::BaseTy BaseTy; - typedef Action::MemInitTy MemInitTy; - typedef Action::CXXScopeTy CXXScopeTy; - typedef Action::TemplateParamsTy TemplateParamsTy; + typedef CXXBaseSpecifier BaseTy; + typedef CXXBaseOrMemberInitializer MemInitTy; + typedef NestedNameSpecifier CXXScopeTy; + typedef TemplateParameterList TemplateParamsTy; typedef Action::TemplateTy TemplateTy; - typedef llvm::SmallVector TemplateParameterLists; + typedef llvm::SmallVector TemplateParameterLists; typedef Action::ExprResult ExprResult; typedef Action::StmtResult StmtResult; @@ -172,20 +172,20 @@ public: /// Adorns a ExprResult with Actions to make it an OwningExprResult OwningExprResult Owned(ExprResult res) { - return OwningExprResult(Actions, res); + return OwningExprResult(res); } /// Adorns a StmtResult with Actions to make it an OwningStmtResult OwningStmtResult Owned(StmtResult res) { - return OwningStmtResult(Actions, res); + return OwningStmtResult(res); } - OwningExprResult ExprError() { return OwningExprResult(Actions, true); } - OwningStmtResult StmtError() { return OwningStmtResult(Actions, true); } + OwningExprResult ExprError() { return OwningExprResult(true); } + OwningStmtResult StmtError() { return OwningStmtResult(true); } OwningExprResult ExprError(const DiagnosticBuilder &) { return ExprError(); } OwningStmtResult StmtError(const DiagnosticBuilder &) { return StmtError(); } - OwningExprResult ExprEmpty() { return OwningExprResult(Actions, false); } + OwningExprResult ExprEmpty() { return OwningExprResult(false); } // Parsing methods. @@ -949,16 +949,17 @@ private: TypeTy *&CastTy, SourceRange &CastRange); - static const unsigned ExprListSize = 12; - typedef llvm::SmallVector ExprListTy; - typedef llvm::SmallVector CommaLocsTy; + typedef llvm::SmallVector ExprListTy; + typedef llvm::SmallVector CommaLocsTy; /// ParseExpressionList - Used for C/C++ (argument-)expression-list. - bool ParseExpressionList(ExprListTy &Exprs, CommaLocsTy &CommaLocs, - void (Action::*Completer)(Scope *S, void *Data, - ExprTy **Args, + bool ParseExpressionList(llvm::SmallVectorImpl &Exprs, + llvm::SmallVectorImpl &CommaLocs, + void (Action::*Completer)(Scope *S, + Expr *Data, + Expr **Args, unsigned NumArgs) = 0, - void *Data = 0); + Expr *Data = 0); /// ParenParseOption - Control what ParseParenExpression will parse. enum ParenParseOption { @@ -1040,7 +1041,8 @@ private: //===--------------------------------------------------------------------===// // C++ 5.3.4 and 5.3.5: C++ new and delete - bool ParseExpressionListOrTypeId(ExprListTy &Exprs, Declarator &D); + bool ParseExpressionListOrTypeId(llvm::SmallVectorImpl &Exprs, + Declarator &D); void ParseDirectNewDeclarator(Declarator &D); OwningExprResult ParseCXXNewExpression(bool UseGlobal, SourceLocation Start); OwningExprResult ParseCXXDeleteExpression(bool UseGlobal, diff --git a/include/clang/Sema/Action.h b/include/clang/Sema/Action.h index a574333e75..87cafafaad 100644 --- a/include/clang/Sema/Action.h +++ b/include/clang/Sema/Action.h @@ -31,6 +31,7 @@ namespace clang { class CXXScopeSpec; class Declarator; class AttributeList; + class TemplateParameterList; struct FieldDeclarator; // Parse. class Scope; @@ -84,23 +85,23 @@ public: typedef clang::StmtResult StmtResult; typedef clang::TypeResult TypeResult; typedef clang::BaseResult BaseResult; - typedef clang::MemInitResult MemInitResult; typedef clang::DeclResult DeclResult; + typedef clang::MemInitResult MemInitResult; /// Same, but with ownership. - typedef ASTOwningResult<&ActionBase::DeleteExpr> OwningExprResult; - typedef ASTOwningResult<&ActionBase::DeleteStmt> OwningStmtResult; + typedef ASTOwningResult OwningExprResult; + typedef ASTOwningResult OwningStmtResult; // Note that these will replace ExprResult and StmtResult when the transition // is complete. /// Single expressions or statements as arguments. - typedef ASTOwningPtr<&ActionBase::DeleteExpr> ExprArg; - typedef ASTOwningPtr<&ActionBase::DeleteStmt> StmtArg; + typedef ASTOwningPtr ExprArg; + typedef ASTOwningPtr StmtArg; /// Multiple expressions or statements as arguments. - typedef ASTMultiPtr<&ActionBase::DeleteExpr> MultiExprArg; - typedef ASTMultiPtr<&ActionBase::DeleteStmt> MultiStmtArg; - typedef ASTMultiPtr<&ActionBase::DeleteTemplateParams> MultiTemplateParamsArg; + typedef ASTMultiPtr MultiExprArg; + typedef ASTMultiPtr MultiStmtArg; + typedef ASTMultiPtr MultiTemplateParamsArg; class FullExprArg { public: @@ -143,14 +144,14 @@ public: // Utilities for Action implementations to return smart results. - OwningExprResult ExprError() { return OwningExprResult(*this, true); } - OwningStmtResult StmtError() { return OwningStmtResult(*this, true); } + OwningExprResult ExprError() { return OwningExprResult(true); } + OwningStmtResult StmtError() { return OwningStmtResult(true); } OwningExprResult ExprError(const DiagnosticBuilder&) { return ExprError(); } OwningStmtResult StmtError(const DiagnosticBuilder&) { return StmtError(); } - OwningExprResult ExprEmpty() { return OwningExprResult(*this, false); } - OwningStmtResult StmtEmpty() { return OwningStmtResult(*this, false); } + OwningExprResult ExprEmpty() { return OwningExprResult(false); } + OwningStmtResult StmtEmpty() { return OwningStmtResult(false); } /// Statistics. virtual void PrintStats() const {} @@ -709,8 +710,8 @@ public: IdentifierInfo *ClassName, llvm::SmallVectorImpl &Decls) {} virtual Decl *ActOnField(Scope *S, Decl *TagD, - SourceLocation DeclStart, - Declarator &D, ExprTy *BitfieldWidth) { + SourceLocation DeclStart, + Declarator &D, ExprTy *BitfieldWidth) { return 0; } @@ -783,9 +784,7 @@ public: virtual void ActOnForEachDeclStmt(DeclGroupPtrTy Decl) { } - virtual OwningStmtResult ActOnExprStmt(FullExprArg Expr) { - return OwningStmtResult(*this, Expr->release()); - } + virtual OwningStmtResult ActOnExprStmt(FullExprArg Expr) = 0; /// ActOnCaseStmt - Note that this handles the GNU 'case 1 ... 4' extension, /// which can specify an RHS value. The sub-statement of the case is @@ -2576,9 +2575,7 @@ public: SourceLocation LBracLoc, SourceLocation SelectorLoc, SourceLocation RBracLoc, - MultiExprArg Args) { - return OwningExprResult(*this); - } + MultiExprArg Args) = 0; /// \brief Parsed a message send to a class. /// @@ -2595,9 +2592,7 @@ public: SourceLocation LBracLoc, SourceLocation SelectorLoc, SourceLocation RBracLoc, - MultiExprArg Args) { - return OwningExprResult(*this); - } + MultiExprArg Args) = 0; /// \brief Parsed a message send to an object instance. /// @@ -2614,9 +2609,7 @@ public: SourceLocation LBracLoc, SourceLocation SelectorLoc, SourceLocation RBracLoc, - MultiExprArg Args) { - return OwningExprResult(*this); - } + MultiExprArg Args) = 0; virtual Decl *ActOnForwardClassDeclaration( SourceLocation AtClassLoc, @@ -2847,8 +2840,8 @@ public: /// \param Args the arguments to the function call (so far). /// /// \param NumArgs the number of arguments in \p Args. - virtual void CodeCompleteCall(Scope *S, ExprTy *Fn, - ExprTy **Args, unsigned NumArgs) { } + virtual void CodeCompleteCall(Scope *S, Expr *Fn, + Expr **Args, unsigned NumArgs) { } /// \brief Code completion for the initializer of a variable declaration. /// diff --git a/include/clang/Sema/AttributeList.h b/include/clang/Sema/AttributeList.h index dcb8d1fd67..c791502bd4 100644 --- a/include/clang/Sema/AttributeList.h +++ b/include/clang/Sema/AttributeList.h @@ -22,6 +22,7 @@ namespace clang { class IdentifierInfo; class Action; + class Expr; /// AttributeList - Represents GCC's __attribute__ declaration. There are /// 4 forms of this construct...they are: @@ -49,7 +50,7 @@ public: AttributeList(IdentifierInfo *AttrName, SourceLocation AttrLoc, IdentifierInfo *ScopeName, SourceLocation ScopeLoc, IdentifierInfo *ParmName, SourceLocation ParmLoc, - ActionBase::ExprTy **args, unsigned numargs, + Expr **args, unsigned numargs, AttributeList *Next, bool declspec = false, bool cxx0x = false); ~AttributeList(); diff --git a/include/clang/Sema/DeclSpec.h b/include/clang/Sema/DeclSpec.h index 3ae23d44b6..993ba2cf4a 100644 --- a/include/clang/Sema/DeclSpec.h +++ b/include/clang/Sema/DeclSpec.h @@ -30,6 +30,7 @@ namespace clang { class LangOptions; class Diagnostic; class IdentifierInfo; + class NestedNameSpecifier; class Preprocessor; class Declarator; struct TemplateIdAnnotation; @@ -47,7 +48,7 @@ namespace clang { /// The actual scope is described by getScopeRep(). class CXXScopeSpec { SourceRange Range; - void *ScopeRep; + NestedNameSpecifier *ScopeRep; public: CXXScopeSpec() : Range(), ScopeRep() { } @@ -59,7 +60,7 @@ public: SourceLocation getBeginLoc() const { return Range.getBegin(); } SourceLocation getEndLoc() const { return Range.getEnd(); } - ActionBase::CXXScopeTy *getScopeRep() const { return ScopeRep; } + NestedNameSpecifier *getScopeRep() const { return ScopeRep; } void setScopeRep(ActionBase::CXXScopeTy *S) { ScopeRep = S; } /// No scope specifier. @@ -799,7 +800,7 @@ struct DeclaratorChunk { /// This is the size of the array, or null if [] or [*] was specified. /// Since the parser is multi-purpose, and we don't want to impose a root /// expression class on all clients, NumElts is untyped. - ActionBase::ExprTy *NumElts; + Expr *NumElts; void destroy() {} }; @@ -1010,7 +1011,7 @@ struct DeclaratorChunk { /// getArray - Return a DeclaratorChunk for an array. /// static DeclaratorChunk getArray(unsigned TypeQuals, bool isStatic, - bool isStar, void *NumElts, + bool isStar, Expr *NumElts, SourceLocation LBLoc, SourceLocation RBLoc) { DeclaratorChunk I; I.Kind = Array; diff --git a/include/clang/Sema/Ownership.h b/include/clang/Sema/Ownership.h index eceac5e43c..1877ddda40 100644 --- a/include/clang/Sema/Ownership.h +++ b/include/clang/Sema/Ownership.h @@ -23,7 +23,14 @@ namespace clang { class ActionBase; + class Attr; + class CXXBaseOrMemberInitializer; + class CXXBaseSpecifier; class Decl; + class Expr; + class NestedNameSpecifier; + class Stmt; + class TemplateParameterList; /// OpaquePtr - This is a very simple POD type that wraps a pointer that the /// Parser doesn't know about but that Sema or another client does. The UID @@ -186,7 +193,7 @@ namespace clang { // Determines whether the low bit of the result pointer for the // given UID is always zero. If so, ActionResult will use that bit // for it's "invalid" flag. - template + template struct IsResultPtrLowBitFree { static const bool value = false; }; @@ -202,13 +209,13 @@ namespace clang { // what types are required to be identical for the actions. typedef OpaquePtr<1> DeclGroupPtrTy; typedef OpaquePtr<2> TemplateTy; - typedef void AttrTy; - typedef void BaseTy; - typedef void MemInitTy; - typedef void ExprTy; - typedef void StmtTy; - typedef void TemplateParamsTy; - typedef void CXXScopeTy; + typedef Attr AttrTy; + typedef CXXBaseSpecifier BaseTy; + typedef CXXBaseOrMemberInitializer MemInitTy; + typedef Expr ExprTy; + typedef Stmt StmtTy; + typedef TemplateParameterList TemplateParamsTy; + typedef NestedNameSpecifier CXXScopeTy; typedef void TypeTy; // FIXME: Change TypeTy to use OpaquePtr. /// ActionResult - This structure is used while parsing/acting on @@ -216,19 +223,21 @@ namespace clang { /// the action, plus a sense of whether or not it is valid. /// When CompressInvalid is true, the "invalid" flag will be /// stored in the low bit of the Val pointer. - template::value> + template::value> class ActionResult { PtrTy Val; bool Invalid; public: ActionResult(bool Invalid = false) : Val(PtrTy()), Invalid(Invalid) {} - template - ActionResult(ActualExprTy val) : Val(val), Invalid(false) {} + ActionResult(PtrTy val) : Val(val), Invalid(false) {} ActionResult(const DiagnosticBuilder &) : Val(PtrTy()), Invalid(true) {} + // These two overloads prevent void* -> bool conversions. + ActionResult(const void *); + ActionResult(volatile void *); + PtrTy get() const { return Val; } void set(PtrTy V) { Val = V; } bool isInvalid() const { return Invalid; } @@ -242,8 +251,8 @@ namespace clang { // This ActionResult partial specialization places the "invalid" // flag into the low bit of the pointer. - template - class ActionResult { + template + class ActionResult { // A pointer whose low bit is 1 if this result is invalid, 0 // otherwise. uintptr_t PtrWithInvalid; @@ -252,20 +261,16 @@ namespace clang { ActionResult(bool Invalid = false) : PtrWithInvalid(static_cast(Invalid)) { } - template - ActionResult(ActualExprTy *val) { - PtrTy V(val); - void *VP = PtrTraits::getAsVoidPointer(V); - PtrWithInvalid = reinterpret_cast(VP); - assert((PtrWithInvalid & 0x01) == 0 && "Badly aligned pointer"); - } - ActionResult(PtrTy V) { void *VP = PtrTraits::getAsVoidPointer(V); PtrWithInvalid = reinterpret_cast(VP); assert((PtrWithInvalid & 0x01) == 0 && "Badly aligned pointer"); } + // These two overloads prevent void* -> bool conversions. + ActionResult(const void *); + ActionResult(volatile void *); + ActionResult(const DiagnosticBuilder &) : PtrWithInvalid(0x01) { } PtrTy get() const { @@ -298,80 +303,68 @@ namespace clang { virtual void DeleteTemplateParams(TemplateParamsTy *P) {} }; - /// ASTDestroyer - The type of an AST node destruction function pointer. - typedef void (ActionBase::*ASTDestroyer)(void *); - - /// For the transition phase: translate from an ASTDestroyer to its - /// ActionResult UID. - template struct DestroyerToUID; - template <> struct DestroyerToUID<&ActionBase::DeleteExpr> { - static const unsigned UID = 0; - }; - template <> struct DestroyerToUID<&ActionBase::DeleteStmt> { - static const unsigned UID = 1; - }; /// ASTOwningResult - A moveable smart pointer for AST nodes that also /// has an extra flag to indicate an additional success status. - template class ASTOwningResult; + template class ASTOwningResult; /// ASTMultiPtr - A moveable smart pointer to multiple AST nodes. Only owns /// the individual pointers, not the array holding them. - template class ASTMultiPtr; + template class ASTMultiPtr; /// Kept only as a type-safe wrapper for a void pointer. - template - class ASTOwningPtr { - void *Node; + template class ASTOwningPtr { + PtrTy Node; public: explicit ASTOwningPtr(ActionBase &) : Node(0) {} - ASTOwningPtr(ActionBase &, void *node) : Node(node) {} + ASTOwningPtr(ActionBase &, PtrTy node) : Node(node) {} + // Normal copying operators are defined implicitly. - ASTOwningPtr(const ASTOwningResult &o); + ASTOwningPtr(const ASTOwningResult &o); - ASTOwningPtr & operator =(void *raw) { + ASTOwningPtr & operator =(PtrTy raw) { Node = raw; return *this; } /// Access to the raw pointer. - void * get() const { return Node; } + PtrTy get() const { return Node; } /// Release the raw pointer. - void * take() { - return Node; - } + PtrTy take() { return Node; } /// Take outside ownership of the raw pointer and cast it down. - template - T *takeAs() { + template T *takeAs() { return static_cast(Node); } /// Alias for interface familiarity with unique_ptr. - void * release() { + PtrTy release() { return take(); } }; - template - class ASTOwningResult { + template class ASTOwningResult { public: - typedef ActionBase::ActionResult::UID> DumbResult; + typedef ActionBase::ActionResult DumbResult; private: DumbResult Result; public: - explicit ASTOwningResult(ActionBase &actions, bool invalid = false) + explicit ASTOwningResult(bool invalid = false) : Result(invalid) { } - ASTOwningResult(ActionBase &actions, void *node) : Result(node) { } - ASTOwningResult(ActionBase &actions, const DumbResult &res) : Result(res) { } + explicit ASTOwningResult(PtrTy node) : Result(node) { } + explicit ASTOwningResult(const DumbResult &res) : Result(res) { } // Normal copying semantics are defined implicitly. - ASTOwningResult(const ASTOwningPtr &o) : Result(o.get()) { } + ASTOwningResult(const ASTOwningPtr &o) : Result(o.get()) { } + + // These two overloads prevent void* -> bool conversions. + explicit ASTOwningResult(const void *); + explicit ASTOwningResult(volatile void *); /// Assignment from a raw pointer. Takes ownership - beware! - ASTOwningResult & operator =(void *raw) { + ASTOwningResult & operator =(PtrTy raw) { Result = raw; return *this; } @@ -383,7 +376,7 @@ namespace clang { } /// Access to the raw pointer. - void * get() const { return Result.get(); } + PtrTy get() const { return Result.get(); } bool isInvalid() const { return Result.isInvalid(); } @@ -392,7 +385,7 @@ namespace clang { bool isUsable() const { return !Result.isInvalid() && get(); } /// Take outside ownership of the raw pointer. - void * take() { + PtrTy take() { return Result.get(); } @@ -403,32 +396,32 @@ namespace clang { } /// Alias for interface familiarity with unique_ptr. - void * release() { return take(); } + PtrTy release() { return take(); } /// Pass ownership to a classical ActionResult. DumbResult result() { return Result; } }; - template + template class ASTMultiPtr { - void **Nodes; + PtrTy *Nodes; unsigned Count; public: // Normal copying implicitly defined explicit ASTMultiPtr(ActionBase &) : Nodes(0), Count(0) {} - ASTMultiPtr(ActionBase &, void **nodes, unsigned count) + ASTMultiPtr(ActionBase &, PtrTy *nodes, unsigned count) : Nodes(nodes), Count(count) {} // Fake mover in Parse/AstGuard.h needs this: - ASTMultiPtr(void **nodes, unsigned count) : Nodes(nodes), Count(count) {} + ASTMultiPtr(PtrTy *nodes, unsigned count) : Nodes(nodes), Count(count) {} /// Access to the raw pointers. - void ** get() const { return Nodes; } + PtrTy *get() const { return Nodes; } /// Access to the count. unsigned size() const { return Count; } - void ** release() { + PtrTy *release() { return Nodes; } }; @@ -472,8 +465,8 @@ namespace clang { }; /// \brief A small vector that owns a set of AST nodes. - template - class ASTOwningVector : public llvm::SmallVector { + template + class ASTOwningVector : public llvm::SmallVector { ASTOwningVector(ASTOwningVector &); // do not implement ASTOwningVector &operator=(ASTOwningVector &); // do not implement @@ -481,60 +474,67 @@ namespace clang { explicit ASTOwningVector(ActionBase &Actions) { } - void **take() { + PtrTy *take() { return &this->front(); } - template T **takeAs() { return (T**)take(); } + template T **takeAs() { return reinterpret_cast(take()); } }; /// A SmallVector of statements, with stack size 32 (as that is the only one /// used.) - typedef ASTOwningVector<&ActionBase::DeleteStmt, 32> StmtVector; + typedef ASTOwningVector StmtVector; /// A SmallVector of expressions, with stack size 12 (the maximum used.) - typedef ASTOwningVector<&ActionBase::DeleteExpr, 12> ExprVector; + typedef ASTOwningVector ExprVector; - template inline - ASTMultiPtr move_arg(ASTOwningVector &vec) { - return ASTMultiPtr(vec.take(), vec.size()); + template inline + ASTMultiPtr move_arg(ASTOwningVector &vec) { + return ASTMultiPtr(vec.take(), vec.size()); } - template inline - ASTOwningPtr::ASTOwningPtr(const ASTOwningResult &o) + template inline + ASTOwningPtr::ASTOwningPtr(const ASTOwningResult &o) : Node(o.get()) { } // These versions are hopefully no-ops. - template inline - ASTOwningResult& move(ASTOwningResult &ptr) { + template inline + ASTOwningResult& move(ASTOwningResult &ptr) { return ptr; } - template inline - ASTOwningPtr& move(ASTOwningPtr &ptr) { + template inline + ASTOwningPtr& move(ASTOwningPtr &ptr) { return ptr; } - template inline - ASTMultiPtr& move(ASTMultiPtr &ptr) { + template inline + ASTMultiPtr& move(ASTMultiPtr &ptr) { return ptr; } // We can re-use the low bit of expression, statement, base, and // member-initializer pointers for the "invalid" flag of // ActionResult. - template<> struct IsResultPtrLowBitFree<0> { static const bool value = true;}; - template<> struct IsResultPtrLowBitFree<1> { static const bool value = true;}; - template<> struct IsResultPtrLowBitFree<3> { static const bool value = true;}; - template<> struct IsResultPtrLowBitFree<4> { static const bool value = true;}; - template<> struct IsResultPtrLowBitFree<5> { static const bool value = true;}; - - typedef ActionBase::ActionResult<0> ExprResult; - typedef ActionBase::ActionResult<1> StmtResult; - typedef ActionBase::ActionResult<2> TypeResult; - typedef ActionBase::ActionResult<3> BaseResult; - typedef ActionBase::ActionResult<4> MemInitResult; - - typedef ActionBase::ActionResult<5, Decl*> DeclResult; + template<> struct IsResultPtrLowBitFree { + static const bool value = true; + }; + template<> struct IsResultPtrLowBitFree { + static const bool value = true; + }; + template<> struct IsResultPtrLowBitFree { + static const bool value = true; + }; + template<> struct IsResultPtrLowBitFree { + static const bool value = true; + }; + + typedef ActionBase::ActionResult ExprResult; + typedef ActionBase::ActionResult StmtResult; + typedef ActionBase::ActionResult TypeResult; + typedef ActionBase::ActionResult BaseResult; + typedef ActionBase::ActionResult MemInitResult; + + typedef ActionBase::ActionResult DeclResult; } #endif diff --git a/include/clang/Sema/ParsedTemplate.h b/include/clang/Sema/ParsedTemplate.h index 8a3a96136e..c420404c90 100644 --- a/include/clang/Sema/ParsedTemplate.h +++ b/include/clang/Sema/ParsedTemplate.h @@ -70,9 +70,9 @@ namespace clang { } /// \brief Retrieve the non-type template argument's expression. - ActionBase::ExprTy *getAsExpr() const { + Expr *getAsExpr() const { assert(Kind == NonType && "Not a non-type template argument"); - return Arg; + return static_cast(Arg); } /// \brief Retrieve the template template argument's template name. diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h index 8a7ebf17f9..0bd672f5d1 100644 --- a/include/clang/Sema/Sema.h +++ b/include/clang/Sema/Sema.h @@ -688,17 +688,17 @@ public: OwningExprResult Owned(Expr* E) { assert(!E || E->isRetained()); - return OwningExprResult(*this, E); + return OwningExprResult(E); } OwningExprResult Owned(ExprResult R) { if (R.isInvalid()) return ExprError(); assert(!R.get() || ((Expr*) R.get())->isRetained()); - return OwningExprResult(*this, R.get()); + return OwningExprResult(R.get()); } OwningStmtResult Owned(Stmt* S) { assert(!S || S->isRetained()); - return OwningStmtResult(*this, S); + return OwningStmtResult(S); } virtual void ActOnEndOfTranslationUnit(); @@ -2398,7 +2398,7 @@ public: bool CompleteConstructorCall(CXXConstructorDecl *Constructor, MultiExprArg ArgsPtr, SourceLocation Loc, - ASTOwningVector<&ActionBase::DeleteExpr> &ConvertedArgs); + ASTOwningVector &ConvertedArgs); virtual TypeTy *getDestructorName(SourceLocation TildeLoc, IdentifierInfo &II, SourceLocation NameLoc, diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp index 2113ac4428..8a548cf517 100644 --- a/lib/Parse/ParseDecl.cpp +++ b/lib/Parse/ParseDecl.cpp @@ -258,7 +258,7 @@ AttributeList* Parser::ParseMicrosoftDeclSpec(AttributeList *CurrAttr) { // correctly. OwningExprResult ArgExpr(ParseAssignmentExpression()); if (!ArgExpr.isInvalid()) { - ExprTy* ExprList = ArgExpr.take(); + Expr *ExprList = ArgExpr.take(); CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, SourceLocation(), &ExprList, 1, CurrAttr, true); @@ -900,7 +900,7 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS, goto DoneWithDeclSpec; CXXScopeSpec SS; - SS.setScopeRep(Tok.getAnnotationValue()); + SS.setScopeRep((NestedNameSpecifier*) Tok.getAnnotationValue()); SS.setRange(Tok.getAnnotationRange()); // We are looking for a qualified typename. @@ -2052,7 +2052,7 @@ void Parser::ParseEnumBody(SourceLocation StartLoc, Decl *EnumDecl) { SourceLocation IdentLoc = ConsumeToken(); SourceLocation EqualLoc; - OwningExprResult AssignedVal(Actions); + OwningExprResult AssignedVal; if (Tok.is(tok::equal)) { EqualLoc = ConsumeToken(); AssignedVal = ParseConstantExpression(); @@ -3283,7 +3283,7 @@ void Parser::ParseBracketDeclarator(Declarator &D) { } // Remember that we parsed the empty array type. - OwningExprResult NumElements(Actions); + OwningExprResult NumElements; D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, 0, StartLoc, EndLoc), EndLoc); @@ -3329,7 +3329,7 @@ void Parser::ParseBracketDeclarator(Declarator &D) { // Handle "direct-declarator [ type-qual-list[opt] * ]". bool isStar = false; - OwningExprResult NumElements(Actions); + OwningExprResult NumElements; // Handle the case where we have '[*]' as the array size. However, a leading // star could be the start of an expression, for example 'X[*p + 4]'. Verify diff --git a/lib/Parse/ParseDeclCXX.cpp b/lib/Parse/ParseDeclCXX.cpp index 1673aa8d11..3687f54f03 100644 --- a/lib/Parse/ParseDeclCXX.cpp +++ b/lib/Parse/ParseDeclCXX.cpp @@ -1070,7 +1070,7 @@ void Parser::ParseBaseClause(Decl *ClassDecl) { ConsumeToken(); // Build up an array of parsed base specifiers. - llvm::SmallVector BaseInfo; + llvm::SmallVector BaseInfo; while (true) { // Parse a base-specifier. @@ -1406,8 +1406,8 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, // member-declarator-list ',' member-declarator llvm::SmallVector DeclsInGroup; - OwningExprResult BitfieldSize(Actions); - OwningExprResult Init(Actions); + OwningExprResult BitfieldSize; + OwningExprResult Init; bool Deleted = false; while (1) { @@ -1706,7 +1706,7 @@ void Parser::ParseConstructorInitializer(Decl *ConstructorDecl) { SourceLocation ColonLoc = ConsumeToken(); - llvm::SmallVector MemInitializers; + llvm::SmallVector MemInitializers; bool AnyErrors = false; do { diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp index 21033b4d19..f7b03f229e 100644 --- a/lib/Parse/ParseExpr.cpp +++ b/lib/Parse/ParseExpr.cpp @@ -200,7 +200,7 @@ Parser::ParseExpressionWithLeadingAt(SourceLocation AtLoc) { /// process of disambiguating between an expression and a declaration. Parser::OwningExprResult Parser::ParseExpressionWithLeadingExtension(SourceLocation ExtLoc) { - OwningExprResult LHS(Actions, true); + OwningExprResult LHS(true); { // Silence extension warnings in the sub-expression ExtensionRAIIObject O(Diags); @@ -290,7 +290,7 @@ Parser::ParseRHSOfBinaryExpression(OwningExprResult LHS, prec::Level MinPrec) { ConsumeToken(); // Special case handling for the ternary operator. - OwningExprResult TernaryMiddle(Actions, true); + OwningExprResult TernaryMiddle(true); if (NextTokPrec == prec::Conditional) { if (Tok.isNot(tok::colon)) { // Don't parse FOO:BAR as if it were a typo for FOO::BAR. @@ -357,7 +357,7 @@ Parser::ParseRHSOfBinaryExpression(OwningExprResult LHS, prec::Level MinPrec) { // Therefore we need some special-casing here. // Also note that the third operand of the conditional operator is // an assignment-expression in C++. - OwningExprResult RHS(Actions); + OwningExprResult RHS; if (getLang().CPlusPlus && NextTokPrec <= prec::Conditional) RHS = ParseAssignmentExpression(); else @@ -549,7 +549,7 @@ Parser::OwningExprResult Parser::ParseCastExpression(bool isUnaryExpression, bool isAddressOfOperand, bool &NotCastExpr, TypeTy *TypeOfCast) { - OwningExprResult Res(Actions); + OwningExprResult Res; tok::TokenKind SavedKind = Tok.getKind(); NotCastExpr = false; @@ -1127,7 +1127,7 @@ Parser::ParseExprAfterTypeofSizeofAlignof(const Token &OpTok, OpTok.is(tok::kw___alignof) || OpTok.is(tok::kw_alignof)) && "Not a typeof/sizeof/alignof expression!"); - OwningExprResult Operand(Actions); + OwningExprResult Operand; // If the operand doesn't start with an '(', it must be an expression. if (Tok.isNot(tok::l_paren)) { @@ -1241,7 +1241,7 @@ Parser::OwningExprResult Parser::ParseSizeofAlignofExpression() { /// [GNU] offsetof-member-designator '[' expression ']' /// Parser::OwningExprResult Parser::ParseBuiltinPrimaryExpression() { - OwningExprResult Res(Actions); + OwningExprResult Res; const IdentifierInfo *BuiltinII = Tok.getIdentifierInfo(); tok::TokenKind T = Tok.getKind(); @@ -1428,7 +1428,7 @@ Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr, assert(Tok.is(tok::l_paren) && "Not a paren expr!"); GreaterThanIsOperatorScope G(GreaterThanIsOperator, true); SourceLocation OpenLoc = ConsumeParen(); - OwningExprResult Result(Actions, true); + OwningExprResult Result(true); bool isAmbiguousTypeId; CastTy = 0; @@ -1479,7 +1479,7 @@ Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr, // Note that this doesn't parse the subsequent cast-expression, it just // returns the parsed type to the callee. if (stopIfCastExpr) - return OwningExprResult(Actions); + return OwningExprResult(); // Reject the cast of super idiom in ObjC. if (Tok.is(tok::identifier) && getLang().ObjC1 && @@ -1585,12 +1585,13 @@ Parser::OwningExprResult Parser::ParseStringLiteralExpression() { /// [C++] assignment-expression /// [C++] expression-list , assignment-expression /// -bool Parser::ParseExpressionList(ExprListTy &Exprs, CommaLocsTy &CommaLocs, +bool Parser::ParseExpressionList(llvm::SmallVectorImpl &Exprs, + llvm::SmallVectorImpl &CommaLocs, void (Action::*Completer)(Scope *S, - void *Data, - ExprTy **Args, + Expr *Data, + Expr **Args, unsigned NumArgs), - void *Data) { + Expr *Data) { while (1) { if (Tok.is(tok::code_completion)) { if (Completer) @@ -1723,7 +1724,7 @@ Parser::OwningExprResult Parser::ParseBlockLiteralExpression() { } - OwningExprResult Result(Actions, true); + OwningExprResult Result(true); if (!Tok.is(tok::l_brace)) { // Saw something like: ^expr Diag(Tok, diag::err_expected_expression); diff --git a/lib/Parse/ParseExprCXX.cpp b/lib/Parse/ParseExprCXX.cpp index 55d2d3bfac..606eb4c1b4 100644 --- a/lib/Parse/ParseExprCXX.cpp +++ b/lib/Parse/ParseExprCXX.cpp @@ -64,7 +64,7 @@ bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS, "Call sites of this function should be guarded by checking for C++"); if (Tok.is(tok::annot_cxxscope)) { - SS.setScopeRep(Tok.getAnnotationValue()); + SS.setScopeRep(static_cast(Tok.getAnnotationValue())); SS.setRange(Tok.getAnnotationRange()); ConsumeToken(); return false; @@ -507,7 +507,7 @@ Parser::OwningExprResult Parser::ParseCXXTypeid() { "typeid")) return ExprError(); - OwningExprResult Result(Actions); + OwningExprResult Result; if (isTypeIdInParens()) { TypeResult Ty = ParseTypeName(); @@ -1698,7 +1698,8 @@ void Parser::ParseDirectNewDeclarator(Declarator &D) { /// new-placement: /// '(' expression-list ')' /// -bool Parser::ParseExpressionListOrTypeId(ExprListTy &PlacementArgs, +bool Parser::ParseExpressionListOrTypeId( + llvm::SmallVectorImpl &PlacementArgs, Declarator &D) { // The '(' was already consumed. if (isTypeIdInParens()) { @@ -1809,7 +1810,7 @@ Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType, assert(ExprType == CastExpr && "Compound literals are not ambiguous!"); assert(isTypeIdInParens() && "Not a type-id!"); - OwningExprResult Result(Actions, true); + OwningExprResult Result(true); CastTy = 0; // We need to disambiguate a very ugly part of the C++ syntax: diff --git a/lib/Parse/ParseInit.cpp b/lib/Parse/ParseInit.cpp index 138058545f..52b6e3c992 100644 --- a/lib/Parse/ParseInit.cpp +++ b/lib/Parse/ParseInit.cpp @@ -137,7 +137,7 @@ Parser::OwningExprResult Parser::ParseInitializerWithPotentialDesignator() { // [4][foo bar] -> obsolete GNU designation with objc message send. // SourceLocation StartLoc = ConsumeBracket(); - OwningExprResult Idx(Actions); + OwningExprResult Idx; // If Objective-C is enabled and this is a typename (class message // send) or send to 'super', parse this as a message send @@ -167,7 +167,7 @@ Parser::OwningExprResult Parser::ParseInitializerWithPotentialDesignator() { CheckArrayDesignatorSyntax(*this, StartLoc, Desig); return ParseAssignmentExprWithObjCMessageExprStart(StartLoc, SourceLocation(), - TypeOrExpr, + TypeOrExpr, ExprArg(Actions)); } @@ -175,7 +175,7 @@ Parser::OwningExprResult Parser::ParseInitializerWithPotentialDesignator() { // whether we have a message send or an array designator; just // adopt the expression for further analysis below. // FIXME: potentially-potentially evaluated expression above? - Idx = OwningExprResult(Actions, TypeOrExpr); + Idx = OwningExprResult(static_cast(TypeOrExpr)); } else if (getLang().ObjC1 && Tok.is(tok::identifier)) { IdentifierInfo *II = Tok.getIdentifierInfo(); SourceLocation IILoc = Tok.getLocation(); @@ -330,7 +330,7 @@ Parser::OwningExprResult Parser::ParseBraceInitializer() { // If we know that this cannot be a designation, just parse the nested // initializer directly. - OwningExprResult SubElt(Actions); + OwningExprResult SubElt; if (MayBeDesignationStart(Tok.getKind(), PP)) SubElt = ParseInitializerWithPotentialDesignator(); else diff --git a/lib/Parse/ParseObjc.cpp b/lib/Parse/ParseObjc.cpp index 5861d95fc5..1b456edeec 100644 --- a/lib/Parse/ParseObjc.cpp +++ b/lib/Parse/ParseObjc.cpp @@ -1458,7 +1458,7 @@ Decl *Parser::ParseObjCPropertyDynamic(SourceLocation atLoc) { /// throw expression[opt]; /// Parser::OwningStmtResult Parser::ParseObjCThrowStmt(SourceLocation atLoc) { - OwningExprResult Res(Actions); + OwningExprResult Res; ConsumeToken(); // consume throw if (Tok.isNot(tok::semi)) { Res = ParseExpression(); @@ -1529,7 +1529,7 @@ Parser::OwningStmtResult Parser::ParseObjCTryStmt(SourceLocation atLoc) { return StmtError(); } StmtVector CatchStmts(Actions); - OwningStmtResult FinallyStmt(Actions); + OwningStmtResult FinallyStmt; ParseScope TryScope(this, Scope::DeclScope); OwningStmtResult TryBody(ParseCompoundStatementBody()); TryScope.Exit(); @@ -1574,7 +1574,7 @@ Parser::OwningStmtResult Parser::ParseObjCTryStmt(SourceLocation atLoc) { else // Skip over garbage, until we get to ')'. Eat the ')'. SkipUntil(tok::r_paren, true, false); - OwningStmtResult CatchBody(Actions, true); + OwningStmtResult CatchBody(true); if (Tok.is(tok::l_brace)) CatchBody = ParseCompoundStatementBody(); else @@ -1600,7 +1600,7 @@ Parser::OwningStmtResult Parser::ParseObjCTryStmt(SourceLocation atLoc) { ConsumeToken(); // consume finally ParseScope FinallyScope(this, Scope::DeclScope); - OwningStmtResult FinallyBody(Actions, true); + OwningStmtResult FinallyBody(true); if (Tok.is(tok::l_brace)) FinallyBody = ParseCompoundStatementBody(); else @@ -1874,7 +1874,7 @@ Parser::OwningExprResult Parser::ParseObjCMessageExpression() { if (IsExpr) return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), 0, - OwningExprResult(Actions, TypeOrExpr)); + OwningExprResult(static_cast(TypeOrExpr))); return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), TypeOrExpr, ExprArg(Actions)); diff --git a/lib/Parse/ParsePragma.cpp b/lib/Parse/ParsePragma.cpp index c468869e5b..6c90e127e2 100644 --- a/lib/Parse/ParsePragma.cpp +++ b/lib/Parse/ParsePragma.cpp @@ -87,7 +87,7 @@ void PragmaPackHandler::HandlePragma(Preprocessor &PP, Token &PackTok) { Action::PragmaPackKind Kind = Action::PPK_Default; IdentifierInfo *Name = 0; - Action::OwningExprResult Alignment(Actions); + Action::OwningExprResult Alignment; SourceLocation LParenLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.is(tok::numeric_constant)) { diff --git a/lib/Parse/ParseStmt.cpp b/lib/Parse/ParseStmt.cpp index 1e243806b4..de39a924b5 100644 --- a/lib/Parse/ParseStmt.cpp +++ b/lib/Parse/ParseStmt.cpp @@ -76,7 +76,7 @@ using namespace clang; Parser::OwningStmtResult Parser::ParseStatementOrDeclaration(bool OnlyStatement) { const char *SemiError = 0; - OwningStmtResult Res(Actions); + OwningStmtResult Res; ParenBraceBracketBalancer BalancerRAIIObj(*this); @@ -272,7 +272,7 @@ Parser::OwningStmtResult Parser::ParseCaseStatement(AttributeList *Attr) { // TopLevelCase - This is the highest level we have parsed. 'case 1' in the // example above. - OwningStmtResult TopLevelCase(Actions, true); + OwningStmtResult TopLevelCase(true); // DeepestParsedCaseStmt - This is the deepest statement we have parsed, which // gets updated each time a new case is parsed, and whose body is unset so @@ -301,7 +301,7 @@ Parser::OwningStmtResult Parser::ParseCaseStatement(AttributeList *Attr) { // GNU case range extension. SourceLocation DotDotDotLoc; - OwningExprResult RHS(Actions); + OwningExprResult RHS; if (Tok.is(tok::ellipsis)) { Diag(Tok, diag::ext_gnu_case_range); DotDotDotLoc = ConsumeToken(); @@ -336,7 +336,7 @@ Parser::OwningStmtResult Parser::ParseCaseStatement(AttributeList *Attr) { } else { // If this is the first case statement we parsed, it becomes TopLevelCase. // Otherwise we link it into the current chain. - StmtTy *NextDeepest = Case.get(); + Stmt *NextDeepest = Case.get(); if (TopLevelCase.isInvalid()) TopLevelCase = move(Case); else @@ -350,7 +350,7 @@ Parser::OwningStmtResult Parser::ParseCaseStatement(AttributeList *Attr) { assert(!TopLevelCase.isInvalid() && "Should have parsed at least one case!"); // If we found a non-case statement, start by parsing it. - OwningStmtResult SubStmt(Actions); + OwningStmtResult SubStmt; if (Tok.isNot(tok::r_brace)) { SubStmt = ParseStatement(); @@ -468,7 +468,7 @@ Parser::OwningStmtResult Parser::ParseCompoundStatementBody(bool isStmtExpr) { typedef StmtVector StmtsTy; StmtsTy Stmts(Actions); while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) { - OwningStmtResult R(Actions); + OwningStmtResult R; if (Tok.isNot(tok::kw___extension__)) { R = ParseStatementOrDeclaration(false); } else { @@ -611,7 +611,7 @@ Parser::OwningStmtResult Parser::ParseIfStatement(AttributeList *Attr) { ParseScope IfScope(this, Scope::DeclScope | Scope::ControlScope, C99orCXX); // Parse the condition. - OwningExprResult CondExp(Actions); + OwningExprResult CondExp; Decl *CondVar = 0; if (ParseParenExprOrCondition(CondExp, CondVar, IfLoc, true)) return StmtError(); @@ -649,7 +649,7 @@ Parser::OwningStmtResult Parser::ParseIfStatement(AttributeList *Attr) { // If it has an else, parse it. SourceLocation ElseLoc; SourceLocation ElseStmtLoc; - OwningStmtResult ElseStmt(Actions); + OwningStmtResult ElseStmt; if (Tok.is(tok::kw_else)) { ElseLoc = ConsumeToken(); @@ -737,7 +737,7 @@ Parser::OwningStmtResult Parser::ParseSwitchStatement(AttributeList *Attr) { ParseScope SwitchScope(this, ScopeFlags); // Parse the condition. - OwningExprResult Cond(Actions); + OwningExprResult Cond; Decl *CondVar = 0; if (ParseParenExprOrCondition(Cond, CondVar, SwitchLoc, false)) return StmtError(); @@ -827,7 +827,7 @@ Parser::OwningStmtResult Parser::ParseWhileStatement(AttributeList *Attr) { ParseScope WhileScope(this, ScopeFlags); // Parse the condition. - OwningExprResult Cond(Actions); + OwningExprResult Cond; Decl *CondVar = 0; if (ParseParenExprOrCondition(Cond, CondVar, WhileLoc, true)) return StmtError(); @@ -982,13 +982,13 @@ Parser::OwningStmtResult Parser::ParseForStatement(AttributeList *Attr) { ParseScope ForScope(this, ScopeFlags); SourceLocation LParenLoc = ConsumeParen(); - OwningExprResult Value(Actions); + OwningExprResult Value; bool ForEach = false; - OwningStmtResult FirstPart(Actions); + OwningStmtResult FirstPart; bool SecondPartIsInvalid = false; FullExprArg SecondPart(Actions); - OwningExprResult Collection(Actions); + OwningExprResult Collection; FullExprArg ThirdPart(Actions); Decl *SecondVar = 0; @@ -1051,7 +1051,7 @@ Parser::OwningStmtResult Parser::ParseForStatement(AttributeList *Attr) { if (Tok.is(tok::semi)) { // for (...;; // no second part. } else { - OwningExprResult Second(Actions); + OwningExprResult Second; if (getLang().CPlusPlus) ParseCXXCondition(Second, SecondVar, ForLoc, true); else { @@ -1132,7 +1132,7 @@ Parser::OwningStmtResult Parser::ParseGotoStatement(AttributeList *Attr) { assert(Tok.is(tok::kw_goto) && "Not a goto stmt!"); SourceLocation GotoLoc = ConsumeToken(); // eat the 'goto'. - OwningStmtResult Res(Actions); + OwningStmtResult Res; if (Tok.is(tok::identifier)) { Res = Actions.ActOnGotoStmt(GotoLoc, Tok.getLocation(), Tok.getIdentifierInfo()); @@ -1193,7 +1193,7 @@ Parser::OwningStmtResult Parser::ParseReturnStatement(AttributeList *Attr) { assert(Tok.is(tok::kw_return) && "Not a return stmt!"); SourceLocation ReturnLoc = ConsumeToken(); // eat the 'return'. - OwningExprResult R(Actions); + OwningExprResult R; if (Tok.isNot(tok::semi)) { if (Tok.is(tok::code_completion)) { Actions.CodeCompleteReturn(getCurScope()); diff --git a/lib/Parse/ParseTemplate.cpp b/lib/Parse/ParseTemplate.cpp index c584cd4669..dec41d9292 100644 --- a/lib/Parse/ParseTemplate.cpp +++ b/lib/Parse/ParseTemplate.cpp @@ -601,7 +601,7 @@ Parser::ParseNonTypeTemplateParameter(unsigned Depth, unsigned Position) { // Per C++0x [basic.scope.pdecl]p9, we parse the default argument before // we introduce the template parameter into the local scope. SourceLocation EqualLoc; - OwningExprResult DefaultArg(Actions); + OwningExprResult DefaultArg; if (Tok.is(tok::equal)) { EqualLoc = ConsumeToken(); diff --git a/lib/Sema/SemaCXXCast.cpp b/lib/Sema/SemaCXXCast.cpp index b59c04a0a1..a7225180ac 100644 --- a/lib/Sema/SemaCXXCast.cpp +++ b/lib/Sema/SemaCXXCast.cpp @@ -967,7 +967,7 @@ TryStaticImplicitCast(Sema &Self, Expr *&SrcExpr, QualType DestType, Sema::OwningExprResult Result = InitSeq.Perform(Self, Entity, InitKind, - Action::MultiExprArg(Self, (void**)&SrcExpr, 1)); + Action::MultiExprArg(Self, &SrcExpr, 1)); if (Result.isInvalid()) { msg = 0; return TC_Failed; diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp index 72d7e20000..55f5aac361 100644 --- a/lib/Sema/SemaDecl.cpp +++ b/lib/Sema/SemaDecl.cpp @@ -4136,7 +4136,7 @@ void Sema::AddInitializerToDecl(Decl *RealDecl, ExprArg init, bool DirectInit) { } else if (!VDecl->isInvalidDecl()) { InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1); OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind, - MultiExprArg(*this, (void**)&Init, 1), + MultiExprArg(*this, &Init, 1), &DclT); if (Result.isInvalid()) { VDecl->setInvalidDecl(); @@ -4207,7 +4207,7 @@ void Sema::AddInitializerToDecl(Decl *RealDecl, ExprArg init, bool DirectInit) { if (!VDecl->isInvalidDecl()) { InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1); OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind, - MultiExprArg(*this, (void**)&Init, 1), + MultiExprArg(*this, &Init, 1), &DclT); if (Result.isInvalid()) { VDecl->setInvalidDecl(); diff --git a/lib/Sema/SemaDeclCXX.cpp b/lib/Sema/SemaDeclCXX.cpp index fd0bcfcadf..08a34a5d0f 100644 --- a/lib/Sema/SemaDeclCXX.cpp +++ b/lib/Sema/SemaDeclCXX.cpp @@ -129,7 +129,7 @@ Sema::SetParamDefaultArgument(ParmVarDecl *Param, ExprArg DefaultArg, EqualLoc); InitializationSequence InitSeq(*this, Entity, Kind, &Arg, 1); OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind, - MultiExprArg(*this, (void**)&Arg, 1)); + MultiExprArg(*this, &Arg, 1)); if (Result.isInvalid()) return true; Arg = Result.takeAs(); @@ -1325,7 +1325,7 @@ Sema::BuildMemberInitializer(FieldDecl *Member, Expr **Args, OwningExprResult MemberInit = InitSeq.Perform(*this, MemberEntity, Kind, - MultiExprArg(*this, (void**)Args, NumArgs), 0); + MultiExprArg(*this, Args, NumArgs), 0); if (MemberInit.isInvalid()) return true; @@ -1457,7 +1457,7 @@ Sema::BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo, OwningExprResult BaseInit = InitSeq.Perform(*this, BaseEntity, Kind, - MultiExprArg(*this, (void**)Args, NumArgs), 0); + MultiExprArg(*this, Args, NumArgs), 0); if (BaseInit.isInvalid()) return true; @@ -1515,7 +1515,7 @@ BuildImplicitBaseInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, = InitializedEntity::InitializeBase(SemaRef.Context, BaseSpec, IsInheritedVirtualBase); - Sema::OwningExprResult BaseInit(SemaRef); + Sema::OwningExprResult BaseInit; switch (ImplicitInitKind) { case IIK_Default: { @@ -1553,7 +1553,7 @@ BuildImplicitBaseInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, &CopyCtorArg, 1); BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, Sema::MultiExprArg(SemaRef, - (void**)&CopyCtorArg, 1)); + &CopyCtorArg, 1)); break; } @@ -1674,7 +1674,7 @@ BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, Sema::OwningExprResult MemberInit = InitSeq.Perform(SemaRef, Entities.back(), InitKind, - Sema::MultiExprArg(SemaRef, (void**)&CopyCtorArgE, 1)); + Sema::MultiExprArg(SemaRef, &CopyCtorArgE, 1)); MemberInit = SemaRef.MaybeCreateCXXExprWithTemporaries(move(MemberInit)); if (MemberInit.isInvalid()) return true; @@ -4927,7 +4927,7 @@ void Sema::DefineImplicitCopyAssignment(SourceLocation CurrentLocation, // which they were declared in the class definition. // The statements that form the synthesized function body. - ASTOwningVector<&ActionBase::DeleteStmt> Statements(*this); + ASTOwningVector Statements(*this); // The parameter for the "other" object, which we are copying from. ParmVarDecl *Other = CopyAssignOperator->getParamDecl(0); @@ -5132,7 +5132,7 @@ void Sema::DefineImplicitCopyAssignment(SourceLocation CurrentLocation, assert(BuiltinMemCpyRef && "Builtin reference cannot fail"); } - ASTOwningVector<&ActionBase::DeleteExpr> CallArgs(*this); + ASTOwningVector CallArgs(*this); CallArgs.push_back(To.takeAs()); CallArgs.push_back(From.takeAs()); CallArgs.push_back(new (Context) IntegerLiteral(Size, SizeType, Loc)); @@ -5602,7 +5602,7 @@ bool Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor, MultiExprArg ArgsPtr, SourceLocation Loc, - ASTOwningVector<&ActionBase::DeleteExpr> &ConvertedArgs) { + ASTOwningVector &ConvertedArgs) { // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall. unsigned NumArgs = ArgsPtr.size(); Expr **Args = (Expr **)ArgsPtr.get(); @@ -6139,7 +6139,7 @@ VarDecl *Sema::BuildExceptionDeclaration(Scope *S, QualType ExDeclType, SourceLocation()); InitializationSequence InitSeq(*this, Entity, Kind, &ExDeclRef, 1); OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind, - MultiExprArg(*this, (void**)&ExDeclRef, 1)); + MultiExprArg(*this, &ExDeclRef, 1)); if (Result.isInvalid()) Invalid = true; else diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp index 2012f7f2fd..01fbdbe5fa 100644 --- a/lib/Sema/SemaExpr.cpp +++ b/lib/Sema/SemaExpr.cpp @@ -3344,7 +3344,7 @@ Sema::OwningExprResult Sema::ActOnMemberAccessExpr(Scope *S, ExprArg BaseArg, BaseArg = MaybeConvertParenListExprToParenExpr(S, move(BaseArg)); Expr *Base = BaseArg.takeAs(); - OwningExprResult Result(*this); + OwningExprResult Result; if (Base->getType()->isDependentType() || Name.isDependentName() || isDependentScopeSpecifier(SS)) { Result = ActOnDependentMemberExpr(ExprArg(*this, Base), Base->getType(), @@ -3417,7 +3417,7 @@ Sema::OwningExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc, InitializationSequence InitSeq(*this, Entity, Kind, &ResultE, 1); Result = InitSeq.Perform(*this, Entity, Kind, - MultiExprArg(*this, (void**)&ResultE, 1)); + MultiExprArg(*this, &ResultE, 1)); if (Result.isInvalid()) return ExprError(); @@ -3841,7 +3841,7 @@ Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, /*IsCStyleCast=*/true); InitializationSequence InitSeq(*this, Entity, Kind, &literalExpr, 1); OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind, - MultiExprArg(*this, (void**)&literalExpr, 1), + MultiExprArg(*this, &literalExpr, 1), &literalType); if (Result.isInvalid()) return ExprError(); @@ -4108,7 +4108,7 @@ Sema::MaybeConvertParenListExprToParenExpr(Scope *S, ExprArg EA) { if (!E) return Owned(expr); - OwningExprResult Result(*this, E->getExpr(0)); + OwningExprResult Result(E->getExpr(0)); for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i) Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, move(Result), diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp index 0a3ec0d053..2d400b5826 100644 --- a/lib/Sema/SemaExprCXX.cpp +++ b/lib/Sema/SemaExprCXX.cpp @@ -780,7 +780,7 @@ Sema::BuildCXXNew(SourceLocation StartLoc, bool UseGlobal, CXXConstructorDecl *Constructor = 0; Expr **ConsArgs = (Expr**)ConstructorArgs.get(); unsigned NumConsArgs = ConstructorArgs.size(); - ASTOwningVector<&ActionBase::DeleteExpr> ConvertedConstructorArgs(*this); + ASTOwningVector ConvertedConstructorArgs(*this); // Array 'new' can't have any initializers. if (NumConsArgs && (ResultType->isArrayType() || ArraySize)) { @@ -1592,10 +1592,10 @@ static Sema::OwningExprResult BuildCXXCastArgument(Sema &S, switch (Kind) { default: assert(0 && "Unhandled cast kind!"); case CastExpr::CK_ConstructorConversion: { - ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(S); + ASTOwningVector ConstructorArgs(S); if (S.CompleteConstructorCall(cast(Method), - Sema::MultiExprArg(S, (void **)&From, 1), + Sema::MultiExprArg(S, &From, 1), CastLoc, ConstructorArgs)) return S.ExprError(); @@ -1723,9 +1723,9 @@ Sema::PerformImplicitConversion(Expr *&From, QualType ToType, // FIXME: When can ToType be a reference type? assert(!ToType->isReferenceType()); if (SCS.Second == ICK_Derived_To_Base) { - ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this); + ASTOwningVector ConstructorArgs(*this); if (CompleteConstructorCall(cast(SCS.CopyConstructor), - MultiExprArg(*this, (void **)&From, 1), + MultiExprArg(*this, &From, 1), /*FIXME:ConstructLoc*/SourceLocation(), ConstructorArgs)) return true; @@ -1741,7 +1741,7 @@ Sema::PerformImplicitConversion(Expr *&From, QualType ToType, OwningExprResult FromResult = BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), ToType, SCS.CopyConstructor, - MultiExprArg(*this, (void**)&From, 1)); + MultiExprArg(*this, &From, 1)); if (FromResult.isInvalid()) return true; @@ -2187,7 +2187,7 @@ static bool ConvertForConditional(Sema &Self, Expr *&E, QualType T) { SourceLocation()); InitializationSequence InitSeq(Self, Entity, Kind, &E, 1); Sema::OwningExprResult Result = InitSeq.Perform(Self, Entity, Kind, - Sema::MultiExprArg(Self, (void **)&E, 1)); + Sema::MultiExprArg(Self, &E, 1)); if (Result.isInvalid()) return true; @@ -2569,14 +2569,14 @@ QualType Sema::FindCompositePointerType(SourceLocation Loc, // Convert E1 to Composite1 OwningExprResult E1Result - = E1ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,(void**)&E1,1)); + = E1ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,&E1,1)); if (E1Result.isInvalid()) return QualType(); E1 = E1Result.takeAs(); // Convert E2 to Composite1 OwningExprResult E2Result - = E2ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,(void**)&E2,1)); + = E2ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,&E2,1)); if (E2Result.isInvalid()) return QualType(); E2 = E2Result.takeAs(); @@ -2594,14 +2594,14 @@ QualType Sema::FindCompositePointerType(SourceLocation Loc, // Convert E1 to Composite2 OwningExprResult E1Result - = E1ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, (void**)&E1, 1)); + = E1ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, &E1, 1)); if (E1Result.isInvalid()) return QualType(); E1 = E1Result.takeAs(); // Convert E2 to Composite2 OwningExprResult E2Result - = E2ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, (void**)&E2, 1)); + = E2ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, &E2, 1)); if (E2Result.isInvalid()) return QualType(); E2 = E2Result.takeAs(); diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp index c26932b590..6d7d3a9b10 100644 --- a/lib/Sema/SemaInit.cpp +++ b/lib/Sema/SemaInit.cpp @@ -680,7 +680,7 @@ void InitListChecker::CheckSubElementType(const InitializedEntity &Entity, if (Seq) { Sema::OwningExprResult Result = Seq.Perform(SemaRef, Entity, Kind, - Sema::MultiExprArg(SemaRef, (void **)&expr, 1)); + Sema::MultiExprArg(SemaRef, &expr, 1)); if (Result.isInvalid()) hadError = true; @@ -3411,7 +3411,7 @@ static Sema::OwningExprResult CopyObject(Sema &S, } CXXConstructorDecl *Constructor = cast(Best->Function); - ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(S); + ASTOwningVector ConstructorArgs(S); CurInit.release(); // Ownership transferred into MultiExprArg, below. S.CheckConstructorAccess(Loc, Constructor, Entity, @@ -3447,9 +3447,7 @@ static Sema::OwningExprResult CopyObject(Sema &S, // constructor call (we might have derived-to-base conversions, or // the copy constructor may have default arguments). if (S.CompleteConstructorCall(Constructor, - Sema::MultiExprArg(S, - (void **)&CurInitExpr, - 1), + Sema::MultiExprArg(S, &CurInitExpr, 1), Loc, ConstructorArgs)) return S.ExprError(); @@ -3530,7 +3528,7 @@ InitializationSequence::Perform(Sema &S, } if (Kind.getKind() == InitializationKind::IK_Copy || Kind.isExplicitCast()) - return Sema::OwningExprResult(S, Args.release()[0]); + return Sema::OwningExprResult(Args.release()[0]); if (Args.size() == 0) return S.Owned((Expr *)0); @@ -3579,7 +3577,7 @@ InitializationSequence::Perform(Sema &S, case SK_StringInit: case SK_ObjCObjectConversion: assert(Args.size() == 1); - CurInit = Sema::OwningExprResult(S, ((Expr **)(Args.get()))[0]->Retain()); + CurInit = Sema::OwningExprResult(((Expr **)(Args.get()))[0]->Retain()); if (CurInit.isInvalid()) return S.ExprError(); break; @@ -3703,16 +3701,14 @@ InitializationSequence::Perform(Sema &S, bool IsLvalue = false; if (CXXConstructorDecl *Constructor = dyn_cast(Fn)) { // Build a call to the selected constructor. - ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(S); + ASTOwningVector ConstructorArgs(S); SourceLocation Loc = CurInitExpr->getLocStart(); CurInit.release(); // Ownership transferred into MultiExprArg, below. // Determine the arguments required to actually perform the constructor // call. if (S.CompleteConstructorCall(Constructor, - Sema::MultiExprArg(S, - (void **)&CurInitExpr, - 1), + Sema::MultiExprArg(S, &CurInitExpr, 1), Loc, ConstructorArgs)) return S.ExprError(); @@ -3838,7 +3834,7 @@ InitializationSequence::Perform(Sema &S, = cast(Step->Function.Function); // Build a call to the selected constructor. - ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(S); + ASTOwningVector ConstructorArgs(S); SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid()) ? Kind.getEqualLoc() : Kind.getLocation(); @@ -4464,6 +4460,5 @@ Sema::PerformCopyInitialization(const InitializedEntity &Entity, EqualLoc); InitializationSequence Seq(*this, Entity, Kind, &InitE, 1); Init.release(); - return Seq.Perform(*this, Entity, Kind, - MultiExprArg(*this, (void**)&InitE, 1)); + return Seq.Perform(*this, Entity, Kind, MultiExprArg(*this, &InitE, 1)); } diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp index 25a3a2e9d0..a04b73dcd5 100644 --- a/lib/Sema/SemaOverload.cpp +++ b/lib/Sema/SemaOverload.cpp @@ -6556,7 +6556,7 @@ BuildRecoveryCallExpr(Sema &SemaRef, Scope *S, Expr *Fn, // an expression with non-empty lookup results, which should never // end up here. return SemaRef.ActOnCallExpr(/*Scope*/ 0, move(NewFn), LParenLoc, - Sema::MultiExprArg(SemaRef, (void**) Args, NumArgs), + Sema::MultiExprArg(SemaRef, Args, NumArgs), CommaLocs, RParenLoc); } diff --git a/lib/Sema/SemaTemplateInstantiateDecl.cpp b/lib/Sema/SemaTemplateInstantiateDecl.cpp index a853d91d04..d915c53c2e 100644 --- a/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -253,7 +253,7 @@ static bool InstantiateInitializationArguments(Sema &SemaRef, Expr **Args, unsigned NumArgs, const MultiLevelTemplateArgumentList &TemplateArgs, llvm::SmallVectorImpl &FakeCommaLocs, - ASTOwningVector<&ActionBase::DeleteExpr> &InitArgs) { + ASTOwningVector &InitArgs) { for (unsigned I = 0; I != NumArgs; ++I) { // When we hit the first defaulted argument, break out of the loop: // we don't pass those default arguments on. @@ -292,7 +292,7 @@ static bool InstantiateInitializer(Sema &S, Expr *Init, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation &LParenLoc, llvm::SmallVector &CommaLocs, - ASTOwningVector<&ActionBase::DeleteExpr> &NewArgs, + ASTOwningVector &NewArgs, SourceLocation &RParenLoc) { NewArgs.clear(); LParenLoc = SourceLocation(); @@ -421,7 +421,7 @@ Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) { // Instantiate the initializer. SourceLocation LParenLoc, RParenLoc; llvm::SmallVector CommaLocs; - ASTOwningVector<&ActionBase::DeleteExpr> InitArgs(SemaRef); + ASTOwningVector InitArgs(SemaRef); if (!InstantiateInitializer(SemaRef, D->getInit(), TemplateArgs, LParenLoc, CommaLocs, InitArgs, RParenLoc)) { // Attach the initializer to the declaration. @@ -591,7 +591,7 @@ Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) { if (InstantiatedAssertExpr.isInvalid()) return 0; - OwningExprResult Message(SemaRef, D->getMessage()); + OwningExprResult Message(D->getMessage()); D->getMessage()->Retain(); return SemaRef.ActOnStaticAssertDeclaration(D->getLocation(), move(InstantiatedAssertExpr), @@ -2251,7 +2251,7 @@ Sema::InstantiateMemInitializers(CXXConstructorDecl *New, CXXBaseOrMemberInitializer *Init = *Inits; SourceLocation LParenLoc, RParenLoc; - ASTOwningVector<&ActionBase::DeleteExpr> NewArgs(*this); + ASTOwningVector NewArgs(*this); llvm::SmallVector CommaLocs; // Instantiate the initializer. diff --git a/lib/Sema/TreeTransform.h b/lib/Sema/TreeTransform.h index 656c03d890..40358e31bc 100644 --- a/lib/Sema/TreeTransform.h +++ b/lib/Sema/TreeTransform.h @@ -1510,7 +1510,7 @@ public: SourceLocation LParenLoc, ExprArg SubExpr, SourceLocation RParenLoc) { - void *Sub = SubExpr.takeAs(); + Expr *Sub = SubExpr.get(); return getSema().ActOnCXXTypeConstructExpr(TypeRange, TInfo->getType().getAsOpaquePtr(), LParenLoc, @@ -1687,7 +1687,7 @@ public: MultiExprArg Args, bool RequiresZeroInit, CXXConstructExpr::ConstructionKind ConstructKind) { - ASTOwningVector<&ActionBase::DeleteExpr> ConvertedArgs(SemaRef); + ASTOwningVector ConvertedArgs(SemaRef); if (getSema().CompleteConstructorCall(Constructor, move(Args), Loc, ConvertedArgs)) return getSema().ExprError(); @@ -3469,7 +3469,7 @@ Sema::OwningStmtResult TreeTransform::TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr) { bool SubStmtChanged = false; - ASTOwningVector<&ActionBase::DeleteStmt> Statements(getSema()); + ASTOwningVector Statements(getSema()); for (CompoundStmt::body_iterator B = S->body_begin(), BEnd = S->body_end(); B != BEnd; ++B) { OwningStmtResult Result = getDerived().TransformStmt(*B); @@ -3493,7 +3493,7 @@ TreeTransform::TransformCompoundStmt(CompoundStmt *S, template Sema::OwningStmtResult TreeTransform::TransformCaseStmt(CaseStmt *S) { - OwningExprResult LHS(SemaRef), RHS(SemaRef); + OwningExprResult LHS, RHS; { // The case value expressions are not potentially evaluated. EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); @@ -3559,7 +3559,7 @@ template Sema::OwningStmtResult TreeTransform::TransformIfStmt(IfStmt *S) { // Transform the condition - OwningExprResult Cond(SemaRef); + OwningExprResult Cond; VarDecl *ConditionVar = 0; if (S->getConditionVariable()) { ConditionVar @@ -3617,7 +3617,7 @@ template Sema::OwningStmtResult TreeTransform::TransformSwitchStmt(SwitchStmt *S) { // Transform the condition. - OwningExprResult Cond(SemaRef); + OwningExprResult Cond; VarDecl *ConditionVar = 0; if (S->getConditionVariable()) { ConditionVar @@ -3655,7 +3655,7 @@ template Sema::OwningStmtResult TreeTransform::TransformWhileStmt(WhileStmt *S) { // Transform the condition - OwningExprResult Cond(SemaRef); + OwningExprResult Cond; VarDecl *ConditionVar = 0; if (S->getConditionVariable()) { ConditionVar @@ -3733,7 +3733,7 @@ TreeTransform::TransformForStmt(ForStmt *S) { return SemaRef.StmtError(); // Transform the condition - OwningExprResult Cond(SemaRef); + OwningExprResult Cond; VarDecl *ConditionVar = 0; if (S->getConditionVariable()) { ConditionVar @@ -3874,12 +3874,12 @@ template Sema::OwningStmtResult TreeTransform::TransformAsmStmt(AsmStmt *S) { - ASTOwningVector<&ActionBase::DeleteExpr> Constraints(getSema()); - ASTOwningVector<&ActionBase::DeleteExpr> Exprs(getSema()); + ASTOwningVector Constraints(getSema()); + ASTOwningVector Exprs(getSema()); llvm::SmallVector Names; - OwningExprResult AsmString(SemaRef); - ASTOwningVector<&ActionBase::DeleteExpr> Clobbers(getSema()); + OwningExprResult AsmString; + ASTOwningVector Clobbers(getSema()); bool ExprsChanged = false; @@ -3954,7 +3954,7 @@ TreeTransform::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { // Transform the @catch statements (if present). bool AnyCatchChanged = false; - ASTOwningVector<&ActionBase::DeleteStmt> CatchStmts(SemaRef); + ASTOwningVector CatchStmts(SemaRef); for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) { OwningStmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I)); if (Catch.isInvalid()) @@ -3965,7 +3965,7 @@ TreeTransform::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { } // Transform the @finally statement (if present). - OwningStmtResult Finally(SemaRef); + OwningStmtResult Finally; if (S->getFinallyStmt()) { Finally = getDerived().TransformStmt(S->getFinallyStmt()); if (Finally.isInvalid()) @@ -4041,7 +4041,7 @@ TreeTransform::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { template Sema::OwningStmtResult TreeTransform::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { - OwningExprResult Operand(SemaRef); + OwningExprResult Operand; if (S->getThrowExpr()) { Operand = getDerived().TransformExpr(S->getThrowExpr()); if (Operand.isInvalid()) @@ -4167,7 +4167,7 @@ TreeTransform::TransformCXXTryStmt(CXXTryStmt *S) { // Transform the handlers. bool HandlerChanged = false; - ASTOwningVector<&ActionBase::DeleteStmt> Handlers(SemaRef); + ASTOwningVector Handlers(SemaRef); for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) { OwningStmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(I)); @@ -4393,7 +4393,7 @@ TreeTransform::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { E->getSourceRange()); } - Sema::OwningExprResult SubExpr(SemaRef); + Sema::OwningExprResult SubExpr; { // C++0x [expr.sizeof]p1: // The operand is either an expression, which is an unevaluated operand @@ -4446,7 +4446,7 @@ TreeTransform::TransformCallExpr(CallExpr *E) { // Transform arguments. bool ArgChanged = false; - ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); + ASTOwningVector Args(SemaRef); llvm::SmallVector FakeCommaLocs; for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I)); @@ -4700,7 +4700,7 @@ Sema::OwningExprResult TreeTransform::TransformInitListExpr(InitListExpr *E) { bool InitChanged = false; - ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); + ASTOwningVector Inits(SemaRef); for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) { OwningExprResult Init = getDerived().TransformExpr(E->getInit(I)); if (Init.isInvalid()) @@ -4728,7 +4728,7 @@ TreeTransform::TransformDesignatedInitExpr(DesignatedInitExpr *E) { return SemaRef.ExprError(); // transform the designators. - ASTOwningVector<&ActionBase::DeleteExpr, 4> ArrayExprs(SemaRef); + ASTOwningVector ArrayExprs(SemaRef); bool ExprChanged = false; for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), DEnd = E->designators_end(); @@ -4828,7 +4828,7 @@ template Sema::OwningExprResult TreeTransform::TransformParenListExpr(ParenListExpr *E) { bool ArgumentChanged = false; - ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); + ASTOwningVector Inits(SemaRef); for (unsigned I = 0, N = E->getNumExprs(); I != N; ++I) { OwningExprResult Init = getDerived().TransformExpr(E->getExpr(I)); if (Init.isInvalid()) @@ -4954,7 +4954,7 @@ TreeTransform::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { static_cast(Object.get())->getLocEnd()); // Transform the call arguments. - ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); + ASTOwningVector Args(SemaRef); llvm::SmallVector FakeCommaLocs; for (unsigned I = 1, N = E->getNumArgs(); I != N; ++I) { if (getDerived().DropCallArgument(E->getArg(I))) @@ -5004,7 +5004,7 @@ TreeTransform::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { if (First.isInvalid()) return SemaRef.ExprError(); - OwningExprResult Second(SemaRef); + OwningExprResult Second; if (E->getNumArgs() == 2) { Second = getDerived().TransformExpr(E->getArg(1)); if (Second.isInvalid()) @@ -5266,7 +5266,7 @@ TreeTransform::TransformCXXNewExpr(CXXNewExpr *E) { // Transform the placement arguments (if any). bool ArgumentChanged = false; - ASTOwningVector<&ActionBase::DeleteExpr> PlacementArgs(SemaRef); + ASTOwningVector PlacementArgs(SemaRef); for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) { OwningExprResult Arg = getDerived().TransformExpr(E->getPlacementArg(I)); if (Arg.isInvalid()) @@ -5277,7 +5277,7 @@ TreeTransform::TransformCXXNewExpr(CXXNewExpr *E) { } // transform the constructor arguments (if any). - ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(SemaRef); + ASTOwningVector ConstructorArgs(SemaRef); for (unsigned I = 0, N = E->getNumConstructorArgs(); I != N; ++I) { if (getDerived().DropCallArgument(E->getConstructorArg(I))) break; @@ -5660,7 +5660,7 @@ TreeTransform::TransformCXXConstructExpr(CXXConstructExpr *E) { return SemaRef.ExprError(); bool ArgumentChanged = false; - ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); + ASTOwningVector Args(SemaRef); for (CXXConstructExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); Arg != ArgEnd; ++Arg) { @@ -5743,7 +5743,7 @@ TreeTransform::TransformCXXTemporaryObjectExpr( return SemaRef.ExprError(); bool ArgumentChanged = false; - ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); + ASTOwningVector Args(SemaRef); Args.reserve(E->getNumArgs()); for (CXXTemporaryObjectExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); @@ -5795,7 +5795,7 @@ TreeTransform::TransformCXXUnresolvedConstructExpr( return SemaRef.ExprError(); bool ArgumentChanged = false; - ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); + ASTOwningVector Args(SemaRef); llvm::SmallVector FakeCommaLocs; for (CXXUnresolvedConstructExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); @@ -5829,7 +5829,7 @@ Sema::OwningExprResult TreeTransform::TransformCXXDependentScopeMemberExpr( CXXDependentScopeMemberExpr *E) { // Transform the base of the expression. - OwningExprResult Base(SemaRef, (Expr*) 0); + OwningExprResult Base((Expr*) 0); Expr *OldBase; QualType BaseType; QualType ObjectType; @@ -5926,7 +5926,7 @@ template Sema::OwningExprResult TreeTransform::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) { // Transform the base of the expression. - OwningExprResult Base(SemaRef, (Expr*) 0); + OwningExprResult Base((Expr*) 0); QualType BaseType; if (!Old->isImplicitAccess()) { Base = getDerived().TransformExpr(Old->getBase()); @@ -6049,7 +6049,7 @@ Sema::OwningExprResult TreeTransform::TransformObjCMessageExpr(ObjCMessageExpr *E) { // Transform arguments. bool ArgChanged = false; - ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); + ASTOwningVector Args(SemaRef); for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I)); if (Arg.isInvalid()) @@ -6211,7 +6211,7 @@ template Sema::OwningExprResult TreeTransform::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { bool ArgumentChanged = false; - ASTOwningVector<&ActionBase::DeleteExpr> SubExprs(SemaRef); + ASTOwningVector SubExprs(SemaRef); for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) { OwningExprResult SubExpr = getDerived().TransformExpr(E->getExpr(I)); if (SubExpr.isInvalid()) -- 2.40.0