Remove tabs, and whitespace cleanups.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@81346 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Sema/TreeTransform.h b/lib/Sema/TreeTransform.h
index d19653d..bd7fb4f 100644
--- a/lib/Sema/TreeTransform.h
+++ b/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 @@
/// 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 @@
/// 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 @@
/// \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 @@
/// 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 @@
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 @@
/// 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 @@
/// \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 @@
/// 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 @@
///
/// \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 @@
///
/// \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 @@
/// \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 @@
/// 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 @@
/// \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 @@
/// 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 @@
///
/// 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 @@
///
/// 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 @@
/// 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 @@
/// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
///
/// 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 @@
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 @@
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 @@
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 @@
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 @@
/*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 @@
}
/// \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 @@
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 @@
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 @@
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 @@
}
/// \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 @@
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 @@
/*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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
///
/// 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 @@
SourceLocation ConstructorLParen,
MultiExprArg ConstructorArgs,
SourceLocation ConstructorRParen) {
- return getSema().BuildCXXNew(StartLoc, UseGlobal,
+ return getSema().BuildCXXNew(StartLoc, UseGlobal,
PlacementLParen,
move(PlacementArgs),
PlacementRParen,
@@ -1359,7 +1358,7 @@
move(ConstructorArgs),
ConstructorRParen);
}
-
+
/// \brief Build a new C++ "delete" expression.
///
/// By default, performs semantic analysis to build the new expression.
@@ -1371,7 +1370,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
Commas,
RParenLoc);
}
-
+
/// \brief Build a new member reference expression.
///
/// By default, performs semantic analysis to build the new expression.
@@ -1511,7 +1510,7 @@
CXXScopeSpec SS;
SS.setRange(QualifierRange);
SS.setScopeRep(Qualifier);
-
+
return SemaRef.BuildMemberReferenceExpr(/*Scope=*/0,
move(Base), OperatorLoc, OpKind,
MemberLoc,
@@ -1540,30 +1539,30 @@
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 @@
SourceLocation RParenLoc) {
return SemaRef.Owned(SemaRef.BuildObjCEncodeExpression(AtLoc, T,
RParenLoc));
- }
+ }
/// \brief Build a new Objective-C protocol expression.
///
@@ -1589,9 +1588,9 @@
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 @@
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 @@
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 @@
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::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 @@
#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 @@
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 @@
case DeclarationName::CXXOperatorName:
case DeclarationName::CXXUsingDirective:
return Name;
-
+
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName: {
@@ -1778,151 +1777,151 @@
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 @@
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) {
- // FIXME: Implement
- return QualType(T, 0);
-}
-
template<typename Derived>
-QualType TreeTransform<Derived>::TransformBuiltinType(const BuiltinType *T) {
+QualType TreeTransform<Derived>::TransformExtQualType(const ExtQualType *T) {
+ // FIXME: Implement
+ return QualType(T, 0);
+}
+
+template<typename Derived>
+QualType TreeTransform<Derived>::TransformBuiltinType(const BuiltinType *T) {
// Nothing to do
- return QualType(T, 0);
+ return QualType(T, 0);
}
-
-template<typename Derived>
-QualType TreeTransform<Derived>::TransformFixedWidthIntType(
- const FixedWidthIntType *T) {
- // FIXME: Implement
- return QualType(T, 0);
-}
-
+
template<typename Derived>
-QualType TreeTransform<Derived>::TransformComplexType(const ComplexType *T) {
+QualType TreeTransform<Derived>::TransformFixedWidthIntType(
+ const FixedWidthIntType *T) {
// FIXME: Implement
- return QualType(T, 0);
+ return QualType(T, 0);
}
-
-template<typename Derived>
+
+template<typename Derived>
+QualType TreeTransform<Derived>::TransformComplexType(const ComplexType *T) {
+ // FIXME: Implement
+ return QualType(T, 0);
+}
+
+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 @@
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 @@
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 @@
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 @@
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 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 @@
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 @@
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 @@
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 @@
//===----------------------------------------------------------------------===//
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
QualType T = getDerived().TransformType(ExceptionDecl->getType());
if (T.isNull())
return SemaRef.StmtError();
-
+
Var = getDerived().RebuildExceptionDecl(ExceptionDecl,
T,
ExceptionDecl->getDeclaratorInfo(),
@@ -2891,7 +2890,7 @@
return SemaRef.StmtError();
}
}
-
+
// Transform the actual exception handler.
OwningStmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
if (Handler.isInvalid()) {
@@ -2899,191 +2898,191 @@
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>::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>::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>::TransformCharacterLiteral(CharacterLiteral *E) {
- return SemaRef.Owned(E->Retain());
+Sema::OwningExprResult
+TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) {
+ return SemaRef.Owned(E->Retain());
}
-
+
template<typename Derived>
-Sema::OwningExprResult
-TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
+Sema::OwningExprResult
+TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) {
+ return SemaRef.Owned(E->Retain());
+}
+
+template<typename Derived>
+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 @@
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 @@
Qualifier,
E->getQualifierRange(),
E->getMemberLoc(),
- Member);
+ Member);
}
-
+
template<typename Derived>
-Sema::OwningExprResult
-TreeTransform<Derived>::TransformCastExpr(CastExpr *E) {
- assert(false && "Cannot transform abstract class");
- return SemaRef.Owned(E->Retain());
-}
-
-template<typename Derived>
Sema::OwningExprResult
-TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
+TreeTransform<Derived>::TransformCastExpr(CastExpr *E) {
+ assert(false && "Cannot transform abstract class");
+ return SemaRef.Owned(E->Retain());
+}
+
+template<typename Derived>
+Sema::OwningExprResult
+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) {
- assert(false && "Cannot transform abstract class");
- return SemaRef.Owned(E->Retain());
-}
-
+
template<typename Derived>
Sema::OwningExprResult
-TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
+TreeTransform<Derived>::TransformExplicitCastExpr(ExplicitCastExpr *E) {
+ assert(false && "Cannot transform abstract class");
+ return SemaRef.Owned(E->Retain());
+}
+
+template<typename Derived>
+Sema::OwningExprResult
+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 @@
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 @@
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 @@
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 @@
/// 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 @@
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 @@
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 @@
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 @@
move(SubExpr),
FakeRParenLoc);
}
-
-template<typename Derived>
-Sema::OwningExprResult
-TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) {
- return getDerived().TransformCXXNamedCastExpr(E);
-}
-
+
template<typename Derived>
Sema::OwningExprResult
-TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
+TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) {
return getDerived().TransformCXXNamedCastExpr(E);
}
-
+
+template<typename Derived>
+Sema::OwningExprResult
+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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
&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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
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,
- getDerived().getBaseLocation(),
- getDerived().getBaseEntity());
-}
-
-template<typename Derived>
-QualType
-TreeTransform<Derived>::RebuildRValueReferenceType(QualType ReferentType) {
- return SemaRef.BuildReferenceType(ReferentType, false, 0,
+ return SemaRef.BuildReferenceType(ReferentType, true, 0,
getDerived().getBaseLocation(),
getDerived().getBaseEntity());
}
template<typename Derived>
-QualType TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType,
+QualType
+TreeTransform<Derived>::RebuildRValueReferenceType(QualType ReferentType) {
+ return SemaRef.BuildReferenceType(ReferentType, false, 0,
+ getDerived().getBaseLocation(),
+ getDerived().getBaseEntity());
+}
+
+template<typename Derived>
+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 @@
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 @@
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 @@
// FIXME: semantic checking!
return SemaRef.Context.getVectorType(ElementType, NumElements);
}
-
+
template<typename Derived>
QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType,
unsigned NumElements,
@@ -4614,32 +4613,32 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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