diff options
Diffstat (limited to 'clang/lib/Sema/TreeTransform.h')
| -rw-r--r-- | clang/lib/Sema/TreeTransform.h | 2219 |
1 files changed, 1109 insertions, 1110 deletions
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h index d19653d157c..bd7fb4f2f89 100644 --- a/clang/lib/Sema/TreeTransform.h +++ b/clang/lib/Sema/TreeTransform.h @@ -28,13 +28,13 @@ #include <algorithm> namespace clang { - + /// \brief A semantic tree transformation that allows one to transform one /// abstract syntax tree into another. /// -/// A new tree transformation is defined by creating a new subclass \c X of -/// \c TreeTransform<X> and then overriding certain operations to provide -/// behavior specific to that transformation. For example, template +/// A new tree transformation is defined by creating a new subclass \c X of +/// \c TreeTransform<X> and then overriding certain operations to provide +/// behavior specific to that transformation. For example, template /// instantiation is implemented as a tree transformation where the /// transformation of TemplateTypeParmType nodes involves substituting the /// template arguments for their corresponding template parameters; a similar @@ -42,7 +42,7 @@ namespace clang { /// template template parameters. /// /// This tree-transformation template uses static polymorphism to allow -/// subclasses to customize any of its operations. Thus, a subclass can +/// subclasses to customize any of its operations. Thus, a subclass can /// override any of the transformation or rebuild operators by providing an /// operation with the same signature as the default implementation. The /// overridding function should not be virtual. @@ -57,7 +57,7 @@ namespace clang { /// were changed by the transformation, invokes the rebuild operation to create /// a new AST node. /// -/// Subclasses can customize the transformation at various levels. The +/// Subclasses can customize the transformation at various levels. The /// most coarse-grained transformations involve replacing TransformType(), /// TransformExpr(), TransformDecl(), TransformNestedNameSpecifier(), /// TransformTemplateName(), or TransformTemplateArgument() with entirely @@ -67,7 +67,7 @@ namespace clang { /// \c TransformXXX functions (where XXX is the name of an AST node, e.g., /// PointerType, StmtExpr) to alter the transformation. As mentioned previously, /// replacing TransformTemplateTypeParmType() allows template instantiation -/// to substitute template arguments for their corresponding template +/// to substitute template arguments for their corresponding template /// parameters. Additionally, subclasses can override the \c RebuildXXX /// functions to control how AST nodes are rebuilt when their operands change. /// By default, \c TreeTransform will invoke semantic analysis to rebuild @@ -75,7 +75,7 @@ namespace clang { /// be able to use more efficient rebuild steps. /// /// There are a handful of other functions that can be overridden, allowing one -/// to avoid traversing nodes that don't need any transformation +/// to avoid traversing nodes that don't need any transformation /// (\c AlreadyTransformed()), force rebuilding AST nodes even when their /// operands have not changed (\c AlwaysRebuild()), and customize the /// default locations and entity names used for type-checking @@ -84,45 +84,45 @@ template<typename Derived> class TreeTransform { protected: Sema &SemaRef; - -public: + +public: typedef Sema::OwningStmtResult OwningStmtResult; typedef Sema::OwningExprResult OwningExprResult; typedef Sema::StmtArg StmtArg; typedef Sema::ExprArg ExprArg; typedef Sema::MultiExprArg MultiExprArg; typedef Sema::MultiStmtArg MultiStmtArg; - + /// \brief Initializes a new tree transformer. TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { } - + /// \brief Retrieves a reference to the derived class. Derived &getDerived() { return static_cast<Derived&>(*this); } /// \brief Retrieves a reference to the derived class. - const Derived &getDerived() const { - return static_cast<const Derived&>(*this); + const Derived &getDerived() const { + return static_cast<const Derived&>(*this); } /// \brief Retrieves a reference to the semantic analysis object used for /// this tree transform. Sema &getSema() const { return SemaRef; } - + /// \brief Whether the transformation should always rebuild AST nodes, even /// if none of the children have changed. /// /// Subclasses may override this function to specify when the transformation /// should rebuild all AST nodes. bool AlwaysRebuild() { return false; } - + /// \brief Returns the location of the entity being transformed, if that /// information was not available elsewhere in the AST. /// - /// By default, returns no source-location information. Subclasses can + /// By default, returns no source-location information. Subclasses can /// provide an alternative implementation that provides better location /// information. SourceLocation getBaseLocation() { return SourceLocation(); } - + /// \brief Returns the name of the entity being transformed, if that /// information was not available elsewhere in the AST. /// @@ -136,33 +136,32 @@ public: /// By default, the source location and entity are ignored. Subclasses can /// override this function to provide a customized implementation. void setBase(SourceLocation Loc, DeclarationName Entity) { } - + /// \brief RAII object that temporarily sets the base location and entity /// used for reporting diagnostics in types. class TemporaryBase { TreeTransform &Self; SourceLocation OldLocation; DeclarationName OldEntity; - + public: TemporaryBase(TreeTransform &Self, SourceLocation Location, - DeclarationName Entity) : Self(Self) - { + DeclarationName Entity) : Self(Self) { OldLocation = Self.getDerived().getBaseLocation(); OldEntity = Self.getDerived().getBaseEntity(); Self.getDerived().setBase(Location, Entity); } - + ~TemporaryBase() { Self.getDerived().setBase(OldLocation, OldEntity); } }; - - /// \brief Determine whether the given type \p T has already been + + /// \brief Determine whether the given type \p T has already been /// transformed. /// /// Subclasses can provide an alternative implementation of this routine - /// to short-circuit evaluation when it is known that a given type will + /// to short-circuit evaluation when it is known that a given type will /// not change. For example, template instantiation need not traverse /// non-dependent types. bool AlreadyTransformed(QualType T) { @@ -172,15 +171,15 @@ public: /// \brief Transforms the given type into another type. /// /// By default, this routine transforms a type by delegating to the - /// appropriate TransformXXXType to build a new type, then applying - /// the qualifiers on \p T to the resulting type with AddTypeQualifiers. - /// Subclasses may override this function (to take over all type + /// appropriate TransformXXXType to build a new type, then applying + /// the qualifiers on \p T to the resulting type with AddTypeQualifiers. + /// Subclasses may override this function (to take over all type /// transformations), some set of the TransformXXXType functions, or /// the AddTypeQualifiers function to alter the transformation. /// /// \returns the transformed type. QualType TransformType(QualType T); - + /// \brief Transform the given type by adding the given set of qualifiers /// and returning the result. /// @@ -190,10 +189,10 @@ public: /// is the right thing for template instantiation, but probably not for /// other clients. QualType AddTypeQualifiers(QualType T, unsigned CVRQualifiers); - + /// \brief Transform the given statement. /// - /// By default, this routine transforms a statement by delegating to the + /// By default, this routine transforms a statement by delegating to the /// appropriate TransformXXXStmt function to transform a specific kind of /// statement or the TransformExpr() function to transform an expression. /// Subclasses may override this function to transform statements using some @@ -201,7 +200,7 @@ public: /// /// \returns the transformed statement. OwningStmtResult TransformStmt(Stmt *S); - + /// \brief Transform the given expression. /// /// By default, this routine transforms an expression by delegating to the @@ -223,7 +222,7 @@ public: /// /// \returns the transformed expression. OwningExprResult TransformExpr(Expr *E, bool isAddressOfOperand); - + /// \brief Transform the given declaration, which is referenced from a type /// or expression. /// @@ -233,20 +232,20 @@ public: /// \brief Transform the definition of the given declaration. /// - /// By default, invokes TransformDecl() to transform the declaration. + /// By default, invokes TransformDecl() to transform the declaration. /// Subclasses may override this function to provide alternate behavior. Decl *TransformDefinition(Decl *D) { return getDerived().TransformDecl(D); } - + /// \brief Transform the given nested-name-specifier. /// - /// By default, transforms all of the types and declarations within the + /// By default, transforms all of the types and declarations within the /// nested-name-specifier. Subclasses may override this function to provide /// alternate behavior. NestedNameSpecifier *TransformNestedNameSpecifier(NestedNameSpecifier *NNS, SourceRange Range, QualType ObjectType = QualType(), NamedDecl *FirstQualifierInScope = 0); - + /// \brief Transform the given declaration name. /// /// By default, transforms the types of conversion function, constructor, @@ -255,37 +254,37 @@ public: /// override this function to provide alternate behavior. DeclarationName TransformDeclarationName(DeclarationName Name, SourceLocation Loc); - + /// \brief Transform the given template name. - /// + /// /// By default, transforms the template name by transforming the declarations - /// and nested-name-specifiers that occur within the template name. + /// and nested-name-specifiers that occur within the template name. /// Subclasses may override this function to provide alternate behavior. TemplateName TransformTemplateName(TemplateName Name, QualType ObjectType = QualType()); - + /// \brief Transform the given template argument. /// - /// By default, this operation transforms the type, expression, or - /// declaration stored within the template argument and constructs a + /// By default, this operation transforms the type, expression, or + /// declaration stored within the template argument and constructs a /// new template argument from the transformed result. Subclasses may /// override this function to provide alternate behavior. TemplateArgument TransformTemplateArgument(const TemplateArgument &Arg); - + #define ABSTRACT_TYPE(CLASS, PARENT) #define TYPE(CLASS, PARENT) \ QualType Transform##CLASS##Type(const CLASS##Type *T); -#include "clang/AST/TypeNodes.def" +#include "clang/AST/TypeNodes.def" OwningStmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr); - + #define STMT(Node, Parent) \ OwningStmtResult Transform##Node(Node *S); #define EXPR(Node, Parent) \ OwningExprResult Transform##Node(Node *E); #define ABSTRACT_EXPR(Node, Parent) #include "clang/AST/StmtNodes.def" - + /// \brief Build a new pointer type given its pointee type. /// /// By default, performs semantic analysis when building the pointer type. @@ -294,7 +293,7 @@ public: /// \brief Build a new block pointer type given its pointee type. /// - /// By default, performs semantic analysis when building the block pointer + /// By default, performs semantic analysis when building the block pointer /// type. Subclasses may override this routine to provide different behavior. QualType RebuildBlockPointerType(QualType PointeeType); @@ -309,45 +308,45 @@ public: /// By default, performs semantic analysis when building the rvalue reference /// type. Subclasses may override this routine to provide different behavior. QualType RebuildRValueReferenceType(QualType ReferentType); - + /// \brief Build a new member pointer type given the pointee type and the /// class type it refers into. /// /// By default, performs semantic analysis when building the member pointer /// type. Subclasses may override this routine to provide different behavior. QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType); - + /// \brief Build a new array type given the element type, size /// modifier, size of the array (if known), size expression, and index type /// qualifiers. /// /// By default, performs semantic analysis when building the array type. /// Subclasses may override this routine to provide different behavior. - /// Also by default, all of the other Rebuild*Array + /// Also by default, all of the other Rebuild*Array QualType RebuildArrayType(QualType ElementType, ArrayType::ArraySizeModifier SizeMod, const llvm::APInt *Size, Expr *SizeExpr, unsigned IndexTypeQuals, SourceRange BracketsRange); - + /// \brief Build a new constant array type given the element type, size /// modifier, (known) size of the array, and index type qualifiers. /// /// By default, performs semantic analysis when building the array type. /// Subclasses may override this routine to provide different behavior. - QualType RebuildConstantArrayType(QualType ElementType, + QualType RebuildConstantArrayType(QualType ElementType, ArrayType::ArraySizeModifier SizeMod, const llvm::APInt &Size, unsigned IndexTypeQuals); /// \brief Build a new constant array type given the element type, size - /// modifier, (known) size of the array, size expression, and index type + /// modifier, (known) size of the array, size expression, and index type /// qualifiers. /// /// By default, performs semantic analysis when building the array type. /// Subclasses may override this routine to provide different behavior. - QualType RebuildConstantArrayWithExprType(QualType ElementType, + QualType RebuildConstantArrayWithExprType(QualType ElementType, ArrayType::ArraySizeModifier SizeMod, const llvm::APInt &Size, Expr *SizeExpr, @@ -359,7 +358,7 @@ public: /// /// By default, performs semantic analysis when building the array type. /// Subclasses may override this routine to provide different behavior. - QualType RebuildConstantArrayWithoutExprType(QualType ElementType, + QualType RebuildConstantArrayWithoutExprType(QualType ElementType, ArrayType::ArraySizeModifier SizeMod, const llvm::APInt &Size, unsigned IndexTypeQuals); @@ -369,27 +368,27 @@ public: /// /// By default, performs semantic analysis when building the array type. /// Subclasses may override this routine to provide different behavior. - QualType RebuildIncompleteArrayType(QualType ElementType, + QualType RebuildIncompleteArrayType(QualType ElementType, ArrayType::ArraySizeModifier SizeMod, unsigned IndexTypeQuals); - /// \brief Build a new variable-length array type given the element type, + /// \brief Build a new variable-length array type given the element type, /// size modifier, size expression, and index type qualifiers. /// /// By default, performs semantic analysis when building the array type. /// Subclasses may override this routine to provide different behavior. - QualType RebuildVariableArrayType(QualType ElementType, + QualType RebuildVariableArrayType(QualType ElementType, ArrayType::ArraySizeModifier SizeMod, ExprArg SizeExpr, unsigned IndexTypeQuals, SourceRange BracketsRange); - /// \brief Build a new dependent-sized array type given the element type, + /// \brief Build a new dependent-sized array type given the element type, /// size modifier, size expression, and index type qualifiers. /// /// By default, performs semantic analysis when building the array type. /// Subclasses may override this routine to provide different behavior. - QualType RebuildDependentSizedArrayType(QualType ElementType, + QualType RebuildDependentSizedArrayType(QualType ElementType, ArrayType::ArraySizeModifier SizeMod, ExprArg SizeExpr, unsigned IndexTypeQuals, @@ -401,7 +400,7 @@ public: /// By default, performs semantic analysis when building the vector type. /// Subclasses may override this routine to provide different behavior. QualType RebuildVectorType(QualType ElementType, unsigned NumElements); - + /// \brief Build a new extended vector type given the element type and /// number of elements. /// @@ -409,25 +408,25 @@ public: /// Subclasses may override this routine to provide different behavior. QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements, SourceLocation AttributeLoc); - - /// \brief Build a new potentially dependently-sized extended vector type + + /// \brief Build a new potentially dependently-sized extended vector type /// given the element type and number of elements. /// /// By default, performs semantic analysis when building the vector type. /// Subclasses may override this routine to provide different behavior. - QualType RebuildDependentSizedExtVectorType(QualType ElementType, + QualType RebuildDependentSizedExtVectorType(QualType ElementType, ExprArg SizeExpr, SourceLocation AttributeLoc); - + /// \brief Build a new function type. /// /// By default, performs semantic analysis when building the function type. /// Subclasses may override this routine to provide different behavior. QualType RebuildFunctionProtoType(QualType T, - QualType *ParamTypes, + QualType *ParamTypes, unsigned NumParamTypes, bool Variadic, unsigned Quals); - + /// \brief Build a new typedef type. QualType RebuildTypedefType(TypedefDecl *Typedef) { return SemaRef.Context.getTypeDeclType(Typedef); @@ -447,24 +446,24 @@ public: QualType RebuildElaboratedType(QualType T, ElaboratedType::TagKind Tag) { return SemaRef.Context.getElaboratedType(T, Tag); } - - /// \brief Build a new typeof(expr) type. + + /// \brief Build a new typeof(expr) type. /// /// By default, performs semantic analysis when building the typeof type. /// Subclasses may override this routine to provide different behavior. QualType RebuildTypeOfExprType(ExprArg Underlying); - /// \brief Build a new typeof(type) type. + /// \brief Build a new typeof(type) type. /// /// By default, builds a new TypeOfType with the given underlying type. QualType RebuildTypeOfType(QualType Underlying); - /// \brief Build a new C++0x decltype type. + /// \brief Build a new C++0x decltype type. /// /// By default, performs semantic analysis when building the decltype type. /// Subclasses may override this routine to provide different behavior. QualType RebuildDecltypeType(ExprArg Underlying); - + /// \brief Build a new template specialization type. /// /// By default, performs semantic analysis when building the template @@ -473,40 +472,40 @@ public: QualType RebuildTemplateSpecializationType(TemplateName Template, const TemplateArgument *Args, unsigned NumArgs); - + /// \brief Build a new qualified name type. /// - /// By default, builds a new QualifiedNameType type from the - /// nested-name-specifier and the named type. Subclasses may override + /// By default, builds a new QualifiedNameType type from the + /// nested-name-specifier and the named type. Subclasses may override /// this routine to provide different behavior. QualType RebuildQualifiedNameType(NestedNameSpecifier *NNS, QualType Named) { return SemaRef.Context.getQualifiedNameType(NNS, Named); - } + } /// \brief Build a new typename type that refers to a template-id. /// /// By default, builds a new TypenameType type from the nested-name-specifier - /// and the given type. Subclasses may override this routine to provide + /// and the given type. Subclasses may override this routine to provide /// different behavior. QualType RebuildTypenameType(NestedNameSpecifier *NNS, QualType T) { if (NNS->isDependent()) - return SemaRef.Context.getTypenameType(NNS, + return SemaRef.Context.getTypenameType(NNS, cast<TemplateSpecializationType>(T)); - + return SemaRef.Context.getQualifiedNameType(NNS, T); - } + } /// \brief Build a new typename type that refers to an identifier. /// /// By default, performs semantic analysis when building the typename type - /// (or qualified name type). Subclasses may override this routine to provide + /// (or qualified name type). Subclasses may override this routine to provide /// different behavior. - QualType RebuildTypenameType(NestedNameSpecifier *NNS, + QualType RebuildTypenameType(NestedNameSpecifier *NNS, const IdentifierInfo *Id) { return SemaRef.CheckTypenameType(NNS, *Id, SourceRange(getDerived().getBaseLocation())); } - + /// \brief Build a new nested-name-specifier given the prefix and an /// identifier that names the next step in the nested-name-specifier. /// @@ -559,7 +558,7 @@ public: TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier, bool TemplateKW, OverloadedFunctionDecl *Ovl); - + /// \brief Build a new template name given a nested name specifier and the /// name that is referred to as a template. /// @@ -570,8 +569,8 @@ public: TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier, const IdentifierInfo &II, QualType ObjectType); - - + + /// \brief Build a new compound statement. /// /// By default, performs semantic analysis to build the new statement. @@ -593,10 +592,10 @@ public: SourceLocation EllipsisLoc, ExprArg RHS, SourceLocation ColonLoc) { - return getSema().ActOnCaseStmt(CaseLoc, move(LHS), EllipsisLoc, move(RHS), + return getSema().ActOnCaseStmt(CaseLoc, move(LHS), EllipsisLoc, move(RHS), ColonLoc); } - + /// \brief Attach the body to a new case statement. /// /// By default, performs semantic analysis to build the new statement. @@ -605,39 +604,39 @@ public: getSema().ActOnCaseStmtBody(S.get(), move(Body)); return move(S); } - + /// \brief Build a new default statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. - OwningStmtResult RebuildDefaultStmt(SourceLocation DefaultLoc, + OwningStmtResult RebuildDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc, StmtArg SubStmt) { - return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, move(SubStmt), + return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, move(SubStmt), /*CurScope=*/0); } - + /// \brief Build a new label statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. - OwningStmtResult RebuildLabelStmt(SourceLocation IdentLoc, + OwningStmtResult RebuildLabelStmt(SourceLocation IdentLoc, IdentifierInfo *Id, SourceLocation ColonLoc, StmtArg SubStmt) { return SemaRef.ActOnLabelStmt(IdentLoc, Id, ColonLoc, move(SubStmt)); } - + /// \brief Build a new "if" statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. - OwningStmtResult RebuildIfStmt(SourceLocation IfLoc, Sema::FullExprArg Cond, - StmtArg Then, SourceLocation ElseLoc, + OwningStmtResult RebuildIfStmt(SourceLocation IfLoc, Sema::FullExprArg Cond, + StmtArg Then, SourceLocation ElseLoc, StmtArg Else) { return getSema().ActOnIfStmt(IfLoc, Cond, move(Then), ElseLoc, move(Else)); } - + /// \brief Start building a new switch statement. /// /// By default, performs semantic analysis to build the new statement. @@ -645,12 +644,12 @@ public: OwningStmtResult RebuildSwitchStmtStart(ExprArg Cond) { return getSema().ActOnStartOfSwitchStmt(move(Cond)); } - + /// \brief Attach the body to the switch statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. - OwningStmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc, + OwningStmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc, StmtArg Switch, StmtArg Body) { return getSema().ActOnFinishSwitchStmt(SwitchLoc, move(Switch), move(Body)); @@ -665,7 +664,7 @@ public: StmtArg Body) { return getSema().ActOnWhileStmt(WhileLoc, Cond, move(Body)); } - + /// \brief Build a new do-while statement. /// /// By default, performs semantic analysis to build the new statement. @@ -675,7 +674,7 @@ public: SourceLocation LParenLoc, ExprArg Cond, SourceLocation RParenLoc) { - return getSema().ActOnDoStmt(DoLoc, move(Body), WhileLoc, LParenLoc, + return getSema().ActOnDoStmt(DoLoc, move(Body), WhileLoc, LParenLoc, move(Cond), RParenLoc); } @@ -683,14 +682,14 @@ public: /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. - OwningStmtResult RebuildForStmt(SourceLocation ForLoc, + OwningStmtResult RebuildForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, StmtArg Init, ExprArg Cond, ExprArg Inc, SourceLocation RParenLoc, StmtArg Body) { - return getSema().ActOnForStmt(ForLoc, LParenLoc, move(Init), move(Cond), + return getSema().ActOnForStmt(ForLoc, LParenLoc, move(Init), move(Cond), move(Inc), RParenLoc, move(Body)); } - + /// \brief Build a new goto statement. /// /// By default, performs semantic analysis to build the new statement. @@ -710,23 +709,23 @@ public: ExprArg Target) { return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, move(Target)); } - + /// \brief Build a new return statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. OwningStmtResult RebuildReturnStmt(SourceLocation ReturnLoc, ExprArg Result) { - + return getSema().ActOnReturnStmt(ReturnLoc, move(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. OwningStmtResult RebuildDeclStmt(Decl **Decls, unsigned NumDecls, - SourceLocation StartLoc, + SourceLocation StartLoc, SourceLocation EndLoc) { return getSema().Owned( new (getSema().Context) DeclStmt( @@ -734,17 +733,17 @@ public: Decls, NumDecls), StartLoc, EndLoc)); } - + /// \brief Build a new C++ exception declaration. /// /// By default, performs semantic analysis to build the new decaration. /// Subclasses may override this routine to provide different behavior. - VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl, QualType T, + VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl, QualType T, DeclaratorInfo *Declarator, IdentifierInfo *Name, SourceLocation Loc, SourceRange TypeRange) { - return getSema().BuildExceptionDeclaration(0, T, Declarator, Name, Loc, + return getSema().BuildExceptionDeclaration(0, T, Declarator, Name, Loc, TypeRange); } @@ -756,10 +755,10 @@ public: VarDecl *ExceptionDecl, StmtArg Handler) { return getSema().Owned( - new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl, + new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl, Handler.takeAs<Stmt>())); } - + /// \brief Build a new C++ try statement. /// /// By default, performs semantic analysis to build the new statement. @@ -769,7 +768,7 @@ public: MultiStmtArg Handlers) { return getSema().ActOnCXXTryBlock(TryLoc, move(TryBlock), move(Handlers)); } - + /// \brief Build a new expression that references a declaration. /// /// By default, performs semantic analysis to build the new expression. @@ -780,9 +779,9 @@ public: /*SS=*/0, /*FIXME:*/false); } - + /// \brief Build a new expression in parentheses. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildParenExpr(ExprArg SubExpr, SourceLocation LParen, @@ -791,7 +790,7 @@ public: } /// \brief Build a new pseudo-destructor expression. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildCXXPseudoDestructorExpr(ExprArg Base, @@ -807,21 +806,21 @@ public: SS.setScopeRep(Qualifier); } - DeclarationName Name + DeclarationName Name = SemaRef.Context.DeclarationNames.getCXXDestructorName( SemaRef.Context.getCanonicalType(DestroyedType)); - - return getSema().BuildMemberReferenceExpr(/*Scope=*/0, move(Base), + + return getSema().BuildMemberReferenceExpr(/*Scope=*/0, move(Base), OperatorLoc, isArrow? tok::arrow : tok::period, DestroyedTypeLoc, Name, Sema::DeclPtrTy::make((Decl *)0), &SS); - } - + } + /// \brief Build a new unary operator expression. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildUnaryOperator(SourceLocation OpLoc, @@ -829,9 +828,9 @@ public: ExprArg SubExpr) { return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, move(SubExpr)); } - + /// \brief Build a new sizeof or alignof expression with a type argument. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildSizeOfAlignOf(QualType T, SourceLocation OpLoc, @@ -839,38 +838,38 @@ public: return getSema().CreateSizeOfAlignOfExpr(T, OpLoc, isSizeOf, R); } - /// \brief Build a new sizeof or alignof expression with an expression + /// \brief Build a new sizeof or alignof expression with an expression /// argument. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildSizeOfAlignOf(ExprArg SubExpr, SourceLocation OpLoc, bool isSizeOf, SourceRange R) { - OwningExprResult Result + OwningExprResult Result = getSema().CreateSizeOfAlignOfExpr((Expr *)SubExpr.get(), OpLoc, isSizeOf, R); if (Result.isInvalid()) return getSema().ExprError(); - + SubExpr.release(); return move(Result); } - + /// \brief Build a new array subscript expression. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. - OwningExprResult RebuildArraySubscriptExpr(ExprArg LHS, + OwningExprResult RebuildArraySubscriptExpr(ExprArg LHS, SourceLocation LBracketLoc, ExprArg RHS, SourceLocation RBracketLoc) { return getSema().ActOnArraySubscriptExpr(/*Scope=*/0, move(LHS), - LBracketLoc, move(RHS), + LBracketLoc, move(RHS), RBracketLoc); } /// \brief Build a new call expression. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildCallExpr(ExprArg Callee, SourceLocation LParenLoc, @@ -882,11 +881,11 @@ public: } /// \brief Build a new member access expression. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildMemberExpr(ExprArg Base, SourceLocation OpLoc, - bool isArrow, + bool isArrow, NestedNameSpecifier *Qualifier, SourceRange QualifierRange, SourceLocation MemberLoc, @@ -894,14 +893,14 @@ public: if (!Member->getDeclName()) { // We have a reference to an unnamed field. assert(!Qualifier && "Can't have an unnamed field with a qualifier!"); - - MemberExpr *ME = + + MemberExpr *ME = new (getSema().Context) MemberExpr(Base.takeAs<Expr>(), isArrow, Member, MemberLoc, cast<FieldDecl>(Member)->getType()); return getSema().Owned(ME); } - + CXXScopeSpec SS; if (Qualifier) { SS.setRange(QualifierRange); @@ -915,27 +914,27 @@ public: /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0), &SS); } - + /// \brief Build a new binary operator expression. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildBinaryOperator(SourceLocation OpLoc, BinaryOperator::Opcode Opc, ExprArg LHS, ExprArg RHS) { OwningExprResult Result - = getSema().CreateBuiltinBinOp(OpLoc, Opc, (Expr *)LHS.get(), + = getSema().CreateBuiltinBinOp(OpLoc, Opc, (Expr *)LHS.get(), (Expr *)RHS.get()); if (Result.isInvalid()) return SemaRef.ExprError(); - + LHS.release(); RHS.release(); return move(Result); } /// \brief Build a new conditional operator expression. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildConditionalOperator(ExprArg Cond, @@ -943,25 +942,25 @@ public: ExprArg LHS, SourceLocation ColonLoc, ExprArg RHS) { - return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, move(Cond), + return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, move(Cond), move(LHS), move(RHS)); } /// \brief Build a new implicit cast expression. - /// + /// /// By default, builds a new implicit cast without any semantic analysis. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildImplicitCastExpr(QualType T, CastExpr::CastKind Kind, ExprArg SubExpr, bool isLvalue) { ImplicitCastExpr *ICE - = new (getSema().Context) ImplicitCastExpr(T, Kind, + = new (getSema().Context) ImplicitCastExpr(T, Kind, (Expr *)SubExpr.release(), isLvalue); return getSema().Owned(ICE); } /// \brief Build a new C-style cast expression. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildCStyleCaseExpr(SourceLocation LParenLoc, @@ -974,9 +973,9 @@ public: RParenLoc, move(SubExpr)); } - + /// \brief Build a new compound literal expression. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc, @@ -986,12 +985,12 @@ public: return getSema().ActOnCompoundLiteral(LParenLoc, T.getAsOpaquePtr(), RParenLoc, move(Init)); } - + /// \brief Build a new extended vector element access expression. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. - OwningExprResult RebuildExtVectorElementExpr(ExprArg Base, + OwningExprResult RebuildExtVectorElementExpr(ExprArg Base, SourceLocation OpLoc, SourceLocation AccessorLoc, IdentifierInfo &Accessor) { @@ -1000,9 +999,9 @@ public: Accessor, /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0)); } - + /// \brief Build a new initializer list expression. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildInitList(SourceLocation LBraceLoc, @@ -1010,9 +1009,9 @@ public: SourceLocation RBraceLoc) { return SemaRef.ActOnInitList(LBraceLoc, move(Inits), RBraceLoc); } - + /// \brief Build a new designated initializer expression. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildDesignatedInitExpr(Designation &Desig, @@ -1025,32 +1024,32 @@ public: move(Init)); if (Result.isInvalid()) return SemaRef.ExprError(); - + ArrayExprs.release(); return move(Result); } - + /// \brief Build a new value-initialized expression. - /// + /// /// By default, builds the implicit value initialization without performing /// any semantic analysis. Subclasses may override this routine to provide /// different behavior. OwningExprResult RebuildImplicitValueInitExpr(QualType T) { return SemaRef.Owned(new (SemaRef.Context) ImplicitValueInitExpr(T)); } - + /// \brief Build a new \c va_arg expression. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc, ExprArg SubExpr, QualType T, SourceLocation RParenLoc) { - return getSema().ActOnVAArg(BuiltinLoc, move(SubExpr), T.getAsOpaquePtr(), + return getSema().ActOnVAArg(BuiltinLoc, move(SubExpr), T.getAsOpaquePtr(), RParenLoc); } /// \brief Build a new expression list in parentheses. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildParenListExpr(SourceLocation LParenLoc, @@ -1058,10 +1057,10 @@ public: SourceLocation RParenLoc) { return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, move(SubExprs)); } - + /// \brief Build a new address-of-label expression. - /// - /// By default, performs semantic analysis, using the name of the label + /// + /// By default, performs semantic analysis, using the name of the label /// rather than attempting to map the label statement itself. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc, @@ -1069,9 +1068,9 @@ public: LabelStmt *Label) { return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label->getID()); } - + /// \brief Build a new GNU statement expression. - /// + /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildStmtExpr(SourceLocation LParenLoc, @@ -1079,7 +1078,7 @@ public: SourceLocation RParenLoc) { return getSema().ActOnStmtExpr(LParenLoc, move(SubStmt), RParenLoc); } - + /// \brief Build a new __builtin_types_compatible_p expression. /// /// By default, performs semantic analysis to build the new expression. @@ -1092,7 +1091,7 @@ public: T2.getAsOpaquePtr(), RParenLoc); } - + /// \brief Build a new __builtin_choose_expr expression. /// /// By default, performs semantic analysis to build the new expression. @@ -1104,13 +1103,13 @@ public: move(Cond), move(LHS), move(RHS), RParenLoc); } - + /// \brief Build a new overloaded operator call expression. /// /// By default, performs semantic analysis to build the new expression. /// The semantic analysis provides the behavior of template instantiation, /// copying with transformations that turn what looks like an overloaded - /// operator call into a use of a builtin operator, performing + /// operator call into a use of a builtin operator, performing /// argument-dependent lookup, etc. Subclasses may override this routine to /// provide different behavior. OwningExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, @@ -1118,12 +1117,12 @@ public: ExprArg Callee, ExprArg First, ExprArg Second); - - /// \brief Build a new C++ "named" cast expression, such as static_cast or + + /// \brief Build a new C++ "named" cast expression, such as static_cast or /// reinterpret_cast. /// /// By default, this routine dispatches to one of the more-specific routines - /// for a particular named case, e.g., RebuildCXXStaticCastExpr(). + /// for a particular named case, e.g., RebuildCXXStaticCastExpr(). /// Subclasses may override this routine to provide different behavior. OwningExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc, Stmt::StmtClass Class, @@ -1135,34 +1134,34 @@ public: SourceLocation RParenLoc) { switch (Class) { case Stmt::CXXStaticCastExprClass: - return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, T, - RAngleLoc, LParenLoc, + return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, T, + RAngleLoc, LParenLoc, move(SubExpr), RParenLoc); case Stmt::CXXDynamicCastExprClass: - return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, T, - RAngleLoc, LParenLoc, + return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, T, + RAngleLoc, LParenLoc, move(SubExpr), RParenLoc); - + case Stmt::CXXReinterpretCastExprClass: - return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, T, - RAngleLoc, LParenLoc, - move(SubExpr), + return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, T, + RAngleLoc, LParenLoc, + move(SubExpr), RParenLoc); - + case Stmt::CXXConstCastExprClass: - return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, T, - RAngleLoc, LParenLoc, + return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, T, + RAngleLoc, LParenLoc, move(SubExpr), RParenLoc); - + default: assert(false && "Invalid C++ named cast"); break; } - + return getSema().ExprError(); } - + /// \brief Build a new C++ static_cast expression. /// /// By default, performs semantic analysis to build the new expression. @@ -1175,7 +1174,7 @@ public: ExprArg SubExpr, SourceLocation RParenLoc) { return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_static_cast, - LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, + LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, LParenLoc, move(SubExpr), RParenLoc); } @@ -1191,7 +1190,7 @@ public: ExprArg SubExpr, SourceLocation RParenLoc) { return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_dynamic_cast, - LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, + LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, LParenLoc, move(SubExpr), RParenLoc); } @@ -1223,10 +1222,10 @@ public: ExprArg SubExpr, SourceLocation RParenLoc) { return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_const_cast, - LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, + LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, LParenLoc, move(SubExpr), RParenLoc); } - + /// \brief Build a new C++ functional-style cast expression. /// /// By default, performs semantic analysis to build the new expression. @@ -1241,10 +1240,10 @@ public: T.getAsOpaquePtr(), LParenLoc, Sema::MultiExprArg(getSema(), &Sub, 1), - /*CommaLocs=*/0, + /*CommaLocs=*/0, RParenLoc); } - + /// \brief Build a new C++ typeid(type) expression. /// /// By default, performs semantic analysis to build the new expression. @@ -1253,10 +1252,10 @@ public: SourceLocation LParenLoc, QualType T, SourceLocation RParenLoc) { - return getSema().ActOnCXXTypeid(TypeidLoc, LParenLoc, true, + return getSema().ActOnCXXTypeid(TypeidLoc, LParenLoc, true, T.getAsOpaquePtr(), RParenLoc); } - + /// \brief Build a new C++ typeid(expr) expression. /// /// By default, performs semantic analysis to build the new expression. @@ -1265,22 +1264,22 @@ public: SourceLocation LParenLoc, ExprArg Operand, SourceLocation RParenLoc) { - OwningExprResult Result + OwningExprResult Result = getSema().ActOnCXXTypeid(TypeidLoc, LParenLoc, false, Operand.get(), RParenLoc); if (Result.isInvalid()) return getSema().ExprError(); - + Operand.release(); // FIXME: since ActOnCXXTypeid silently took ownership return move(Result); - } - + } + /// \brief Build a new C++ "this" expression. /// /// By default, builds a new "this" expression without performing any - /// semantic analysis. Subclasses may override this routine to provide + /// semantic analysis. Subclasses may override this routine to provide /// different behavior. - OwningExprResult RebuildCXXThisExpr(SourceLocation ThisLoc, + OwningExprResult RebuildCXXThisExpr(SourceLocation ThisLoc, QualType ThisType) { return getSema().Owned( new (getSema().Context) CXXThisExpr(ThisLoc, ThisType)); @@ -1307,38 +1306,38 @@ public: /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. - OwningExprResult RebuildCXXZeroInitValueExpr(SourceLocation TypeStartLoc, + OwningExprResult RebuildCXXZeroInitValueExpr(SourceLocation TypeStartLoc, SourceLocation LParenLoc, QualType T, SourceLocation RParenLoc) { - return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeStartLoc), - T.getAsOpaquePtr(), LParenLoc, - MultiExprArg(getSema(), 0, 0), + return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeStartLoc), + T.getAsOpaquePtr(), LParenLoc, + MultiExprArg(getSema(), 0, 0), 0, RParenLoc); } - + /// \brief Build a new C++ conditional declaration expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. - OwningExprResult RebuildCXXConditionDeclExpr(SourceLocation StartLoc, + OwningExprResult RebuildCXXConditionDeclExpr(SourceLocation StartLoc, SourceLocation EqLoc, VarDecl *Var) { return SemaRef.Owned(new (SemaRef.Context) CXXConditionDeclExpr(StartLoc, EqLoc, Var)); } - + /// \brief Build a new C++ "new" expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. - OwningExprResult RebuildCXXNewExpr(SourceLocation StartLoc, + OwningExprResult RebuildCXXNewExpr(SourceLocation StartLoc, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, - bool ParenTypeId, + bool ParenTypeId, QualType AllocType, SourceLocation TypeLoc, SourceRange TypeRange, @@ -1346,7 +1345,7 @@ public: SourceLocation ConstructorLParen, MultiExprArg ConstructorArgs, SourceLocation ConstructorRParen) { - return getSema().BuildCXXNew(StartLoc, UseGlobal, + return getSema().BuildCXXNew(StartLoc, UseGlobal, PlacementLParen, move(PlacementArgs), PlacementRParen, @@ -1359,7 +1358,7 @@ public: move(ConstructorArgs), ConstructorRParen); } - + /// \brief Build a new C++ "delete" expression. /// /// By default, performs semantic analysis to build the new expression. @@ -1371,7 +1370,7 @@ public: return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm, move(Operand)); } - + /// \brief Build a new unary type trait expression. /// /// By default, performs semantic analysis to build the new expression. @@ -1381,7 +1380,7 @@ public: SourceLocation LParenLoc, QualType T, SourceLocation RParenLoc) { - return getSema().ActOnUnaryTypeTrait(Trait, StartLoc, LParenLoc, + return getSema().ActOnUnaryTypeTrait(Trait, StartLoc, LParenLoc, T.getAsOpaquePtr(), RParenLoc); } @@ -1397,7 +1396,7 @@ public: CXXScopeSpec SS; SS.setRange(QualifierRange); SS.setScopeRep(NNS); - return getSema().ActOnDeclarationNameExpr(/*Scope=*/0, + return getSema().ActOnDeclarationNameExpr(/*Scope=*/0, Location, ND->getDeclName(), /*Trailing lparen=*/false, @@ -1405,7 +1404,7 @@ public: IsAddressOfOperand); } - /// \brief Build a new (previously unresolved) declaration reference + /// \brief Build a new (previously unresolved) declaration reference /// expression. /// /// By default, performs semantic analysis to build the new expression. @@ -1418,7 +1417,7 @@ public: CXXScopeSpec SS; SS.setRange(QualifierRange); SS.setScopeRep(NNS); - return getSema().ActOnDeclarationNameExpr(/*Scope=*/0, + return getSema().ActOnDeclarationNameExpr(/*Scope=*/0, Location, Name, /*Trailing lparen=*/false, @@ -1492,7 +1491,7 @@ public: Commas, RParenLoc); } - + /// \brief Build a new member reference expression. /// /// By default, performs semantic analysis to build the new expression. @@ -1511,7 +1510,7 @@ public: CXXScopeSpec SS; SS.setRange(QualifierRange); SS.setScopeRep(Qualifier); - + return SemaRef.BuildMemberReferenceExpr(/*Scope=*/0, move(Base), OperatorLoc, OpKind, MemberLoc, @@ -1540,30 +1539,30 @@ public: SourceLocation RAngleLoc) { OwningExprResult Base = move(BaseE); tok::TokenKind OpKind = IsArrow? tok::arrow : tok::period; - + CXXScopeSpec SS; SS.setRange(QualifierRange); SS.setScopeRep(Qualifier); - + // FIXME: We're going to end up looking up the template based on its name, // twice! Also, duplicates part of Sema::ActOnMemberTemplateIdReferenceExpr. DeclarationName Name; if (TemplateDecl *ActualTemplate = Template.getAsTemplateDecl()) Name = ActualTemplate->getDeclName(); - else if (OverloadedFunctionDecl *Ovl + else if (OverloadedFunctionDecl *Ovl = Template.getAsOverloadedFunctionDecl()) Name = Ovl->getDeclName(); else Name = Template.getAsDependentTemplateName()->getName(); - - return SemaRef.BuildMemberReferenceExpr(/*Scope=*/0, move(Base), + + return SemaRef.BuildMemberReferenceExpr(/*Scope=*/0, move(Base), OperatorLoc, OpKind, TemplateNameLoc, Name, true, LAngleLoc, TemplateArgs, NumTemplateArgs, RAngleLoc, Sema::DeclPtrTy(), &SS); } - + /// \brief Build a new Objective-C @encode expression. /// /// By default, performs semantic analysis to build the new expression. @@ -1573,7 +1572,7 @@ public: SourceLocation RParenLoc) { return SemaRef.Owned(SemaRef.BuildObjCEncodeExpression(AtLoc, T, RParenLoc)); - } + } /// \brief Build a new Objective-C protocol expression. /// @@ -1589,9 +1588,9 @@ public: AtLoc, ProtoLoc, LParenLoc, - RParenLoc)); + RParenLoc)); } - + /// \brief Build a new shuffle vector expression. /// /// By default, performs semantic analysis to build the new expression. @@ -1600,20 +1599,20 @@ public: MultiExprArg SubExprs, SourceLocation RParenLoc) { // Find the declaration for __builtin_shufflevector - const IdentifierInfo &Name + const IdentifierInfo &Name = SemaRef.Context.Idents.get("__builtin_shufflevector"); TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl(); DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name)); assert(Lookup.first != Lookup.second && "No __builtin_shufflevector?"); - + // Build a reference to the __builtin_shufflevector builtin FunctionDecl *Builtin = cast<FunctionDecl>(*Lookup.first); - Expr *Callee + Expr *Callee = new (SemaRef.Context) DeclRefExpr(Builtin, Builtin->getType(), BuiltinLoc, false, false); SemaRef.UsualUnaryConversions(Callee); - - // Build the CallExpr + + // Build the CallExpr unsigned NumSubExprs = SubExprs.size(); Expr **Subs = (Expr **)SubExprs.release(); CallExpr *TheCall = new (SemaRef.Context) CallExpr(SemaRef.Context, Callee, @@ -1621,14 +1620,14 @@ public: Builtin->getResultType(), RParenLoc); OwningExprResult OwnedCall(SemaRef.Owned(TheCall)); - + // Type-check the __builtin_shufflevector expression. OwningExprResult Result = SemaRef.SemaBuiltinShuffleVector(TheCall); if (Result.isInvalid()) return SemaRef.ExprError(); - + OwnedCall.release(); - return move(Result); + return move(Result); } }; @@ -1636,16 +1635,16 @@ template<typename Derived> Sema::OwningStmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) { if (!S) return SemaRef.Owned(S); - + switch (S->getStmtClass()) { case Stmt::NoStmtClass: break; - + // Transform individual statement nodes #define STMT(Node, Parent) \ case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S)); #define EXPR(Node, Parent) #include "clang/AST/StmtNodes.def" - + // Transform expressions by calling TransformExpr. #define STMT(Node, Parent) #define EXPR(Node, Parent) case Stmt::Node##Class: @@ -1654,15 +1653,15 @@ Sema::OwningStmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) { Sema::OwningExprResult E = getDerived().TransformExpr(cast<Expr>(S)); if (E.isInvalid()) return getSema().StmtError(); - + return getSema().Owned(E.takeAs<Stmt>()); } - } - + } + return SemaRef.Owned(S->Retain()); } - - + + template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformExpr(Expr *E, bool isAddressOfOperand) { @@ -1675,8 +1674,8 @@ Sema::OwningExprResult TreeTransform<Derived>::TransformExpr(Expr *E, #define EXPR(Node, Parent) \ case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E)); #include "clang/AST/StmtNodes.def" - } - + } + return SemaRef.Owned(E->Retain()); } @@ -1688,75 +1687,75 @@ TreeTransform<Derived>::TransformNestedNameSpecifier(NestedNameSpecifier *NNS, NamedDecl *FirstQualifierInScope) { if (!NNS) return 0; - + // Transform the prefix of this nested name specifier. NestedNameSpecifier *Prefix = NNS->getPrefix(); if (Prefix) { - Prefix = getDerived().TransformNestedNameSpecifier(Prefix, Range, + Prefix = getDerived().TransformNestedNameSpecifier(Prefix, Range, ObjectType, FirstQualifierInScope); if (!Prefix) return 0; - - // Clear out the object type and the first qualifier in scope; they only + + // Clear out the object type and the first qualifier in scope; they only // apply to the first element in the nested-name-specifier. ObjectType = QualType(); FirstQualifierInScope = 0; } - + switch (NNS->getKind()) { case NestedNameSpecifier::Identifier: - assert((Prefix || !ObjectType.isNull()) && + assert((Prefix || !ObjectType.isNull()) && "Identifier nested-name-specifier with no prefix or object type"); if (!getDerived().AlwaysRebuild() && Prefix == NNS->getPrefix() && ObjectType.isNull()) return NNS; - - return getDerived().RebuildNestedNameSpecifier(Prefix, Range, + + return getDerived().RebuildNestedNameSpecifier(Prefix, Range, *NNS->getAsIdentifier(), ObjectType, FirstQualifierInScope); - + case NestedNameSpecifier::Namespace: { - NamespaceDecl *NS + NamespaceDecl *NS = cast_or_null<NamespaceDecl>( getDerived().TransformDecl(NNS->getAsNamespace())); - if (!getDerived().AlwaysRebuild() && + if (!getDerived().AlwaysRebuild() && Prefix == NNS->getPrefix() && NS == NNS->getAsNamespace()) return NNS; - + return getDerived().RebuildNestedNameSpecifier(Prefix, Range, NS); } - + case NestedNameSpecifier::Global: // There is no meaningful transformation that one could perform on the // global scope. return NNS; - + case NestedNameSpecifier::TypeSpecWithTemplate: case NestedNameSpecifier::TypeSpec: { QualType T = getDerived().TransformType(QualType(NNS->getAsType(), 0)); if (T.isNull()) return 0; - + if (!getDerived().AlwaysRebuild() && Prefix == NNS->getPrefix() && T == QualType(NNS->getAsType(), 0)) return NNS; - - return getDerived().RebuildNestedNameSpecifier(Prefix, Range, - NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate, + + return getDerived().RebuildNestedNameSpecifier(Prefix, Range, + NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate, T); } } - + // Required to silence a GCC warning - return 0; + return 0; } template<typename Derived> -DeclarationName +DeclarationName TreeTransform<Derived>::TransformDeclarationName(DeclarationName Name, SourceLocation Loc) { if (!Name) @@ -1770,7 +1769,7 @@ TreeTransform<Derived>::TransformDeclarationName(DeclarationName Name, case DeclarationName::CXXOperatorName: case DeclarationName::CXXUsingDirective: return Name; - + case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: { @@ -1778,151 +1777,151 @@ TreeTransform<Derived>::TransformDeclarationName(DeclarationName Name, QualType T = getDerived().TransformType(Name.getCXXNameType()); if (T.isNull()) return DeclarationName(); - + return SemaRef.Context.DeclarationNames.getCXXSpecialName( - Name.getNameKind(), + Name.getNameKind(), SemaRef.Context.getCanonicalType(T)); - } } - + } + return DeclarationName(); } template<typename Derived> -TemplateName +TemplateName TreeTransform<Derived>::TransformTemplateName(TemplateName Name, QualType ObjectType) { if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) { - NestedNameSpecifier *NNS + NestedNameSpecifier *NNS = getDerived().TransformNestedNameSpecifier(QTN->getQualifier(), /*FIXME:*/SourceRange(getDerived().getBaseLocation())); if (!NNS) return TemplateName(); - + if (TemplateDecl *Template = QTN->getTemplateDecl()) { - TemplateDecl *TransTemplate + TemplateDecl *TransTemplate = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Template)); if (!TransTemplate) return TemplateName(); - + if (!getDerived().AlwaysRebuild() && NNS == QTN->getQualifier() && TransTemplate == Template) return Name; - + return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(), TransTemplate); } - + OverloadedFunctionDecl *Ovl = QTN->getOverloadedFunctionDecl(); assert(Ovl && "Not a template name or an overload set?"); - OverloadedFunctionDecl *TransOvl + OverloadedFunctionDecl *TransOvl = cast_or_null<OverloadedFunctionDecl>(getDerived().TransformDecl(Ovl)); if (!TransOvl) return TemplateName(); - + if (!getDerived().AlwaysRebuild() && NNS == QTN->getQualifier() && TransOvl == Ovl) return Name; - + return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(), TransOvl); } - + if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) { - NestedNameSpecifier *NNS + NestedNameSpecifier *NNS = getDerived().TransformNestedNameSpecifier(DTN->getQualifier(), /*FIXME:*/SourceRange(getDerived().getBaseLocation())); if (!NNS && DTN->getQualifier()) return TemplateName(); - + if (!getDerived().AlwaysRebuild() && NNS == DTN->getQualifier()) return Name; - + return getDerived().RebuildTemplateName(NNS, *DTN->getName(), ObjectType); } - + if (TemplateDecl *Template = Name.getAsTemplateDecl()) { - TemplateDecl *TransTemplate + TemplateDecl *TransTemplate = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Template)); if (!TransTemplate) return TemplateName(); - + if (!getDerived().AlwaysRebuild() && TransTemplate == Template) return Name; - + return TemplateName(TransTemplate); } - + OverloadedFunctionDecl *Ovl = Name.getAsOverloadedFunctionDecl(); assert(Ovl && "Not a template name or an overload set?"); - OverloadedFunctionDecl *TransOvl + OverloadedFunctionDecl *TransOvl = cast_or_null<OverloadedFunctionDecl>(getDerived().TransformDecl(Ovl)); if (!TransOvl) return TemplateName(); - + if (!getDerived().AlwaysRebuild() && TransOvl == Ovl) return Name; - + return TemplateName(TransOvl); } template<typename Derived> -TemplateArgument +TemplateArgument TreeTransform<Derived>::TransformTemplateArgument(const TemplateArgument &Arg) { switch (Arg.getKind()) { case TemplateArgument::Null: case TemplateArgument::Integral: return Arg; - + case TemplateArgument::Type: { QualType T = getDerived().TransformType(Arg.getAsType()); if (T.isNull()) return TemplateArgument(); return TemplateArgument(Arg.getLocation(), T); } - + case TemplateArgument::Declaration: { Decl *D = getDerived().TransformDecl(Arg.getAsDecl()); if (!D) return TemplateArgument(); return TemplateArgument(Arg.getLocation(), D); } - + case TemplateArgument::Expression: { // Template argument expressions are not potentially evaluated. - EnterExpressionEvaluationContext Unevaluated(getSema(), + EnterExpressionEvaluationContext Unevaluated(getSema(), Action::Unevaluated); - + Sema::OwningExprResult E = getDerived().TransformExpr(Arg.getAsExpr()); if (E.isInvalid()) return TemplateArgument(); return TemplateArgument(E.takeAs<Expr>()); } - + case TemplateArgument::Pack: { llvm::SmallVector<TemplateArgument, 4> TransformedArgs; TransformedArgs.reserve(Arg.pack_size()); - for (TemplateArgument::pack_iterator A = Arg.pack_begin(), + for (TemplateArgument::pack_iterator A = Arg.pack_begin(), AEnd = Arg.pack_end(); A != AEnd; ++A) { TemplateArgument TA = getDerived().TransformTemplateArgument(*A); if (TA.isNull()) return TA; - + TransformedArgs.push_back(TA); } TemplateArgument Result; - Result.setArgumentPack(TransformedArgs.data(), TransformedArgs.size(), + Result.setArgumentPack(TransformedArgs.data(), TransformedArgs.size(), true); return Result; } } - + // Work around bogus GCC warning return TemplateArgument(); } @@ -1935,126 +1934,126 @@ template<typename Derived> QualType TreeTransform<Derived>::TransformType(QualType T) { if (getDerived().AlreadyTransformed(T)) return T; - + QualType Result; switch (T->getTypeClass()) { -#define ABSTRACT_TYPE(CLASS, PARENT) +#define ABSTRACT_TYPE(CLASS, PARENT) #define TYPE(CLASS, PARENT) \ case Type::CLASS: \ Result = getDerived().Transform##CLASS##Type( \ static_cast<CLASS##Type*>(T.getTypePtr())); \ break; -#include "clang/AST/TypeNodes.def" +#include "clang/AST/TypeNodes.def" } - + if (Result.isNull() || T == Result) return Result; - + return getDerived().AddTypeQualifiers(Result, T.getCVRQualifiers()); } - + template<typename Derived> -QualType +QualType TreeTransform<Derived>::AddTypeQualifiers(QualType T, unsigned CVRQualifiers) { if (CVRQualifiers && !T->isFunctionType() && !T->isReferenceType()) return T.getWithAdditionalQualifiers(CVRQualifiers); - + return T; } -template<typename Derived> -QualType TreeTransform<Derived>::TransformExtQualType(const ExtQualType *T) { +template<typename Derived> +QualType TreeTransform<Derived>::TransformExtQualType(const ExtQualType *T) { // FIXME: Implement - return QualType(T, 0); + return QualType(T, 0); } - + template<typename Derived> -QualType TreeTransform<Derived>::TransformBuiltinType(const BuiltinType *T) { +QualType TreeTransform<Derived>::TransformBuiltinType(const BuiltinType *T) { // Nothing to do - return QualType(T, 0); + return QualType(T, 0); } - -template<typename Derived> + +template<typename Derived> QualType TreeTransform<Derived>::TransformFixedWidthIntType( - const FixedWidthIntType *T) { + const FixedWidthIntType *T) { // FIXME: Implement - return QualType(T, 0); + return QualType(T, 0); } - + template<typename Derived> -QualType TreeTransform<Derived>::TransformComplexType(const ComplexType *T) { +QualType TreeTransform<Derived>::TransformComplexType(const ComplexType *T) { // FIXME: Implement - return QualType(T, 0); + return QualType(T, 0); } - -template<typename Derived> + +template<typename Derived> QualType TreeTransform<Derived>::TransformPointerType(const PointerType *T) { QualType PointeeType = getDerived().TransformType(T->getPointeeType()); if (PointeeType.isNull()) return QualType(); - + if (!getDerived().AlwaysRebuild() && PointeeType == T->getPointeeType()) return QualType(T, 0); return getDerived().RebuildPointerType(PointeeType); } - -template<typename Derived> -QualType -TreeTransform<Derived>::TransformBlockPointerType(const BlockPointerType *T) { + +template<typename Derived> +QualType +TreeTransform<Derived>::TransformBlockPointerType(const BlockPointerType *T) { QualType PointeeType = getDerived().TransformType(T->getPointeeType()); if (PointeeType.isNull()) return QualType(); - + if (!getDerived().AlwaysRebuild() && PointeeType == T->getPointeeType()) return QualType(T, 0); - + return getDerived().RebuildBlockPointerType(PointeeType); } -template<typename Derived> -QualType +template<typename Derived> +QualType TreeTransform<Derived>::TransformLValueReferenceType( - const LValueReferenceType *T) { + const LValueReferenceType *T) { QualType PointeeType = getDerived().TransformType(T->getPointeeType()); if (PointeeType.isNull()) return QualType(); - + if (!getDerived().AlwaysRebuild() && PointeeType == T->getPointeeType()) return QualType(T, 0); - + return getDerived().RebuildLValueReferenceType(PointeeType); } -template<typename Derived> -QualType +template<typename Derived> +QualType TreeTransform<Derived>::TransformRValueReferenceType( - const RValueReferenceType *T) { + const RValueReferenceType *T) { QualType PointeeType = getDerived().TransformType(T->getPointeeType()); if (PointeeType.isNull()) return QualType(); - + if (!getDerived().AlwaysRebuild() && PointeeType == T->getPointeeType()) return QualType(T, 0); - + return getDerived().RebuildRValueReferenceType(PointeeType); } - + template<typename Derived> -QualType -TreeTransform<Derived>::TransformMemberPointerType(const MemberPointerType *T) { +QualType +TreeTransform<Derived>::TransformMemberPointerType(const MemberPointerType *T) { QualType PointeeType = getDerived().TransformType(T->getPointeeType()); if (PointeeType.isNull()) return QualType(); - + QualType ClassType = getDerived().TransformType(QualType(T->getClass(), 0)); if (ClassType.isNull()) return QualType(); - + if (!getDerived().AlwaysRebuild() && PointeeType == T->getPointeeType() && ClassType == QualType(T->getClass(), 0)) @@ -2063,76 +2062,76 @@ TreeTransform<Derived>::TransformMemberPointerType(const MemberPointerType *T) { return getDerived().RebuildMemberPointerType(PointeeType, ClassType); } -template<typename Derived> -QualType -TreeTransform<Derived>::TransformConstantArrayType(const ConstantArrayType *T) { +template<typename Derived> +QualType +TreeTransform<Derived>::TransformConstantArrayType(const ConstantArrayType *T) { QualType ElementType = getDerived().TransformType(T->getElementType()); if (ElementType.isNull()) return QualType(); - + if (!getDerived().AlwaysRebuild() && ElementType == T->getElementType()) return QualType(T, 0); - - return getDerived().RebuildConstantArrayType(ElementType, + + return getDerived().RebuildConstantArrayType(ElementType, T->getSizeModifier(), T->getSize(), T->getIndexTypeQualifier()); } - + template<typename Derived> -QualType +QualType TreeTransform<Derived>::TransformConstantArrayWithExprType( - const ConstantArrayWithExprType *T) { + const ConstantArrayWithExprType *T) { QualType ElementType = getDerived().TransformType(T->getElementType()); if (ElementType.isNull()) return QualType(); - + // Array bounds are not potentially evaluated contexts EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); - + Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); if (Size.isInvalid()) return QualType(); - + if (!getDerived().AlwaysRebuild() && ElementType == T->getElementType() && Size.get() == T->getSizeExpr()) return QualType(T, 0); - - return getDerived().RebuildConstantArrayWithExprType(ElementType, + + return getDerived().RebuildConstantArrayWithExprType(ElementType, T->getSizeModifier(), T->getSize(), Size.takeAs<Expr>(), T->getIndexTypeQualifier(), T->getBracketsRange()); } - -template<typename Derived> -QualType + +template<typename Derived> +QualType TreeTransform<Derived>::TransformConstantArrayWithoutExprType( - const ConstantArrayWithoutExprType *T) { + const ConstantArrayWithoutExprType *T) { QualType ElementType = getDerived().TransformType(T->getElementType()); if (ElementType.isNull()) return QualType(); - + if (!getDerived().AlwaysRebuild() && ElementType == T->getElementType()) return QualType(T, 0); - - return getDerived().RebuildConstantArrayWithoutExprType(ElementType, + + return getDerived().RebuildConstantArrayWithoutExprType(ElementType, T->getSizeModifier(), T->getSize(), T->getIndexTypeQualifier()); } -template<typename Derived> +template<typename Derived> QualType TreeTransform<Derived>::TransformIncompleteArrayType( - const IncompleteArrayType *T) { + const IncompleteArrayType *T) { QualType ElementType = getDerived().TransformType(T->getElementType()); if (ElementType.isNull()) return QualType(); - + if (!getDerived().AlwaysRebuild() && ElementType == T->getElementType()) return QualType(T, 0); @@ -2141,91 +2140,91 @@ QualType TreeTransform<Derived>::TransformIncompleteArrayType( T->getSizeModifier(), T->getIndexTypeQualifier()); } - + template<typename Derived> QualType TreeTransform<Derived>::TransformVariableArrayType( - const VariableArrayType *T) { + const VariableArrayType *T) { QualType ElementType = getDerived().TransformType(T->getElementType()); if (ElementType.isNull()) return QualType(); - + // Array bounds are not potentially evaluated contexts EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); if (Size.isInvalid()) return QualType(); - + if (!getDerived().AlwaysRebuild() && ElementType == T->getElementType() && Size.get() == T->getSizeExpr()) { Size.take(); return QualType(T, 0); } - - return getDerived().RebuildVariableArrayType(ElementType, + + return getDerived().RebuildVariableArrayType(ElementType, T->getSizeModifier(), move(Size), T->getIndexTypeQualifier(), T->getBracketsRange()); } - -template<typename Derived> + +template<typename Derived> QualType TreeTransform<Derived>::TransformDependentSizedArrayType( - const DependentSizedArrayType *T) { + const DependentSizedArrayType *T) { QualType ElementType = getDerived().TransformType(T->getElementType()); if (ElementType.isNull()) return QualType(); - + // Array bounds are not potentially evaluated contexts EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); - + Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); if (Size.isInvalid()) return QualType(); - + if (!getDerived().AlwaysRebuild() && ElementType == T->getElementType() && Size.get() == T->getSizeExpr()) { Size.take(); return QualType(T, 0); } - - return getDerived().RebuildDependentSizedArrayType(ElementType, + + return getDerived().RebuildDependentSizedArrayType(ElementType, T->getSizeModifier(), move(Size), T->getIndexTypeQualifier(), T->getBracketsRange()); } - -template<typename Derived> + +template<typename Derived> QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType( - const DependentSizedExtVectorType *T) { + const DependentSizedExtVectorType *T) { QualType ElementType = getDerived().TransformType(T->getElementType()); if (ElementType.isNull()) return QualType(); - + // Vector sizes are not potentially evaluated contexts EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); if (Size.isInvalid()) return QualType(); - + if (!getDerived().AlwaysRebuild() && ElementType == T->getElementType() && Size.get() == T->getSizeExpr()) { Size.take(); return QualType(T, 0); } - - return getDerived().RebuildDependentSizedExtVectorType(ElementType, + + return getDerived().RebuildDependentSizedExtVectorType(ElementType, move(Size), T->getAttributeLoc()); } - -template<typename Derived> -QualType TreeTransform<Derived>::TransformVectorType(const VectorType *T) { + +template<typename Derived> +QualType TreeTransform<Derived>::TransformVectorType(const VectorType *T) { QualType ElementType = getDerived().TransformType(T->getElementType()); if (ElementType.isNull()) return QualType(); @@ -2233,80 +2232,80 @@ QualType TreeTransform<Derived>::TransformVectorType(const VectorType *T) { if (!getDerived().AlwaysRebuild() && ElementType == T->getElementType()) return QualType(T, 0); - + return getDerived().RebuildVectorType(ElementType, T->getNumElements()); } - -template<typename Derived> -QualType -TreeTransform<Derived>::TransformExtVectorType(const ExtVectorType *T) { + +template<typename Derived> +QualType +TreeTransform<Derived>::TransformExtVectorType(const ExtVectorType *T) { QualType ElementType = getDerived().TransformType(T->getElementType()); if (ElementType.isNull()) return QualType(); - + if (!getDerived().AlwaysRebuild() && ElementType == T->getElementType()) return QualType(T, 0); - + return getDerived().RebuildExtVectorType(ElementType, T->getNumElements(), /*FIXME*/SourceLocation()); } -template<typename Derived> +template<typename Derived> QualType TreeTransform<Derived>::TransformFunctionProtoType( - const FunctionProtoType *T) { + const FunctionProtoType *T) { QualType ResultType = getDerived().TransformType(T->getResultType()); if (ResultType.isNull()) return QualType(); - + llvm::SmallVector<QualType, 4> ParamTypes; for (FunctionProtoType::arg_type_iterator Param = T->arg_type_begin(), - ParamEnd = T->arg_type_end(); + ParamEnd = T->arg_type_end(); Param != ParamEnd; ++Param) { QualType P = getDerived().TransformType(*Param); if (P.isNull()) return QualType(); - + ParamTypes.push_back(P); } - + if (!getDerived().AlwaysRebuild() && ResultType == T->getResultType() && std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) return QualType(T, 0); - - return getDerived().RebuildFunctionProtoType(ResultType, ParamTypes.data(), + + return getDerived().RebuildFunctionProtoType(ResultType, ParamTypes.data(), ParamTypes.size(), T->isVariadic(), T->getTypeQuals()); } - + template<typename Derived> QualType TreeTransform<Derived>::TransformFunctionNoProtoType( - const FunctionNoProtoType *T) { + const FunctionNoProtoType *T) { // FIXME: Implement - return QualType(T, 0); + return QualType(T, 0); } - + template<typename Derived> -QualType TreeTransform<Derived>::TransformTypedefType(const TypedefType *T) { +QualType TreeTransform<Derived>::TransformTypedefType(const TypedefType *T) { TypedefDecl *Typedef = cast_or_null<TypedefDecl>(getDerived().TransformDecl(T->getDecl())); if (!Typedef) return QualType(); - + if (!getDerived().AlwaysRebuild() && Typedef == T->getDecl()) return QualType(T, 0); - + return getDerived().RebuildTypedefType(Typedef); } - + template<typename Derived> QualType TreeTransform<Derived>::TransformTypeOfExprType( - const TypeOfExprType *T) { + const TypeOfExprType *T) { // typeof expressions are not potentially evaluated contexts EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); - + Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); if (E.isInvalid()) return QualType(); @@ -2316,66 +2315,66 @@ QualType TreeTransform<Derived>::TransformTypeOfExprType( E.take(); return QualType(T, 0); } - + return getDerived().RebuildTypeOfExprType(move(E)); } - -template<typename Derived> -QualType TreeTransform<Derived>::TransformTypeOfType(const TypeOfType *T) { + +template<typename Derived> +QualType TreeTransform<Derived>::TransformTypeOfType(const TypeOfType *T) { QualType Underlying = getDerived().TransformType(T->getUnderlyingType()); if (Underlying.isNull()) return QualType(); - + if (!getDerived().AlwaysRebuild() && Underlying == T->getUnderlyingType()) return QualType(T, 0); - + return getDerived().RebuildTypeOfType(Underlying); } - -template<typename Derived> -QualType TreeTransform<Derived>::TransformDecltypeType(const DecltypeType *T) { + +template<typename Derived> +QualType TreeTransform<Derived>::TransformDecltypeType(const DecltypeType *T) { // decltype expressions are not potentially evaluated contexts EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); - + Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); if (E.isInvalid()) return QualType(); - + if (!getDerived().AlwaysRebuild() && E.get() == T->getUnderlyingExpr()) { E.take(); return QualType(T, 0); } - + return getDerived().RebuildDecltypeType(move(E)); } template<typename Derived> -QualType TreeTransform<Derived>::TransformRecordType(const RecordType *T) { +QualType TreeTransform<Derived>::TransformRecordType(const RecordType *T) { RecordDecl *Record = cast_or_null<RecordDecl>(getDerived().TransformDecl(T->getDecl())); if (!Record) return QualType(); - + if (!getDerived().AlwaysRebuild() && Record == T->getDecl()) return QualType(T, 0); - + return getDerived().RebuildRecordType(Record); } - -template<typename Derived> -QualType TreeTransform<Derived>::TransformEnumType(const EnumType *T) { + +template<typename Derived> +QualType TreeTransform<Derived>::TransformEnumType(const EnumType *T) { EnumDecl *Enum = cast_or_null<EnumDecl>(getDerived().TransformDecl(T->getDecl())); if (!Enum) return QualType(); - + if (!getDerived().AlwaysRebuild() && Enum == T->getDecl()) return QualType(T, 0); - + return getDerived().RebuildEnumType(Enum); } @@ -2385,30 +2384,30 @@ QualType TreeTransform<Derived>::TransformElaboratedType( QualType Underlying = getDerived().TransformType(T->getUnderlyingType()); if (Underlying.isNull()) return QualType(); - + if (!getDerived().AlwaysRebuild() && Underlying == T->getUnderlyingType()) return QualType(T, 0); - + return getDerived().RebuildElaboratedType(Underlying, T->getTagKind()); } - - + + template<typename Derived> QualType TreeTransform<Derived>::TransformTemplateTypeParmType( - const TemplateTypeParmType *T) { + const TemplateTypeParmType *T) { // Nothing to do - return QualType(T, 0); + return QualType(T, 0); } -template<typename Derived> +template<typename Derived> QualType TreeTransform<Derived>::TransformTemplateSpecializationType( - const TemplateSpecializationType *T) { - TemplateName Template + const TemplateSpecializationType *T) { + TemplateName Template = getDerived().TransformTemplateName(T->getTemplateName()); if (Template.isNull()) return QualType(); - + llvm::SmallVector<TemplateArgument, 4> NewTemplateArgs; NewTemplateArgs.reserve(T->getNumArgs()); for (TemplateSpecializationType::iterator Arg = T->begin(), ArgEnd = T->end(); @@ -2416,20 +2415,20 @@ QualType TreeTransform<Derived>::TransformTemplateSpecializationType( TemplateArgument NewArg = getDerived().TransformTemplateArgument(*Arg); if (NewArg.isNull()) return QualType(); - + NewTemplateArgs.push_back(NewArg); } - + // FIXME: early abort if all of the template arguments and such are the // same. - + // FIXME: We're missing the locations of the template name, '<', and '>'. return getDerived().RebuildTemplateSpecializationType(Template, NewTemplateArgs.data(), NewTemplateArgs.size()); } - -template<typename Derived> + +template<typename Derived> QualType TreeTransform<Derived>::TransformQualifiedNameType( const QualifiedNameType *T) { NestedNameSpecifier *NNS @@ -2437,11 +2436,11 @@ QualType TreeTransform<Derived>::TransformQualifiedNameType( SourceRange()); if (!NNS) return QualType(); - + QualType Named = getDerived().TransformType(T->getNamedType()); if (Named.isNull()) return QualType(); - + if (!getDerived().AlwaysRebuild() && NNS == T->getQualifier() && Named == T->getNamedType()) @@ -2449,44 +2448,44 @@ QualType TreeTransform<Derived>::TransformQualifiedNameType( return getDerived().RebuildQualifiedNameType(NNS, Named); } - -template<typename Derived> + +template<typename Derived> QualType TreeTransform<Derived>::TransformTypenameType(const TypenameType *T) { NestedNameSpecifier *NNS = getDerived().TransformNestedNameSpecifier(T->getQualifier(), SourceRange(/*FIXME:*/getDerived().getBaseLocation())); if (!NNS) return QualType(); - + if (const TemplateSpecializationType *TemplateId = T->getTemplateId()) { - QualType NewTemplateId + QualType NewTemplateId = getDerived().TransformType(QualType(TemplateId, 0)); if (NewTemplateId.isNull()) return QualType(); - + if (!getDerived().AlwaysRebuild() && NNS == T->getQualifier() && NewTemplateId == QualType(TemplateId, 0)) return QualType(T, 0); - + return getDerived().RebuildTypenameType(NNS, NewTemplateId); } return getDerived().RebuildTypenameType(NNS, T->getIdentifier()); } - + template<typename Derived> QualType TreeTransform<Derived>::TransformObjCInterfaceType( - const ObjCInterfaceType *T) { + const ObjCInterfaceType *T) { // FIXME: Implement - return QualType(T, 0); + return QualType(T, 0); } - -template<typename Derived> + +template<typename Derived> QualType TreeTransform<Derived>::TransformObjCObjectPointerType( - const ObjCObjectPointerType *T) { + const ObjCObjectPointerType *T) { // FIXME: Implement - return QualType(T, 0); + return QualType(T, 0); } //===----------------------------------------------------------------------===// @@ -2494,8 +2493,8 @@ QualType TreeTransform<Derived>::TransformObjCObjectPointerType( //===----------------------------------------------------------------------===// template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformNullStmt(NullStmt *S) { - return SemaRef.Owned(S->Retain()); +TreeTransform<Derived>::TransformNullStmt(NullStmt *S) { + return SemaRef.Owned(S->Retain()); } template<typename Derived> @@ -2506,7 +2505,7 @@ TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) { template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, +TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr) { bool SubStmtChanged = false; ASTOwningVector<&ActionBase::DeleteStmt> Statements(getSema()); @@ -2515,37 +2514,37 @@ TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, OwningStmtResult Result = getDerived().TransformStmt(*B); if (Result.isInvalid()) return getSema().StmtError(); - + SubStmtChanged = SubStmtChanged || Result.get() != *B; Statements.push_back(Result.takeAs<Stmt>()); } - + if (!getDerived().AlwaysRebuild() && !SubStmtChanged) - return SemaRef.Owned(S->Retain()); + return SemaRef.Owned(S->Retain()); return getDerived().RebuildCompoundStmt(S->getLBracLoc(), move_arg(Statements), S->getRBracLoc(), IsStmtExpr); } - + template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) { +TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) { // The case value expressions are not potentially evaluated. EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); - + // Transform the left-hand case value. OwningExprResult LHS = getDerived().TransformExpr(S->getLHS()); if (LHS.isInvalid()) return SemaRef.StmtError(); - + // Transform the right-hand case value (for the GNU case-range extension). OwningExprResult RHS = getDerived().TransformExpr(S->getRHS()); if (RHS.isInvalid()) return SemaRef.StmtError(); - + // Build the case statement. // Case statements are always rebuilt so that they will attached to their // transformed switch statement. @@ -2556,118 +2555,118 @@ TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) { S->getColonLoc()); if (Case.isInvalid()) return SemaRef.StmtError(); - + // Transform the statement following the case OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); if (SubStmt.isInvalid()) return SemaRef.StmtError(); - + // Attach the body to the case statement return getDerived().RebuildCaseStmtBody(move(Case), move(SubStmt)); } template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) { +TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) { // Transform the statement following the default case OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); if (SubStmt.isInvalid()) return SemaRef.StmtError(); - + // Default statements are always rebuilt return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(), move(SubStmt)); } - + template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) { +TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) { OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); if (SubStmt.isInvalid()) return SemaRef.StmtError(); - + // FIXME: Pass the real colon location in. SourceLocation ColonLoc = SemaRef.PP.getLocForEndOfToken(S->getIdentLoc()); return getDerived().RebuildLabelStmt(S->getIdentLoc(), S->getID(), ColonLoc, move(SubStmt)); } - + template<typename Derived> -Sema::OwningStmtResult -TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { +Sema::OwningStmtResult +TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { // Transform the condition OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); if (Cond.isInvalid()) return SemaRef.StmtError(); - + Sema::FullExprArg FullCond(getSema().FullExpr(Cond)); - + // Transform the "then" branch. OwningStmtResult Then = getDerived().TransformStmt(S->getThen()); if (Then.isInvalid()) return SemaRef.StmtError(); - + // Transform the "else" branch. OwningStmtResult Else = getDerived().TransformStmt(S->getElse()); if (Else.isInvalid()) return SemaRef.StmtError(); - + if (!getDerived().AlwaysRebuild() && FullCond->get() == S->getCond() && Then.get() == S->getThen() && Else.get() == S->getElse()) - return SemaRef.Owned(S->Retain()); - + return SemaRef.Owned(S->Retain()); + return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, move(Then), - S->getElseLoc(), move(Else)); + S->getElseLoc(), move(Else)); } template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { +TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { // Transform the condition. OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); if (Cond.isInvalid()) return SemaRef.StmtError(); - + // Rebuild the switch statement. OwningStmtResult Switch = getDerived().RebuildSwitchStmtStart(move(Cond)); if (Switch.isInvalid()) return SemaRef.StmtError(); - + // Transform the body of the switch statement. OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); if (Body.isInvalid()) return SemaRef.StmtError(); - + // Complete the switch statement. return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), move(Switch), move(Body)); } - + template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { +TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { // Transform the condition OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); if (Cond.isInvalid()) return SemaRef.StmtError(); - + Sema::FullExprArg FullCond(getSema().FullExpr(Cond)); - + // Transform the body OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); if (Body.isInvalid()) return SemaRef.StmtError(); - + if (!getDerived().AlwaysRebuild() && FullCond->get() == S->getCond() && Body.get() == S->getBody()) - return SemaRef.Owned(S->Retain()); - + return SemaRef.Owned(S->Retain()); + return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond, move(Body)); } - + template<typename Derived> Sema::OwningStmtResult TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { @@ -2675,75 +2674,75 @@ TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); if (Cond.isInvalid()) return SemaRef.StmtError(); - + // Transform the body OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); if (Body.isInvalid()) return SemaRef.StmtError(); - + if (!getDerived().AlwaysRebuild() && Cond.get() == S->getCond() && Body.get() == S->getBody()) - return SemaRef.Owned(S->Retain()); - + return SemaRef.Owned(S->Retain()); + return getDerived().RebuildDoStmt(S->getDoLoc(), move(Body), S->getWhileLoc(), /*FIXME:*/S->getWhileLoc(), move(Cond), S->getRParenLoc()); } - + template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformForStmt(ForStmt *S) { +TreeTransform<Derived>::TransformForStmt(ForStmt *S) { // Transform the initialization statement OwningStmtResult Init = getDerived().TransformStmt(S->getInit()); if (Init.isInvalid()) return SemaRef.StmtError(); - + // Transform the condition OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); if (Cond.isInvalid()) return SemaRef.StmtError(); - + // Transform the increment OwningExprResult Inc = getDerived().TransformExpr(S->getInc()); if (Inc.isInvalid()) return SemaRef.StmtError(); - + // Transform the body OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); if (Body.isInvalid()) return SemaRef.StmtError(); - + if (!getDerived().AlwaysRebuild() && Init.get() == S->getInit() && Cond.get() == S->getCond() && Inc.get() == S->getInc() && Body.get() == S->getBody()) - return SemaRef.Owned(S->Retain()); - + return SemaRef.Owned(S->Retain()); + return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(), move(Init), move(Cond), move(Inc), S->getRParenLoc(), move(Body)); } template<typename Derived> -Sema::OwningStmtResult -TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) { +Sema::OwningStmtResult +TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) { // Goto statements must always be rebuilt, to resolve the label. - return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(), + return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(), S->getLabel()); } template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { +TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { OwningExprResult Target = getDerived().TransformExpr(S->getTarget()); if (Target.isInvalid()) return SemaRef.StmtError(); - + if (!getDerived().AlwaysRebuild() && Target.get() == S->getTarget()) - return SemaRef.Owned(S->Retain()); + return SemaRef.Owned(S->Retain()); return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(), move(Target)); @@ -2751,31 +2750,31 @@ TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { - return SemaRef.Owned(S->Retain()); +TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { + return SemaRef.Owned(S->Retain()); } - + template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { - return SemaRef.Owned(S->Retain()); +TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { + return SemaRef.Owned(S->Retain()); } - + template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) { +TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) { Sema::OwningExprResult Result = getDerived().TransformExpr(S->getRetValue()); if (Result.isInvalid()) return SemaRef.StmtError(); - // FIXME: We always rebuild the return statement because there is no way + // FIXME: We always rebuild the return statement because there is no way // to tell whether the return type of the function has changed. return getDerived().RebuildReturnStmt(S->getReturnLoc(), move(Result)); } - + template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { +TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { bool DeclChanged = false; llvm::SmallVector<Decl *, 4> Decls; for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); @@ -2783,25 +2782,25 @@ TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { Decl *Transformed = getDerived().TransformDefinition(*D); if (!Transformed) return SemaRef.StmtError(); - + if (Transformed != *D) DeclChanged = true; - + Decls.push_back(Transformed); } - + if (!getDerived().AlwaysRebuild() && !DeclChanged) - return SemaRef.Owned(S->Retain()); - - return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(), + return SemaRef.Owned(S->Retain()); + + return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(), S->getStartLoc(), S->getEndLoc()); } - + template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformSwitchCase(SwitchCase *S) { +TreeTransform<Derived>::TransformSwitchCase(SwitchCase *S) { assert(false && "SwitchCase is abstract and cannot be transformed"); - return SemaRef.Owned(S->Retain()); + return SemaRef.Owned(S->Retain()); } template<typename Derived> @@ -2809,58 +2808,58 @@ Sema::OwningStmtResult TreeTransform<Derived>::TransformAsmStmt(AsmStmt *S) { // FIXME: Implement! assert(false && "Inline assembly cannot be transformed"); - return SemaRef.Owned(S->Retain()); + return SemaRef.Owned(S->Retain()); } template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { +TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { // FIXME: Implement this assert(false && "Cannot transform an Objective-C @try statement"); - return SemaRef.Owned(S->Retain()); + return SemaRef.Owned(S->Retain()); } - + template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { +TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { // FIXME: Implement this assert(false && "Cannot transform an Objective-C @catch statement"); return SemaRef.Owned(S->Retain()); } - + template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { +TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { // FIXME: Implement this assert(false && "Cannot transform an Objective-C @finally statement"); - return SemaRef.Owned(S->Retain()); + return SemaRef.Owned(S->Retain()); } - + template<typename Derived> Sema::OwningStmtResult -TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { +TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { // FIXME: Implement this assert(false && "Cannot transform an Objective-C @throw statement"); - return SemaRef.Owned(S->Retain()); + return SemaRef.Owned(S->Retain()); } - + template<typename Derived> Sema::OwningStmtResult TreeTransform<Derived>::TransformObjCAtSynchronizedStmt( - ObjCAtSynchronizedStmt *S) { + ObjCAtSynchronizedStmt *S) { // FIXME: Implement this assert(false && "Cannot transform an Objective-C @synchronized statement"); - return SemaRef.Owned(S->Retain()); + return SemaRef.Owned(S->Retain()); } template<typename Derived> Sema::OwningStmtResult TreeTransform<Derived>::TransformObjCForCollectionStmt( - ObjCForCollectionStmt *S) { + ObjCForCollectionStmt *S) { // FIXME: Implement this assert(false && "Cannot transform an Objective-C for-each statement"); - return SemaRef.Owned(S->Retain()); + return SemaRef.Owned(S->Retain()); } @@ -2877,7 +2876,7 @@ TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { QualType T = getDerived().TransformType(ExceptionDecl->getType()); if (T.isNull()) return SemaRef.StmtError(); - + Var = getDerived().RebuildExceptionDecl(ExceptionDecl, T, ExceptionDecl->getDeclaratorInfo(), @@ -2891,7 +2890,7 @@ TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { return SemaRef.StmtError(); } } - + // Transform the actual exception handler. OwningStmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock()); if (Handler.isInvalid()) { @@ -2899,191 +2898,191 @@ TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { Var->Destroy(SemaRef.Context); return SemaRef.StmtError(); } - + if (!getDerived().AlwaysRebuild() && !Var && Handler.get() == S->getHandlerBlock()) - return SemaRef.Owned(S->Retain()); + return SemaRef.Owned(S->Retain()); return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, move(Handler)); } - + template<typename Derived> Sema::OwningStmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) { // Transform the try block itself. - OwningStmtResult TryBlock + OwningStmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock()); if (TryBlock.isInvalid()) return SemaRef.StmtError(); - + // Transform the handlers. bool HandlerChanged = false; ASTOwningVector<&ActionBase::DeleteStmt> Handlers(SemaRef); for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) { - OwningStmtResult Handler + OwningStmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(I)); if (Handler.isInvalid()) return SemaRef.StmtError(); - + HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); Handlers.push_back(Handler.takeAs<Stmt>()); } - + if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() && !HandlerChanged) - return SemaRef.Owned(S->Retain()); + return SemaRef.Owned(S->Retain()); return getDerived().RebuildCXXTryStmt(S->getTryLoc(), move(TryBlock), - move_arg(Handlers)); + move_arg(Handlers)); } - + //===----------------------------------------------------------------------===// // Expression transformation //===----------------------------------------------------------------------===// -template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) { - return SemaRef.Owned(E->Retain()); -} - -template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { - NamedDecl *ND +template<typename Derived> +Sema::OwningExprResult +TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) { + return SemaRef.Owned(E->Retain()); +} + +template<typename Derived> +Sema::OwningExprResult +TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { + NamedDecl *ND = dyn_cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getDecl())); if (!ND) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && ND == E->getDecl()) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + return getDerived().RebuildDeclRefExpr(ND, E->getLocation()); } - + template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) { - return SemaRef.Owned(E->Retain()); +Sema::OwningExprResult +TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) { + return SemaRef.Owned(E->Retain()); } - + template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) { - return SemaRef.Owned(E->Retain()); +Sema::OwningExprResult +TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) { + return SemaRef.Owned(E->Retain()); } - + template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) { - return SemaRef.Owned(E->Retain()); +Sema::OwningExprResult +TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) { + return SemaRef.Owned(E->Retain()); } - -template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) { - return SemaRef.Owned(E->Retain()); + +template<typename Derived> +Sema::OwningExprResult +TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) { + return SemaRef.Owned(E->Retain()); } - + template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { - return SemaRef.Owned(E->Retain()); +Sema::OwningExprResult +TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { + return SemaRef.Owned(E->Retain()); } - + template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) { +Sema::OwningExprResult +TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) { OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); if (SubExpr.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) - return SemaRef.Owned(E->Retain()); - - return getDerived().RebuildParenExpr(move(SubExpr), E->getLParen(), + return SemaRef.Owned(E->Retain()); + + return getDerived().RebuildParenExpr(move(SubExpr), E->getLParen(), E->getRParen()); } -template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) { +template<typename Derived> +Sema::OwningExprResult +TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) { OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); if (SubExpr.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), E->getOpcode(), move(SubExpr)); } - + template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { +Sema::OwningExprResult +TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { if (E->isArgumentType()) { QualType T = getDerived().TransformType(E->getArgumentType()); if (T.isNull()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && T == E->getArgumentType()) return SemaRef.Owned(E->Retain()); - - return getDerived().RebuildSizeOfAlignOf(T, E->getOperatorLoc(), - E->isSizeOf(), + + return getDerived().RebuildSizeOfAlignOf(T, E->getOperatorLoc(), + E->isSizeOf(), E->getSourceRange()); } - + Sema::OwningExprResult SubExpr(SemaRef); - { + { // C++0x [expr.sizeof]p1: // The operand is either an expression, which is an unevaluated operand // [...] EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); - + SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); if (SubExpr.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) return SemaRef.Owned(E->Retain()); } - + return getDerived().RebuildSizeOfAlignOf(move(SubExpr), E->getOperatorLoc(), E->isSizeOf(), E->getSourceRange()); } - + template<typename Derived> -Sema::OwningExprResult +Sema::OwningExprResult TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) { OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); if (LHS.isInvalid()) return SemaRef.ExprError(); - + OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); if (RHS.isInvalid()) return SemaRef.ExprError(); - - + + if (!getDerived().AlwaysRebuild() && LHS.get() == E->getLHS() && RHS.get() == E->getRHS()) return SemaRef.Owned(E->Retain()); - + return getDerived().RebuildArraySubscriptExpr(move(LHS), /*FIXME:*/E->getLHS()->getLocStart(), move(RHS), E->getRBracketLoc()); } - -template<typename Derived> -Sema::OwningExprResult + +template<typename Derived> +Sema::OwningExprResult TreeTransform<Derived>::TransformCallExpr(CallExpr *E) { // Transform the callee. OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); @@ -3098,55 +3097,55 @@ TreeTransform<Derived>::TransformCallExpr(CallExpr *E) { OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I)); if (Arg.isInvalid()) return SemaRef.ExprError(); - + // FIXME: Wrong source location information for the ','. FakeCommaLocs.push_back( SemaRef.PP.getLocForEndOfToken(E->getArg(I)->getSourceRange().getEnd())); - - ArgChanged = ArgChanged || Arg.get() != E->getArg(I); + + ArgChanged = ArgChanged || Arg.get() != E->getArg(I); Args.push_back(Arg.takeAs<Expr>()); } - + if (!getDerived().AlwaysRebuild() && Callee.get() == E->getCallee() && !ArgChanged) return SemaRef.Owned(E->Retain()); - + // FIXME: Wrong source location information for the '('. - SourceLocation FakeLParenLoc + SourceLocation FakeLParenLoc = ((Expr *)Callee.get())->getSourceRange().getBegin(); return getDerived().RebuildCallExpr(move(Callee), FakeLParenLoc, move_arg(Args), FakeCommaLocs.data(), E->getRParenLoc()); } - -template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { + +template<typename Derived> +Sema::OwningExprResult +TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { OwningExprResult Base = getDerived().TransformExpr(E->getBase()); if (Base.isInvalid()) return SemaRef.ExprError(); - + NestedNameSpecifier *Qualifier = 0; if (E->hasQualifier()) { - Qualifier + Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), E->getQualifierRange()); if (Qualifier == 0) return SemaRef.ExprError(); } - - NamedDecl *Member + + NamedDecl *Member = cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getMemberDecl())); if (!Member) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() && Qualifier == E->getQualifier() && Member == E->getMemberDecl()) - return SemaRef.Owned(E->Retain()); + return SemaRef.Owned(E->Retain()); // FIXME: Bogus source location for the operator SourceLocation FakeOperatorLoc @@ -3157,208 +3156,208 @@ TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { Qualifier, E->getQualifierRange(), E->getMemberLoc(), - Member); + Member); } - + template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformCastExpr(CastExpr *E) { +Sema::OwningExprResult +TreeTransform<Derived>::TransformCastExpr(CastExpr *E) { assert(false && "Cannot transform abstract class"); - return SemaRef.Owned(E->Retain()); + return SemaRef.Owned(E->Retain()); } - -template<typename Derived> + +template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { +TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); if (LHS.isInvalid()) return SemaRef.ExprError(); - + OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); if (RHS.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && LHS.get() == E->getLHS() && RHS.get() == E->getRHS()) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(), move(LHS), move(RHS)); } -template<typename Derived> +template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformCompoundAssignOperator( CompoundAssignOperator *E) { return getDerived().TransformBinaryOperator(E); } - + template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) { +Sema::OwningExprResult +TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) { OwningExprResult Cond = getDerived().TransformExpr(E->getCond()); if (Cond.isInvalid()) return SemaRef.ExprError(); - + OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); if (LHS.isInvalid()) return SemaRef.ExprError(); - + OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); if (RHS.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && Cond.get() == E->getCond() && LHS.get() == E->getLHS() && RHS.get() == E->getRHS()) return SemaRef.Owned(E->Retain()); - - return getDerived().RebuildConditionalOperator(move(Cond), + + return getDerived().RebuildConditionalOperator(move(Cond), E->getQuestionLoc(), - move(LHS), + move(LHS), E->getColonLoc(), move(RHS)); } - -template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) { + +template<typename Derived> +Sema::OwningExprResult +TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) { QualType T = getDerived().TransformType(E->getType()); if (T.isNull()) return SemaRef.ExprError(); - + OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); if (SubExpr.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && T == E->getType() && SubExpr.get() == E->getSubExpr()) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + return getDerived().RebuildImplicitCastExpr(T, E->getCastKind(), - move(SubExpr), + move(SubExpr), E->isLvalueCast()); } - + template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformExplicitCastExpr(ExplicitCastExpr *E) { +Sema::OwningExprResult +TreeTransform<Derived>::TransformExplicitCastExpr(ExplicitCastExpr *E) { assert(false && "Cannot transform abstract class"); - return SemaRef.Owned(E->Retain()); + return SemaRef.Owned(E->Retain()); } - + template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) { +TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) { QualType T; { // FIXME: Source location isn't quite accurate. - SourceLocation TypeStartLoc + SourceLocation TypeStartLoc = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc()); TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName()); - + T = getDerived().TransformType(E->getTypeAsWritten()); if (T.isNull()) return SemaRef.ExprError(); } - + OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); if (SubExpr.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && T == E->getTypeAsWritten() && SubExpr.get() == E->getSubExpr()) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + return getDerived().RebuildCStyleCaseExpr(E->getLParenLoc(), T, E->getRParenLoc(), move(SubExpr)); } - + template<typename Derived> -Sema::OwningExprResult +Sema::OwningExprResult TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) { QualType T; { // FIXME: Source location isn't quite accurate. - SourceLocation FakeTypeLoc + SourceLocation FakeTypeLoc = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc()); TemporaryBase Rebase(*this, FakeTypeLoc, DeclarationName()); - + T = getDerived().TransformType(E->getType()); if (T.isNull()) return SemaRef.ExprError(); } - + OwningExprResult Init = getDerived().TransformExpr(E->getInitializer()); if (Init.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && T == E->getType() && Init.get() == E->getInitializer()) - return SemaRef.Owned(E->Retain()); + return SemaRef.Owned(E->Retain()); return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), T, /*FIXME:*/E->getInitializer()->getLocEnd(), move(Init)); } - + template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { +TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { OwningExprResult Base = getDerived().TransformExpr(E->getBase()); if (Base.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase()) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + // FIXME: Bad source location - SourceLocation FakeOperatorLoc + SourceLocation FakeOperatorLoc = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd()); return getDerived().RebuildExtVectorElementExpr(move(Base), FakeOperatorLoc, E->getAccessorLoc(), E->getAccessor()); } - + template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) { +Sema::OwningExprResult +TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) { bool InitChanged = false; - + ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) { OwningExprResult Init = getDerived().TransformExpr(E->getInit(I)); if (Init.isInvalid()) return SemaRef.ExprError(); - + InitChanged = InitChanged || Init.get() != E->getInit(I); Inits.push_back(Init.takeAs<Expr>()); } - + if (!getDerived().AlwaysRebuild() && !InitChanged) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + return getDerived().RebuildInitList(E->getLBraceLoc(), move_arg(Inits), E->getRBraceLoc()); } - + template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { +TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { Designation Desig; - + // transform the initializer value OwningExprResult Init = getDerived().TransformExpr(E->getInit()); if (Init.isInvalid()) return SemaRef.ExprError(); - + // transform the designators. ASTOwningVector<&ActionBase::DeleteExpr, 4> ArrayExprs(SemaRef); bool ExprChanged = false; @@ -3371,73 +3370,73 @@ TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { D->getFieldLoc())); continue; } - + if (D->isArrayDesignator()) { OwningExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D)); if (Index.isInvalid()) return SemaRef.ExprError(); - - Desig.AddDesignator(Designator::getArray(Index.get(), + + Desig.AddDesignator(Designator::getArray(Index.get(), D->getLBracketLoc())); - + ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); ArrayExprs.push_back(Index.release()); continue; } - + assert(D->isArrayRangeDesignator() && "New kind of designator?"); - OwningExprResult Start + OwningExprResult Start = getDerived().TransformExpr(E->getArrayRangeStart(*D)); if (Start.isInvalid()) return SemaRef.ExprError(); - + OwningExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D)); if (End.isInvalid()) return SemaRef.ExprError(); - - Desig.AddDesignator(Designator::getArrayRange(Start.get(), + + Desig.AddDesignator(Designator::getArrayRange(Start.get(), End.get(), D->getLBracketLoc(), D->getEllipsisLoc())); - + ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || End.get() != E->getArrayRangeEnd(*D); - + ArrayExprs.push_back(Start.release()); ArrayExprs.push_back(End.release()); } - + if (!getDerived().AlwaysRebuild() && Init.get() == E->getInit() && !ExprChanged) return SemaRef.Owned(E->Retain()); - + return getDerived().RebuildDesignatedInitExpr(Desig, move_arg(ArrayExprs), E->getEqualOrColonLoc(), E->usesGNUSyntax(), move(Init)); } - + template<typename Derived> -Sema::OwningExprResult +Sema::OwningExprResult TreeTransform<Derived>::TransformImplicitValueInitExpr( - ImplicitValueInitExpr *E) { + ImplicitValueInitExpr *E) { QualType T = getDerived().TransformType(E->getType()); if (T.isNull()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && T == E->getType()) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + return getDerived().RebuildImplicitValueInitExpr(T); } - + template<typename Derived> -Sema::OwningExprResult +Sema::OwningExprResult TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) { // FIXME: Do we want the type as written? QualType T; - + { // FIXME: Source location isn't quite accurate. TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName()); @@ -3445,22 +3444,22 @@ TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) { if (T.isNull()) return SemaRef.ExprError(); } - + OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); if (SubExpr.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && T == E->getType() && SubExpr.get() == E->getSubExpr()) return SemaRef.Owned(E->Retain()); - + return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), move(SubExpr), T, E->getRParenLoc()); } template<typename Derived> -Sema::OwningExprResult +Sema::OwningExprResult TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { bool ArgumentChanged = false; ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); @@ -3468,16 +3467,16 @@ TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { OwningExprResult Init = getDerived().TransformExpr(E->getExpr(I)); if (Init.isInvalid()) return SemaRef.ExprError(); - + ArgumentChanged = ArgumentChanged || Init.get() != E->getExpr(I); Inits.push_back(Init.takeAs<Expr>()); } - + return getDerived().RebuildParenListExpr(E->getLParenLoc(), move_arg(Inits), E->getRParenLoc()); } - + /// \brief Transform an address-of-label expression. /// /// By default, the transformation of an address-of-label expression always @@ -3485,39 +3484,39 @@ TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { /// the corresponding label statement by semantic analysis. template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) { +TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) { return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(), E->getLabel()); } - -template<typename Derived> + +template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) { - OwningStmtResult SubStmt + OwningStmtResult SubStmt = getDerived().TransformCompoundStmt(E->getSubStmt(), true); if (SubStmt.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && SubStmt.get() == E->getSubStmt()) return SemaRef.Owned(E->Retain()); - - return getDerived().RebuildStmtExpr(E->getLParenLoc(), + + return getDerived().RebuildStmtExpr(E->getLParenLoc(), move(SubStmt), E->getRParenLoc()); } - + template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformTypesCompatibleExpr(TypesCompatibleExpr *E) { +TreeTransform<Derived>::TransformTypesCompatibleExpr(TypesCompatibleExpr *E) { QualType T1, T2; { // FIXME: Source location isn't quite accurate. TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName()); - + T1 = getDerived().TransformType(E->getArgType1()); if (T1.isNull()) return SemaRef.ExprError(); - + T2 = getDerived().TransformType(E->getArgType2()); if (T2.isNull()) return SemaRef.ExprError(); @@ -3526,42 +3525,42 @@ TreeTransform<Derived>::TransformTypesCompatibleExpr(TypesCompatibleExpr *E) { if (!getDerived().AlwaysRebuild() && T1 == E->getArgType1() && T2 == E->getArgType2()) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + return getDerived().RebuildTypesCompatibleExpr(E->getBuiltinLoc(), T1, T2, E->getRParenLoc()); } - + template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { +TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { OwningExprResult Cond = getDerived().TransformExpr(E->getCond()); if (Cond.isInvalid()) return SemaRef.ExprError(); - + OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); if (LHS.isInvalid()) return SemaRef.ExprError(); - + OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); if (RHS.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && Cond.get() == E->getCond() && LHS.get() == E->getLHS() && RHS.get() == E->getRHS()) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), move(Cond), move(LHS), move(RHS), E->getRParenLoc()); } - + template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) { - return SemaRef.Owned(E->Retain()); +Sema::OwningExprResult +TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) { + return SemaRef.Owned(E->Retain()); } template<typename Derived> @@ -3570,7 +3569,7 @@ TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); if (Callee.isInvalid()) return SemaRef.ExprError(); - + OwningExprResult First = getDerived().TransformExpr(E->getArg(0)); if (First.isInvalid()) return SemaRef.ExprError(); @@ -3581,59 +3580,59 @@ TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { if (Second.isInvalid()) return SemaRef.ExprError(); } - + if (!getDerived().AlwaysRebuild() && Callee.get() == E->getCallee() && First.get() == E->getArg(0) && - (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) - return SemaRef.Owned(E->Retain()); - + (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) + return SemaRef.Owned(E->Retain()); + return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(), E->getOperatorLoc(), - move(Callee), + move(Callee), move(First), move(Second)); } - + template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) { +TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) { return getDerived().TransformCallExpr(E); } - + template<typename Derived> -Sema::OwningExprResult +Sema::OwningExprResult TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) { QualType ExplicitTy; { // FIXME: Source location isn't quite accurate. - SourceLocation TypeStartLoc + SourceLocation TypeStartLoc = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName()); - + ExplicitTy = getDerived().TransformType(E->getTypeAsWritten()); if (ExplicitTy.isNull()) return SemaRef.ExprError(); } - + OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); if (SubExpr.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && ExplicitTy == E->getTypeAsWritten() && SubExpr.get() == E->getSubExpr()) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + // FIXME: Poor source location information here. - SourceLocation FakeLAngleLoc + SourceLocation FakeLAngleLoc = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); SourceLocation FakeRAngleLoc = E->getSubExpr()->getSourceRange().getBegin(); SourceLocation FakeRParenLoc = SemaRef.PP.getLocForEndOfToken( E->getSubExpr()->getSourceRange().getEnd()); return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(), - E->getStmtClass(), + E->getStmtClass(), FakeLAngleLoc, ExplicitTy, FakeRAngleLoc, @@ -3641,54 +3640,54 @@ TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) { move(SubExpr), FakeRParenLoc); } - + template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) { +Sema::OwningExprResult +TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) { return getDerived().TransformCXXNamedCastExpr(E); } - + template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) { +TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) { return getDerived().TransformCXXNamedCastExpr(E); } - + template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformCXXReinterpretCastExpr( - CXXReinterpretCastExpr *E) { + CXXReinterpretCastExpr *E) { return getDerived().TransformCXXNamedCastExpr(E); } - + template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) { +TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) { return getDerived().TransformCXXNamedCastExpr(E); } - + template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformCXXFunctionalCastExpr( - CXXFunctionalCastExpr *E) { + CXXFunctionalCastExpr *E) { QualType ExplicitTy; { TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); - + ExplicitTy = getDerived().TransformType(E->getTypeAsWritten()); if (ExplicitTy.isNull()) return SemaRef.ExprError(); } - + OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); if (SubExpr.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && ExplicitTy == E->getTypeAsWritten() && SubExpr.get() == E->getSubExpr()) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + // FIXME: The end of the type's source range is wrong return getDerived().RebuildCXXFunctionalCastExpr( /*FIXME:*/SourceRange(E->getTypeBeginLoc()), @@ -3697,41 +3696,41 @@ TreeTransform<Derived>::TransformCXXFunctionalCastExpr( move(SubExpr), E->getRParenLoc()); } - + template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { +TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { if (E->isTypeOperand()) { TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); - + QualType T = getDerived().TransformType(E->getTypeOperand()); if (T.isNull()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && T == E->getTypeOperand()) return SemaRef.Owned(E->Retain()); - + return getDerived().RebuildCXXTypeidExpr(E->getLocStart(), /*FIXME:*/E->getLocStart(), T, E->getLocEnd()); } - + // We don't know whether the expression is potentially evaluated until // after we perform semantic analysis, so the expression is potentially // potentially evaluated. - EnterExpressionEvaluationContext Unevaluated(SemaRef, + EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::PotentiallyPotentiallyEvaluated); - + OwningExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); if (SubExpr.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getExprOperand()) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + return getDerived().RebuildCXXTypeidExpr(E->getLocStart(), /*FIXME:*/E->getLocStart(), move(SubExpr), @@ -3739,63 +3738,63 @@ TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { } template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { - return SemaRef.Owned(E->Retain()); +Sema::OwningExprResult +TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { + return SemaRef.Owned(E->Retain()); } - + template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( - CXXNullPtrLiteralExpr *E) { - return SemaRef.Owned(E->Retain()); + CXXNullPtrLiteralExpr *E) { + return SemaRef.Owned(E->Retain()); } - + template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) { TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); - + QualType T = getDerived().TransformType(E->getType()); if (T.isNull()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && T == E->getType()) return SemaRef.Owned(E->Retain()); - + return getDerived().RebuildCXXThisExpr(E->getLocStart(), T); } - + template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) { +TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) { OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); if (SubExpr.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) - return SemaRef.Owned(E->Retain()); + return SemaRef.Owned(E->Retain()); return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), move(SubExpr)); } - + template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { - ParmVarDecl *Param +TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { + ParmVarDecl *Param = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getParam())); if (!Param) return SemaRef.ExprError(); - + if (getDerived().AlwaysRebuild() && Param == E->getParam()) return SemaRef.Owned(E->Retain()); - + return getDerived().RebuildCXXDefaultArgExpr(Param); } - + template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) { @@ -3804,48 +3803,48 @@ TreeTransform<Derived>::TransformCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) { QualType T = getDerived().TransformType(E->getType()); if (T.isNull()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && T == E->getType()) - return SemaRef.Owned(E->Retain()); - - return getDerived().RebuildCXXZeroInitValueExpr(E->getTypeBeginLoc(), + return SemaRef.Owned(E->Retain()); + + return getDerived().RebuildCXXZeroInitValueExpr(E->getTypeBeginLoc(), /*FIXME:*/E->getTypeBeginLoc(), T, E->getRParenLoc()); } - + template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformCXXConditionDeclExpr(CXXConditionDeclExpr *E) { - VarDecl *Var + VarDecl *Var = cast_or_null<VarDecl>(getDerived().TransformDefinition(E->getVarDecl())); if (!Var) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && - Var == E->getVarDecl()) + Var == E->getVarDecl()) return SemaRef.Owned(E->Retain()); - - return getDerived().RebuildCXXConditionDeclExpr(E->getStartLoc(), + + return getDerived().RebuildCXXConditionDeclExpr(E->getStartLoc(), /*FIXME:*/E->getStartLoc(), Var); } - + template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { +TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { // Transform the type that we're allocating TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); QualType AllocType = getDerived().TransformType(E->getAllocatedType()); if (AllocType.isNull()) return SemaRef.ExprError(); - + // Transform the size of the array we're allocating (if any). OwningExprResult ArraySize = getDerived().TransformExpr(E->getArraySize()); if (ArraySize.isInvalid()) return SemaRef.ExprError(); - + // Transform the placement arguments (if any). bool ArgumentChanged = false; ASTOwningVector<&ActionBase::DeleteExpr> PlacementArgs(SemaRef); @@ -3853,28 +3852,28 @@ TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { OwningExprResult Arg = getDerived().TransformExpr(E->getPlacementArg(I)); if (Arg.isInvalid()) return SemaRef.ExprError(); - + ArgumentChanged = ArgumentChanged || Arg.get() != E->getPlacementArg(I); PlacementArgs.push_back(Arg.take()); } - + // transform the constructor arguments (if any). ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(SemaRef); for (unsigned I = 0, N = E->getNumConstructorArgs(); I != N; ++I) { OwningExprResult Arg = getDerived().TransformExpr(E->getConstructorArg(I)); if (Arg.isInvalid()) return SemaRef.ExprError(); - + ArgumentChanged = ArgumentChanged || Arg.get() != E->getConstructorArg(I); ConstructorArgs.push_back(Arg.take()); } - + if (!getDerived().AlwaysRebuild() && AllocType == E->getAllocatedType() && ArraySize.get() == E->getArraySize() && !ArgumentChanged) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + return getDerived().RebuildCXXNewExpr(E->getLocStart(), E->isGlobalNew(), /*FIXME:*/E->getLocStart(), @@ -3887,26 +3886,26 @@ TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { move(ArraySize), /*FIXME:*/E->getLocStart(), move_arg(ConstructorArgs), - E->getLocEnd()); + E->getLocEnd()); } - + template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) { +TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) { OwningExprResult Operand = getDerived().TransformExpr(E->getArgument()); if (Operand.isInvalid()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && - Operand.get() == E->getArgument()) - return SemaRef.Owned(E->Retain()); - + Operand.get() == E->getArgument()) + return SemaRef.Owned(E->Retain()); + return getDerived().RebuildCXXDeleteExpr(E->getLocStart(), E->isGlobalDelete(), E->isArrayForm(), move(Operand)); } - + template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( @@ -3914,13 +3913,13 @@ TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( OwningExprResult Base = getDerived().TransformExpr(E->getBase()); if (Base.isInvalid()) return SemaRef.ExprError(); - + NestedNameSpecifier *Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), E->getQualifierRange()); if (E->getQualifier() && !Qualifier) return SemaRef.ExprError(); - + QualType DestroyedType; { TemporaryBase Rebase(*this, E->getDestroyedTypeLoc(), DeclarationName()); @@ -3928,13 +3927,13 @@ TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( if (DestroyedType.isNull()) return SemaRef.ExprError(); } - + if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() && Qualifier == E->getQualifier() && DestroyedType == E->getDestroyedType()) return SemaRef.Owned(E->Retain()); - + return getDerived().RebuildCXXPseudoDestructorExpr(move(Base), E->getOperatorLoc(), E->isArrow(), @@ -3943,39 +3942,39 @@ TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( Qualifier, E->getQualifierRange()); } - + template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformUnresolvedFunctionNameExpr( - UnresolvedFunctionNameExpr *E) { + UnresolvedFunctionNameExpr *E) { // There is no transformation we can apply to an unresolved function name. - return SemaRef.Owned(E->Retain()); + return SemaRef.Owned(E->Retain()); } - + template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { +TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); - + QualType T = getDerived().TransformType(E->getQueriedType()); if (T.isNull()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && T == E->getQueriedType()) return SemaRef.Owned(E->Retain()); - + // FIXME: Bad location information SourceLocation FakeLParenLoc = SemaRef.PP.getLocForEndOfToken(E->getLocStart()); - - return getDerived().RebuildUnaryTypeTrait(E->getTrait(), + + return getDerived().RebuildUnaryTypeTrait(E->getTrait(), E->getLocStart(), /*FIXME:*/FakeLParenLoc, T, E->getLocEnd()); } - + template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformQualifiedDeclRefExpr(QualifiedDeclRefExpr *E) { @@ -3984,45 +3983,45 @@ TreeTransform<Derived>::TransformQualifiedDeclRefExpr(QualifiedDeclRefExpr *E) { E->getQualifierRange()); if (!NNS) return SemaRef.ExprError(); - - NamedDecl *ND + + NamedDecl *ND = dyn_cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getDecl())); if (!ND) return SemaRef.ExprError(); - - if (!getDerived().AlwaysRebuild() && + + if (!getDerived().AlwaysRebuild() && NNS == E->getQualifier() && ND == E->getDecl()) - return SemaRef.Owned(E->Retain()); - - return getDerived().RebuildQualifiedDeclRefExpr(NNS, + return SemaRef.Owned(E->Retain()); + + return getDerived().RebuildQualifiedDeclRefExpr(NNS, E->getQualifierRange(), ND, E->getLocation(), /*FIXME:*/false); } - + template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformUnresolvedDeclRefExpr( - UnresolvedDeclRefExpr *E) { + UnresolvedDeclRefExpr *E) { NestedNameSpecifier *NNS = getDerived().TransformNestedNameSpecifier(E->getQualifier(), E->getQualifierRange()); if (!NNS) return SemaRef.ExprError(); - - DeclarationName Name + + DeclarationName Name = getDerived().TransformDeclarationName(E->getDeclName(), E->getLocation()); if (!Name) return SemaRef.ExprError(); - - if (!getDerived().AlwaysRebuild() && + + if (!getDerived().AlwaysRebuild() && NNS == E->getQualifier() && Name == E->getDeclName()) - return SemaRef.Owned(E->Retain()); - - return getDerived().RebuildUnresolvedDeclRefExpr(NNS, + return SemaRef.Owned(E->Retain()); + + return getDerived().RebuildUnresolvedDeclRefExpr(NNS, E->getQualifierRange(), Name, E->getLocation(), @@ -4031,15 +4030,15 @@ TreeTransform<Derived>::TransformUnresolvedDeclRefExpr( template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformTemplateIdRefExpr(TemplateIdRefExpr *E) { - TemplateName Template +TreeTransform<Derived>::TransformTemplateIdRefExpr(TemplateIdRefExpr *E) { + TemplateName Template = getDerived().TransformTemplateName(E->getTemplateName()); if (Template.isNull()) return SemaRef.ExprError(); - + llvm::SmallVector<TemplateArgument, 4> TransArgs; for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { - TemplateArgument TransArg + TemplateArgument TransArg = getDerived().TransformTemplateArgument(E->getTemplateArgs()[I]); if (TransArg.isNull()) return SemaRef.ExprError(); @@ -4049,8 +4048,8 @@ TreeTransform<Derived>::TransformTemplateIdRefExpr(TemplateIdRefExpr *E) { // FIXME: Would like to avoid rebuilding if nothing changed, but we can't // compare template arguments (yet). - - // FIXME: It's possible that we'll find out now that the template name + + // FIXME: It's possible that we'll find out now that the template name // actually refers to a type, in which case the caller is actually dealing // with a functional cast. Give a reasonable error message! return getDerived().RebuildTemplateIdExpr(Template, E->getTemplateNameLoc(), @@ -4062,7 +4061,7 @@ TreeTransform<Derived>::TransformTemplateIdRefExpr(TemplateIdRefExpr *E) { template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { +TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); QualType T = getDerived().TransformType(E->getType()); @@ -4074,16 +4073,16 @@ TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { getDerived().TransformDecl(E->getConstructor())); if (!Constructor) return SemaRef.ExprError(); - + bool ArgumentChanged = false; ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); - for (CXXConstructExpr::arg_iterator Arg = E->arg_begin(), + for (CXXConstructExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); Arg != ArgEnd; ++Arg) { OwningExprResult TransArg = getDerived().TransformExpr(*Arg); if (TransArg.isInvalid()) return SemaRef.ExprError(); - + ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; Args.push_back(TransArg.takeAs<Expr>()); } @@ -4093,15 +4092,15 @@ TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { Constructor == E->getConstructor() && !ArgumentChanged) return SemaRef.Owned(E->Retain()); - + return getDerived().RebuildCXXConstructExpr(T, Constructor, E->isElidable(), move_arg(Args)); } - + /// \brief Transform a C++ temporary-binding expression. /// -/// The transformation of a temporary-binding expression always attempts to -/// bind a new temporary variable to its subexpression, even if the +/// The transformation of a temporary-binding expression always attempts to +/// bind a new temporary variable to its subexpression, even if the /// subexpression itself did not change, because the temporary variable itself /// must be unique. template<typename Derived> @@ -4110,70 +4109,70 @@ TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); if (SubExpr.isInvalid()) return SemaRef.ExprError(); - + return SemaRef.MaybeBindToTemporary(SubExpr.takeAs<Expr>()); } - -/// \brief Transform a C++ expression that contains temporaries that should + +/// \brief Transform a C++ expression that contains temporaries that should /// be destroyed after the expression is evaluated. /// -/// The transformation of a full expression always attempts to build a new -/// CXXExprWithTemporaries expression, even if the +/// The transformation of a full expression always attempts to build a new +/// CXXExprWithTemporaries expression, even if the /// subexpression itself did not change, because it will need to capture the /// the new temporary variables introduced in the subexpression. template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformCXXExprWithTemporaries( - CXXExprWithTemporaries *E) { + CXXExprWithTemporaries *E) { OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); if (SubExpr.isInvalid()) return SemaRef.ExprError(); - + return SemaRef.Owned( SemaRef.MaybeCreateCXXExprWithTemporaries(SubExpr.takeAs<Expr>(), E->shouldDestroyTemporaries())); } - + template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( - CXXTemporaryObjectExpr *E) { + CXXTemporaryObjectExpr *E) { TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); QualType T = getDerived().TransformType(E->getType()); if (T.isNull()) return SemaRef.ExprError(); - + CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>( getDerived().TransformDecl(E->getConstructor())); if (!Constructor) return SemaRef.ExprError(); - + bool ArgumentChanged = false; ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); Args.reserve(E->getNumArgs()); - for (CXXTemporaryObjectExpr::arg_iterator Arg = E->arg_begin(), + for (CXXTemporaryObjectExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); Arg != ArgEnd; ++Arg) { OwningExprResult TransArg = getDerived().TransformExpr(*Arg); if (TransArg.isInvalid()) return SemaRef.ExprError(); - + ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; Args.push_back((Expr *)TransArg.release()); } - + if (!getDerived().AlwaysRebuild() && T == E->getType() && Constructor == E->getConstructor() && !ArgumentChanged) return SemaRef.Owned(E->Retain()); - + // FIXME: Bogus location information SourceLocation CommaLoc; if (Args.size() > 1) { Expr *First = (Expr *)Args[0]; - CommaLoc + CommaLoc = SemaRef.PP.getLocForEndOfToken(First->getSourceRange().getEnd()); } return getDerived().RebuildCXXTemporaryObjectExpr(E->getTypeBeginLoc(), @@ -4183,16 +4182,16 @@ TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( &CommaLoc, E->getLocEnd()); } - + template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( - CXXUnresolvedConstructExpr *E) { + CXXUnresolvedConstructExpr *E) { TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); QualType T = getDerived().TransformType(E->getTypeAsWritten()); if (T.isNull()) return SemaRef.ExprError(); - + bool ArgumentChanged = false; ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); llvm::SmallVector<SourceLocation, 8> FakeCommaLocs; @@ -4202,18 +4201,18 @@ TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( OwningExprResult TransArg = getDerived().TransformExpr(*Arg); if (TransArg.isInvalid()) return SemaRef.ExprError(); - + ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; FakeCommaLocs.push_back( SemaRef.PP.getLocForEndOfToken((*Arg)->getLocEnd())); Args.push_back(TransArg.takeAs<Expr>()); } - + if (!getDerived().AlwaysRebuild() && T == E->getTypeAsWritten() && !ArgumentChanged) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + // FIXME: we're faking the locations of the commas return getDerived().RebuildCXXUnresolvedConstructExpr(E->getTypeBeginLoc(), T, @@ -4222,31 +4221,31 @@ TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( FakeCommaLocs.data(), E->getRParenLoc()); } - + template<typename Derived> Sema::OwningExprResult TreeTransform<Derived>::TransformCXXUnresolvedMemberExpr( - CXXUnresolvedMemberExpr *E) { + CXXUnresolvedMemberExpr *E) { // Transform the base of the expression. OwningExprResult Base = getDerived().TransformExpr(E->getBase()); if (Base.isInvalid()) return SemaRef.ExprError(); - + Sema::TypeTy *ObjectType = 0; - Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base), + Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base), E->getOperatorLoc(), E->isArrow()? tok::arrow : tok::period, ObjectType); if (Base.isInvalid()) return SemaRef.ExprError(); - + // FIXME: The first qualifier found might be a template type parameter, // in which case there is no transformed declaration to refer to (it might // refer to a built-in type!). NamedDecl *FirstQualifierInScope = cast_or_null<NamedDecl>( getDerived().TransformDecl(E->getFirstQualifierFoundInScope())); - + NestedNameSpecifier *Qualifier = 0; if (E->getQualifier()) { Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), @@ -4256,12 +4255,12 @@ TreeTransform<Derived>::TransformCXXUnresolvedMemberExpr( if (!Qualifier) return SemaRef.ExprError(); } - - DeclarationName Name + + DeclarationName Name = getDerived().TransformDeclarationName(E->getMember(), E->getMemberLoc()); if (!Name) return SemaRef.ExprError(); - + if (!E->hasExplicitTemplateArgumentList()) { // This is a reference to a member without an explicitly-specified // template argument list. Optimize for this common case. @@ -4270,8 +4269,8 @@ TreeTransform<Derived>::TransformCXXUnresolvedMemberExpr( Qualifier == E->getQualifier() && Name == E->getMember() && FirstQualifierInScope == E->getFirstQualifierFoundInScope()) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + return getDerived().RebuildCXXUnresolvedMemberExpr(move(Base), E->isArrow(), E->getOperatorLoc(), @@ -4287,23 +4286,23 @@ TreeTransform<Derived>::TransformCXXUnresolvedMemberExpr( // FIXME: This also won't work for, e.g., x->template operator+<int> TemplateName OrigTemplateName = SemaRef.Context.getDependentTemplateName(0, Name.getAsIdentifierInfo()); - - TemplateName Template - = getDerived().TransformTemplateName(OrigTemplateName, + + TemplateName Template + = getDerived().TransformTemplateName(OrigTemplateName, QualType::getFromOpaquePtr(ObjectType)); if (Template.isNull()) return SemaRef.ExprError(); - + llvm::SmallVector<TemplateArgument, 4> TransArgs; for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { - TemplateArgument TransArg + TemplateArgument TransArg = getDerived().TransformTemplateArgument(E->getTemplateArgs()[I]); if (TransArg.isNull()) return SemaRef.ExprError(); - + TransArgs.push_back(TransArg); } - + return getDerived().RebuildCXXUnresolvedMemberExpr(move(Base), E->isArrow(), E->getOperatorLoc(), @@ -4320,46 +4319,46 @@ TreeTransform<Derived>::TransformCXXUnresolvedMemberExpr( template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { - return SemaRef.Owned(E->Retain()); +TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { + return SemaRef.Owned(E->Retain()); } -template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { +template<typename Derived> +Sema::OwningExprResult +TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { // FIXME: poor source location TemporaryBase Rebase(*this, E->getAtLoc(), DeclarationName()); QualType EncodedType = getDerived().TransformType(E->getEncodedType()); if (EncodedType.isNull()) return SemaRef.ExprError(); - + if (!getDerived().AlwaysRebuild() && EncodedType == E->getEncodedType()) - return SemaRef.Owned(E->Retain()); + return SemaRef.Owned(E->Retain()); return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), EncodedType, E->getRParenLoc()); } - + template<typename Derived> Sema::OwningExprResult -TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { +TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { // FIXME: Implement this! assert(false && "Cannot transform Objective-C expressions yet"); - return SemaRef.Owned(E->Retain()); + return SemaRef.Owned(E->Retain()); } -template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { - return SemaRef.Owned(E->Retain()); +template<typename Derived> +Sema::OwningExprResult +TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { + return SemaRef.Owned(E->Retain()); } -template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { - ObjCProtocolDecl *Protocol +template<typename Derived> +Sema::OwningExprResult +TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { + ObjCProtocolDecl *Protocol = cast_or_null<ObjCProtocolDecl>( getDerived().TransformDecl(E->getProtocol())); if (!Protocol) @@ -4367,140 +4366,140 @@ TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { if (!getDerived().AlwaysRebuild() && Protocol == E->getProtocol()) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + return getDerived().RebuildObjCProtocolExpr(Protocol, E->getAtLoc(), /*FIXME:*/E->getAtLoc(), /*FIXME:*/E->getAtLoc(), E->getRParenLoc()); - + } -template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { +template<typename Derived> +Sema::OwningExprResult +TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { // FIXME: Implement this! assert(false && "Cannot transform Objective-C expressions yet"); - return SemaRef.Owned(E->Retain()); + return SemaRef.Owned(E->Retain()); } -template<typename Derived> -Sema::OwningExprResult +template<typename Derived> +Sema::OwningExprResult TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { // FIXME: Implement this! assert(false && "Cannot transform Objective-C expressions yet"); - return SemaRef.Owned(E->Retain()); + return SemaRef.Owned(E->Retain()); } -template<typename Derived> -Sema::OwningExprResult +template<typename Derived> +Sema::OwningExprResult TreeTransform<Derived>::TransformObjCImplicitSetterGetterRefExpr( - ObjCImplicitSetterGetterRefExpr *E) { + ObjCImplicitSetterGetterRefExpr *E) { // FIXME: Implement this! assert(false && "Cannot transform Objective-C expressions yet"); - return SemaRef.Owned(E->Retain()); + return SemaRef.Owned(E->Retain()); } -template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformObjCSuperExpr(ObjCSuperExpr *E) { +template<typename Derived> +Sema::OwningExprResult +TreeTransform<Derived>::TransformObjCSuperExpr(ObjCSuperExpr *E) { // FIXME: Implement this! assert(false && "Cannot transform Objective-C expressions yet"); - return SemaRef.Owned(E->Retain()); + return SemaRef.Owned(E->Retain()); } -template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) { +template<typename Derived> +Sema::OwningExprResult +TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) { // FIXME: Implement this! assert(false && "Cannot transform Objective-C expressions yet"); - return SemaRef.Owned(E->Retain()); + return SemaRef.Owned(E->Retain()); } -template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { +template<typename Derived> +Sema::OwningExprResult +TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { bool ArgumentChanged = false; ASTOwningVector<&ActionBase::DeleteExpr> SubExprs(SemaRef); for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) { OwningExprResult SubExpr = getDerived().TransformExpr(E->getExpr(I)); if (SubExpr.isInvalid()) return SemaRef.ExprError(); - + ArgumentChanged = ArgumentChanged || SubExpr.get() != E->getExpr(I); SubExprs.push_back(SubExpr.takeAs<Expr>()); } - + if (!getDerived().AlwaysRebuild() && !ArgumentChanged) - return SemaRef.Owned(E->Retain()); - + return SemaRef.Owned(E->Retain()); + return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), move_arg(SubExprs), E->getRParenLoc()); } -template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { +template<typename Derived> +Sema::OwningExprResult +TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { // FIXME: Implement this! assert(false && "Cannot transform block expressions yet"); - return SemaRef.Owned(E->Retain()); + return SemaRef.Owned(E->Retain()); } -template<typename Derived> -Sema::OwningExprResult -TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E) { +template<typename Derived> +Sema::OwningExprResult +TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E) { // FIXME: Implement this! assert(false && "Cannot transform block-related expressions yet"); - return SemaRef.Owned(E->Retain()); + return SemaRef.Owned(E->Retain()); } - + //===----------------------------------------------------------------------===// // Type reconstruction //===----------------------------------------------------------------------===// -template<typename Derived> +template<typename Derived> QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType) { - return SemaRef.BuildPointerType(PointeeType, 0, + return SemaRef.BuildPointerType(PointeeType, 0, getDerived().getBaseLocation(), getDerived().getBaseEntity()); } -template<typename Derived> +template<typename Derived> QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType) { - return SemaRef.BuildBlockPointerType(PointeeType, 0, + return SemaRef.BuildBlockPointerType(PointeeType, 0, getDerived().getBaseLocation(), getDerived().getBaseEntity()); } -template<typename Derived> -QualType +template<typename Derived> +QualType TreeTransform<Derived>::RebuildLValueReferenceType(QualType ReferentType) { - return SemaRef.BuildReferenceType(ReferentType, true, 0, + return SemaRef.BuildReferenceType(ReferentType, true, 0, getDerived().getBaseLocation(), getDerived().getBaseEntity()); } -template<typename Derived> -QualType +template<typename Derived> +QualType TreeTransform<Derived>::RebuildRValueReferenceType(QualType ReferentType) { - return SemaRef.BuildReferenceType(ReferentType, false, 0, + return SemaRef.BuildReferenceType(ReferentType, false, 0, getDerived().getBaseLocation(), getDerived().getBaseEntity()); } template<typename Derived> -QualType TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, +QualType TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, QualType ClassType) { - return SemaRef.BuildMemberPointerType(PointeeType, ClassType, 0, + return SemaRef.BuildMemberPointerType(PointeeType, ClassType, 0, getDerived().getBaseLocation(), getDerived().getBaseEntity()); } template<typename Derived> -QualType +QualType TreeTransform<Derived>::RebuildArrayType(QualType ElementType, ArrayType::ArraySizeModifier SizeMod, const llvm::APInt *Size, @@ -4511,11 +4510,11 @@ TreeTransform<Derived>::RebuildArrayType(QualType ElementType, return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, IndexTypeQuals, BracketsRange, getDerived().getBaseEntity()); - - QualType Types[] = { - SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, - SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, - SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty + + QualType Types[] = { + SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, + SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, + SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty }; const unsigned NumTypes = sizeof(Types) / sizeof(QualType); QualType SizeType; @@ -4524,78 +4523,78 @@ TreeTransform<Derived>::RebuildArrayType(QualType ElementType, SizeType = Types[I]; break; } - + if (SizeType.isNull()) SizeType = SemaRef.Context.getFixedWidthIntType(Size->getBitWidth(), false); - + IntegerLiteral ArraySize(*Size, SizeType, /*FIXME*/BracketsRange.getBegin()); - return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize, + return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize, IndexTypeQuals, BracketsRange, - getDerived().getBaseEntity()); + getDerived().getBaseEntity()); } - + template<typename Derived> -QualType -TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, +QualType +TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, ArrayType::ArraySizeModifier SizeMod, const llvm::APInt &Size, unsigned IndexTypeQuals) { - return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, + return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, IndexTypeQuals, SourceRange()); } template<typename Derived> -QualType -TreeTransform<Derived>::RebuildConstantArrayWithExprType(QualType ElementType, +QualType +TreeTransform<Derived>::RebuildConstantArrayWithExprType(QualType ElementType, ArrayType::ArraySizeModifier SizeMod, const llvm::APInt &Size, Expr *SizeExpr, unsigned IndexTypeQuals, SourceRange BracketsRange) { - return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, SizeExpr, + return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, SizeExpr, IndexTypeQuals, BracketsRange); } template<typename Derived> -QualType +QualType TreeTransform<Derived>::RebuildConstantArrayWithoutExprType( - QualType ElementType, + QualType ElementType, ArrayType::ArraySizeModifier SizeMod, const llvm::APInt &Size, unsigned IndexTypeQuals) { - return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, + return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, IndexTypeQuals, SourceRange()); } template<typename Derived> -QualType -TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, +QualType +TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, ArrayType::ArraySizeModifier SizeMod, unsigned IndexTypeQuals) { - return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0, + return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0, IndexTypeQuals, SourceRange()); } - + template<typename Derived> -QualType -TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, +QualType +TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, ArrayType::ArraySizeModifier SizeMod, ExprArg SizeExpr, unsigned IndexTypeQuals, SourceRange BracketsRange) { - return getDerived().RebuildArrayType(ElementType, SizeMod, 0, + return getDerived().RebuildArrayType(ElementType, SizeMod, 0, SizeExpr.takeAs<Expr>(), IndexTypeQuals, BracketsRange); } template<typename Derived> -QualType -TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, +QualType +TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, ArrayType::ArraySizeModifier SizeMod, ExprArg SizeExpr, unsigned IndexTypeQuals, SourceRange BracketsRange) { - return getDerived().RebuildArrayType(ElementType, SizeMod, 0, + return getDerived().RebuildArrayType(ElementType, SizeMod, 0, SizeExpr.takeAs<Expr>(), IndexTypeQuals, BracketsRange); } @@ -4606,7 +4605,7 @@ QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, // FIXME: semantic checking! return SemaRef.Context.getVectorType(ElementType, NumElements); } - + template<typename Derived> QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, unsigned NumElements, @@ -4614,32 +4613,32 @@ QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), NumElements, true); IntegerLiteral *VectorSize - = new (SemaRef.Context) IntegerLiteral(numElements, SemaRef.Context.IntTy, + = new (SemaRef.Context) IntegerLiteral(numElements, SemaRef.Context.IntTy, AttributeLoc); return SemaRef.BuildExtVectorType(ElementType, SemaRef.Owned(VectorSize), AttributeLoc); } - + template<typename Derived> -QualType -TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, +QualType +TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, ExprArg SizeExpr, SourceLocation AttributeLoc) { return SemaRef.BuildExtVectorType(ElementType, move(SizeExpr), AttributeLoc); } - + template<typename Derived> QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T, - QualType *ParamTypes, + QualType *ParamTypes, unsigned NumParamTypes, - bool Variadic, + bool Variadic, unsigned Quals) { - return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic, + return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic, Quals, getDerived().getBaseLocation(), getDerived().getBaseEntity()); } - + template<typename Derived> QualType TreeTransform<Derived>::RebuildTypeOfExprType(ExprArg E) { return SemaRef.BuildTypeofExprType(E.takeAs<Expr>()); @@ -4662,10 +4661,10 @@ QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( unsigned NumArgs) { // FIXME: Missing source locations for the template name, <, >. return SemaRef.CheckTemplateIdType(Template, getDerived().getBaseLocation(), - SourceLocation(), Args, NumArgs, - SourceLocation()); + SourceLocation(), Args, NumArgs, + SourceLocation()); } - + template<typename Derived> NestedNameSpecifier * TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, @@ -4678,7 +4677,7 @@ TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, SS.setRange(Range); SS.setScopeRep(Prefix); return static_cast<NestedNameSpecifier *>( - SemaRef.BuildCXXNestedNameSpecifier(0, SS, Range.getEnd(), + SemaRef.BuildCXXNestedNameSpecifier(0, SS, Range.getEnd(), Range.getEnd(), II, ObjectType, FirstQualifierInScope, @@ -4705,22 +4704,22 @@ TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, return NestedNameSpecifier::Create(SemaRef.Context, Prefix, TemplateKW, T.getTypePtr()); } - + SemaRef.Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T; return 0; } - + template<typename Derived> -TemplateName +TemplateName TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, bool TemplateKW, TemplateDecl *Template) { - return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, + return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, Template); } template<typename Derived> -TemplateName +TemplateName TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, bool TemplateKW, OverloadedFunctionDecl *Ovl) { @@ -4728,13 +4727,13 @@ TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, } template<typename Derived> -TemplateName +TemplateName TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, const IdentifierInfo &II, QualType ObjectType) { CXXScopeSpec SS; SS.setRange(SourceRange(getDerived().getBaseLocation())); - SS.setScopeRep(Qualifier); + SS.setScopeRep(Qualifier); return getSema().ActOnDependentTemplateName( /*FIXME:*/getDerived().getBaseLocation(), II, @@ -4743,9 +4742,9 @@ TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, ObjectType.getAsOpaquePtr()) .template getAsVal<TemplateName>(); } - + template<typename Derived> -Sema::OwningExprResult +Sema::OwningExprResult TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, SourceLocation OpLoc, ExprArg Callee, @@ -4754,73 +4753,73 @@ TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, Expr *FirstExpr = (Expr *)First.get(); Expr *SecondExpr = (Expr *)Second.get(); bool isPostIncDec = SecondExpr && (Op == OO_PlusPlus || Op == OO_MinusMinus); - + // Determine whether this should be a builtin operation. if (SecondExpr == 0 || isPostIncDec) { if (!FirstExpr->getType()->isOverloadableType()) { // The argument is not of overloadable type, so try to create a // built-in unary operation. - UnaryOperator::Opcode Opc + UnaryOperator::Opcode Opc = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); - + return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, move(First)); } } else { - if (!FirstExpr->getType()->isOverloadableType() && + if (!FirstExpr->getType()->isOverloadableType() && !SecondExpr->getType()->isOverloadableType()) { // Neither of the arguments is an overloadable type, so try to // create a built-in binary operation. BinaryOperator::Opcode Opc = BinaryOperator::getOverloadedOpcode(Op); - OwningExprResult Result + OwningExprResult Result = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, FirstExpr, SecondExpr); if (Result.isInvalid()) return SemaRef.ExprError(); - + First.release(); Second.release(); return move(Result); } } - - // Compute the transformed set of functions (and function templates) to be + + // Compute the transformed set of functions (and function templates) to be // used during overload resolution. Sema::FunctionSet Functions; - - DeclRefExpr *DRE + + DeclRefExpr *DRE = cast<DeclRefExpr>(((Expr *)Callee.get())->IgnoreParenCasts()); - + // FIXME: Do we have to check // IsAcceptableNonMemberOperatorCandidate for each of these? for (OverloadIterator F(DRE->getDecl()), FEnd; F != FEnd; ++F) Functions.insert(*F); - + // Add any functions found via argument-dependent lookup. Expr *Args[2] = { FirstExpr, SecondExpr }; unsigned NumArgs = 1 + (SecondExpr != 0); - DeclarationName OpName + DeclarationName OpName = SemaRef.Context.DeclarationNames.getCXXOperatorName(Op); SemaRef.ArgumentDependentLookup(OpName, Args, NumArgs, Functions); - + // Create the overloaded operator invocation for unary operators. if (NumArgs == 1 || isPostIncDec) { - UnaryOperator::Opcode Opc + UnaryOperator::Opcode Opc = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(First)); } - + // Create the overloaded operator invocation for binary operators. - BinaryOperator::Opcode Opc = + BinaryOperator::Opcode Opc = BinaryOperator::getOverloadedOpcode(Op); - OwningExprResult Result + OwningExprResult Result = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]); if (Result.isInvalid()) return SemaRef.ExprError(); - + First.release(); Second.release(); - return move(Result); + return move(Result); } - + } // end namespace clang #endif // LLVM_CLANG_SEMA_TREETRANSFORM_H |
