lib/Sema/TreeTransform.h

   1 //===------- TreeTransform.h - Semantic Tree Transformation -----*- C++ -*-===/
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //===----------------------------------------------------------------------===/
   8 //
   9 //  This file implements a semantic tree transformation that takes a given
  10 //  AST and rebuilds it, possibly transforming some nodes in the process.
  11 //
  12 //===----------------------------------------------------------------------===/
  13 #ifndef LLVM_CLANG_SEMA_TREETRANSFORM_H
  14 #define LLVM_CLANG_SEMA_TREETRANSFORM_H
  15
  16 #include "Sema.h"
  17 #include "clang/Sema/SemaDiagnostic.h"
  18 #include "clang/AST/Decl.h"
  19 #include "clang/AST/Expr.h"
  20 #include "clang/AST/ExprCXX.h"
  21 #include "clang/AST/ExprObjC.h"
  22 #include "clang/AST/Stmt.h"
  23 #include "clang/AST/StmtCXX.h"
  24 #include "clang/AST/StmtObjC.h"
  25 #include "clang/AST/TypeLocBuilder.h"
  26 #include "clang/Parse/Ownership.h"
  27 #include "clang/Parse/Designator.h"
  28 #include "clang/Lex/Preprocessor.h"
  29 #include "llvm/Support/ErrorHandling.h"
  30 #include <algorithm>
  31
  32 namespace clang {
  33
  34 /// \brief A semantic tree transformation that allows one to transform one
  35 /// abstract syntax tree into another.
  36 ///
  37 /// A new tree transformation is defined by creating a new subclass \c X of
  38 /// \c TreeTransform<X> and then overriding certain operations to provide
  39 /// behavior specific to that transformation. For example, template
  40 /// instantiation is implemented as a tree transformation where the
  41 /// transformation of TemplateTypeParmType nodes involves substituting the
  42 /// template arguments for their corresponding template parameters; a similar
  43 /// transformation is performed for non-type template parameters and
  44 /// template template parameters.
  45 ///
  46 /// This tree-transformation template uses static polymorphism to allow
  47 /// subclasses to customize any of its operations. Thus, a subclass can
  48 /// override any of the transformation or rebuild operators by providing an
  49 /// operation with the same signature as the default implementation. The
  50 /// overridding function should not be virtual.
  51 ///
  52 /// Semantic tree transformations are split into two stages, either of which
  53 /// can be replaced by a subclass. The "transform" step transforms an AST node
  54 /// or the parts of an AST node using the various transformation functions,
  55 /// then passes the pieces on to the "rebuild" step, which constructs a new AST
  56 /// node of the appropriate kind from the pieces. The default transformation
  57 /// routines recursively transform the operands to composite AST nodes (e.g.,
  58 /// the pointee type of a PointerType node) and, if any of those operand nodes
  59 /// were changed by the transformation, invokes the rebuild operation to create
  60 /// a new AST node.
  61 ///
  62 /// Subclasses can customize the transformation at various levels. The
  63 /// most coarse-grained transformations involve replacing TransformType(),
  64 /// TransformExpr(), TransformDecl(), TransformNestedNameSpecifier(),
  65 /// TransformTemplateName(), or TransformTemplateArgument() with entirely
  66 /// new implementations.
  67 ///
  68 /// For more fine-grained transformations, subclasses can replace any of the
  69 /// \c TransformXXX functions (where XXX is the name of an AST node, e.g.,
  70 /// PointerType, StmtExpr) to alter the transformation. As mentioned previously,
  71 /// replacing TransformTemplateTypeParmType() allows template instantiation
  72 /// to substitute template arguments for their corresponding template
  73 /// parameters. Additionally, subclasses can override the \c RebuildXXX
  74 /// functions to control how AST nodes are rebuilt when their operands change.
  75 /// By default, \c TreeTransform will invoke semantic analysis to rebuild
  76 /// AST nodes. However, certain other tree transformations (e.g, cloning) may
  77 /// be able to use more efficient rebuild steps.
  78 ///
  79 /// There are a handful of other functions that can be overridden, allowing one
  80 /// to avoid traversing nodes that don't need any transformation
  81 /// (\c AlreadyTransformed()), force rebuilding AST nodes even when their
  82 /// operands have not changed (\c AlwaysRebuild()), and customize the
  83 /// default locations and entity names used for type-checking
  84 /// (\c getBaseLocation(), \c getBaseEntity()).
  85 template<typename Derived>
  86 class TreeTransform {
  87 protected:
  88   Sema &SemaRef;
  89
  90 public:
  91   typedef Sema::OwningStmtResult OwningStmtResult;
  92   typedef Sema::OwningExprResult OwningExprResult;
  93   typedef Sema::StmtArg StmtArg;
  94   typedef Sema::ExprArg ExprArg;
  95   typedef Sema::MultiExprArg MultiExprArg;
  96   typedef Sema::MultiStmtArg MultiStmtArg;
  97
  98   /// \brief Initializes a new tree transformer.
  99   TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { }
 100
 101   /// \brief Retrieves a reference to the derived class.
 102   Derived &getDerived() { return static_cast<Derived&>(*this); }
 103
 104   /// \brief Retrieves a reference to the derived class.
 105   const Derived &getDerived() const {
 106     return static_cast<const Derived&>(*this);
 107   }
 108
 109   /// \brief Retrieves a reference to the semantic analysis object used for
 110   /// this tree transform.
 111   Sema &getSema() const { return SemaRef; }
 112
 113   /// \brief Whether the transformation should always rebuild AST nodes, even
 114   /// if none of the children have changed.
 115   ///
 116   /// Subclasses may override this function to specify when the transformation
 117   /// should rebuild all AST nodes.
 118   bool AlwaysRebuild() { return false; }
 119
 120   /// \brief Returns the location of the entity being transformed, if that
 121   /// information was not available elsewhere in the AST.
 122   ///
 123   /// By default, returns no source-location information. Subclasses can
 124   /// provide an alternative implementation that provides better location
 125   /// information.
 126   SourceLocation getBaseLocation() { return SourceLocation(); }
 127
 128   /// \brief Returns the name of the entity being transformed, if that
 129   /// information was not available elsewhere in the AST.
 130   ///
 131   /// By default, returns an empty name. Subclasses can provide an alternative
 132   /// implementation with a more precise name.
 133   DeclarationName getBaseEntity() { return DeclarationName(); }
 134
 135   /// \brief Sets the "base" location and entity when that
 136   /// information is known based on another transformation.
 137   ///
 138   /// By default, the source location and entity are ignored. Subclasses can
 139   /// override this function to provide a customized implementation.
 140   void setBase(SourceLocation Loc, DeclarationName Entity) { }
 141
 142   /// \brief RAII object that temporarily sets the base location and entity
 143   /// used for reporting diagnostics in types.
 144   class TemporaryBase {
 145     TreeTransform &Self;
 146     SourceLocation OldLocation;
 147     DeclarationName OldEntity;
 148
 149   public:
 150     TemporaryBase(TreeTransform &Self, SourceLocation Location,
 151                   DeclarationName Entity) : Self(Self) {
 152       OldLocation = Self.getDerived().getBaseLocation();
 153       OldEntity = Self.getDerived().getBaseEntity();
 154       Self.getDerived().setBase(Location, Entity);
 155     }
 156
 157     ~TemporaryBase() {
 158       Self.getDerived().setBase(OldLocation, OldEntity);
 159     }
 160   };
 161
 162   /// \brief Determine whether the given type \p T has already been
 163   /// transformed.
 164   ///
 165   /// Subclasses can provide an alternative implementation of this routine
 166   /// to short-circuit evaluation when it is known that a given type will
 167   /// not change. For example, template instantiation need not traverse
 168   /// non-dependent types.
 169   bool AlreadyTransformed(QualType T) {
 170     return T.isNull();
 171   }
 172
 173   /// \brief Transforms the given type into another type.
 174   ///
 175   /// By default, this routine transforms a type by creating a
 176   /// DeclaratorInfo for it and delegating to the appropriate
 177   /// function.  This is expensive, but we don't mind, because
 178   /// this method is deprecated anyway;  all users should be
 179   /// switched to storing DeclaratorInfos.
 180   ///
 181   /// \returns the transformed type.
 182   QualType TransformType(QualType T);
 183
 184   /// \brief Transforms the given type-with-location into a new
 185   /// type-with-location.
 186   ///
 187   /// By default, this routine transforms a type by delegating to the
 188   /// appropriate TransformXXXType to build a new type.  Subclasses
 189   /// may override this function (to take over all type
 190   /// transformations) or some set of the TransformXXXType functions
 191   /// to alter the transformation.
 192   DeclaratorInfo *TransformType(DeclaratorInfo *DI);
 193
 194   /// \brief Transform the given type-with-location into a new
 195   /// type, collecting location information in the given builder
 196   /// as necessary.
 197   ///
 198   QualType TransformType(TypeLocBuilder &TLB, TypeLoc TL);
 199
 200   /// \brief Transform the given statement.
 201   ///
 202   /// By default, this routine transforms a statement by delegating to the
 203   /// appropriate TransformXXXStmt function to transform a specific kind of
 204   /// statement or the TransformExpr() function to transform an expression.
 205   /// Subclasses may override this function to transform statements using some
 206   /// other mechanism.
 207   ///
 208   /// \returns the transformed statement.
 209   OwningStmtResult TransformStmt(Stmt *S);
 210
 211   /// \brief Transform the given expression.
 212   ///
 213   /// By default, this routine transforms an expression by delegating to the
 214   /// appropriate TransformXXXExpr function to build a new expression.
 215   /// Subclasses may override this function to transform expressions using some
 216   /// other mechanism.
 217   ///
 218   /// \returns the transformed expression.
 219   OwningExprResult TransformExpr(Expr *E) {
 220     return getDerived().TransformExpr(E, /*isAddressOfOperand=*/false);
 221   }
 222
 223   /// \brief Transform the given expression.
 224   ///
 225   /// By default, this routine transforms an expression by delegating to the
 226   /// appropriate TransformXXXExpr function to build a new expression.
 227   /// Subclasses may override this function to transform expressions using some
 228   /// other mechanism.
 229   ///
 230   /// \returns the transformed expression.
 231   OwningExprResult TransformExpr(Expr *E, bool isAddressOfOperand);
 232
 233   /// \brief Transform the given declaration, which is referenced from a type
 234   /// or expression.
 235   ///
 236   /// By default, acts as the identity function on declarations. Subclasses
 237   /// may override this function to provide alternate behavior.
 238   Decl *TransformDecl(Decl *D) { return D; }
 239
 240   /// \brief Transform the definition of the given declaration.
 241   ///
 242   /// By default, invokes TransformDecl() to transform the declaration.
 243   /// Subclasses may override this function to provide alternate behavior.
 244   Decl *TransformDefinition(Decl *D) { return getDerived().TransformDecl(D); }
 245
 246   /// \brief Transform the given declaration, which was the first part of a
 247   /// nested-name-specifier in a member access expression.
 248   ///
 249   /// This specific declaration transformation only applies to the first
 250   /// identifier in a nested-name-specifier of a member access expression, e.g.,
 251   /// the \c T in \c x->T::member
 252   ///
 253   /// By default, invokes TransformDecl() to transform the declaration.
 254   /// Subclasses may override this function to provide alternate behavior.
 255   NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc) {
 256     return cast_or_null<NamedDecl>(getDerived().TransformDecl(D));
 257   }
 258
 259   /// \brief Transform the given nested-name-specifier.
 260   ///
 261   /// By default, transforms all of the types and declarations within the
 262   /// nested-name-specifier. Subclasses may override this function to provide
 263   /// alternate behavior.
 264   NestedNameSpecifier *TransformNestedNameSpecifier(NestedNameSpecifier *NNS,
 265                                                     SourceRange Range,
 266                                               QualType ObjectType = QualType(),
 267                                           NamedDecl *FirstQualifierInScope = 0);
 268
 269   /// \brief Transform the given declaration name.
 270   ///
 271   /// By default, transforms the types of conversion function, constructor,
 272   /// and destructor names and then (if needed) rebuilds the declaration name.
 273   /// Identifiers and selectors are returned unmodified. Sublcasses may
 274   /// override this function to provide alternate behavior.
 275   DeclarationName TransformDeclarationName(DeclarationName Name,
 276                                            SourceLocation Loc,
 277                                            QualType ObjectType = QualType());
 278
 279   /// \brief Transform the given template name.
 280   ///
 281   /// By default, transforms the template name by transforming the declarations
 282   /// and nested-name-specifiers that occur within the template name.
 283   /// Subclasses may override this function to provide alternate behavior.
 284   TemplateName TransformTemplateName(TemplateName Name,
 285                                      QualType ObjectType = QualType());
 286
 287   /// \brief Transform the given template argument.
 288   ///
 289   /// By default, this operation transforms the type, expression, or
 290   /// declaration stored within the template argument and constructs a
 291   /// new template argument from the transformed result. Subclasses may
 292   /// override this function to provide alternate behavior.
 293   ///
 294   /// Returns true if there was an error.
 295   bool TransformTemplateArgument(const TemplateArgumentLoc &Input,
 296                                  TemplateArgumentLoc &Output);
 297
 298   /// \brief Fakes up a TemplateArgumentLoc for a given TemplateArgument.
 299   void InventTemplateArgumentLoc(const TemplateArgument &Arg,
 300                                  TemplateArgumentLoc &ArgLoc);
 301
 302   /// \brief Fakes up a DeclaratorInfo for a type.
 303   DeclaratorInfo *InventDeclaratorInfo(QualType T) {
 304     return SemaRef.Context.getTrivialDeclaratorInfo(T,
 305                        getDerived().getBaseLocation());
 306   }
 307
 308 #define ABSTRACT_TYPELOC(CLASS, PARENT)
 309 #define TYPELOC(CLASS, PARENT)                                   \
 310   QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
 311 #include "clang/AST/TypeLocNodes.def"
 312
 313   QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);
 314
 315   QualType
 316   TransformTemplateSpecializationType(const TemplateSpecializationType *T,
 317                                       QualType ObjectType);
 318
 319   QualType
 320   TransformTemplateSpecializationType(TypeLocBuilder &TLB,
 321                                       TemplateSpecializationTypeLoc TL,
 322                                       QualType ObjectType);
 323
 324   OwningStmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr);
 325
 326 #define STMT(Node, Parent)                        \
 327   OwningStmtResult Transform##Node(Node *S);
 328 #define EXPR(Node, Parent)                        \
 329   OwningExprResult Transform##Node(Node *E, bool isAddressOfOperand);
 330 #define ABSTRACT_EXPR(Node, Parent)
 331 #include "clang/AST/StmtNodes.def"
 332
 333   /// \brief Build a new pointer type given its pointee type.
 334   ///
 335   /// By default, performs semantic analysis when building the pointer type.
 336   /// Subclasses may override this routine to provide different behavior.
 337   QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);
 338
 339   /// \brief Build a new block pointer type given its pointee type.
 340   ///
 341   /// By default, performs semantic analysis when building the block pointer
 342   /// type. Subclasses may override this routine to provide different behavior.
 343   QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);
 344
 345   /// \brief Build a new reference type given the type it references.
 346   ///
 347   /// By default, performs semantic analysis when building the
 348   /// reference type. Subclasses may override this routine to provide
 349   /// different behavior.
 350   ///
 351   /// \param LValue whether the type was written with an lvalue sigil
 352   /// or an rvalue sigil.
 353   QualType RebuildReferenceType(QualType ReferentType,
 354                                 bool LValue,
 355                                 SourceLocation Sigil);
 356
 357   /// \brief Build a new member pointer type given the pointee type and the
 358   /// class type it refers into.
 359   ///
 360   /// By default, performs semantic analysis when building the member pointer
 361   /// type. Subclasses may override this routine to provide different behavior.
 362   QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
 363                                     SourceLocation Sigil);
 364
 365   /// \brief Build a new Objective C object pointer type.
 366   QualType RebuildObjCObjectPointerType(QualType PointeeType,
 367                                         SourceLocation Sigil);
 368
 369   /// \brief Build a new array type given the element type, size
 370   /// modifier, size of the array (if known), size expression, and index type
 371   /// qualifiers.
 372   ///
 373   /// By default, performs semantic analysis when building the array type.
 374   /// Subclasses may override this routine to provide different behavior.
 375   /// Also by default, all of the other Rebuild*Array
 376   QualType RebuildArrayType(QualType ElementType,
 377                             ArrayType::ArraySizeModifier SizeMod,
 378                             const llvm::APInt *Size,
 379                             Expr *SizeExpr,
 380                             unsigned IndexTypeQuals,
 381                             SourceRange BracketsRange);
 382
 383   /// \brief Build a new constant array type given the element type, size
 384   /// modifier, (known) size of the array, and index type qualifiers.
 385   ///
 386   /// By default, performs semantic analysis when building the array type.
 387   /// Subclasses may override this routine to provide different behavior.
 388   QualType RebuildConstantArrayType(QualType ElementType,
 389                                     ArrayType::ArraySizeModifier SizeMod,
 390                                     const llvm::APInt &Size,
 391                                     unsigned IndexTypeQuals,
 392                                     SourceRange BracketsRange);
 393
 394   /// \brief Build a new incomplete array type given the element type, size
 395   /// modifier, and index type qualifiers.
 396   ///
 397   /// By default, performs semantic analysis when building the array type.
 398   /// Subclasses may override this routine to provide different behavior.
 399   QualType RebuildIncompleteArrayType(QualType ElementType,
 400                                       ArrayType::ArraySizeModifier SizeMod,
 401                                       unsigned IndexTypeQuals,
 402                                       SourceRange BracketsRange);
 403
 404   /// \brief Build a new variable-length array type given the element type,
 405   /// size modifier, size expression, and index type qualifiers.
 406   ///
 407   /// By default, performs semantic analysis when building the array type.
 408   /// Subclasses may override this routine to provide different behavior.
 409   QualType RebuildVariableArrayType(QualType ElementType,
 410                                     ArrayType::ArraySizeModifier SizeMod,
 411                                     ExprArg SizeExpr,
 412                                     unsigned IndexTypeQuals,
 413                                     SourceRange BracketsRange);
 414
 415   /// \brief Build a new dependent-sized array type given the element type,
 416   /// size modifier, size expression, and index type qualifiers.
 417   ///
 418   /// By default, performs semantic analysis when building the array type.
 419   /// Subclasses may override this routine to provide different behavior.
 420   QualType RebuildDependentSizedArrayType(QualType ElementType,
 421                                           ArrayType::ArraySizeModifier SizeMod,
 422                                           ExprArg SizeExpr,
 423                                           unsigned IndexTypeQuals,
 424                                           SourceRange BracketsRange);
 425
 426   /// \brief Build a new vector type given the element type and
 427   /// number of elements.
 428   ///
 429   /// By default, performs semantic analysis when building the vector type.
 430   /// Subclasses may override this routine to provide different behavior.
 431   QualType RebuildVectorType(QualType ElementType, unsigned NumElements);
 432
 433   /// \brief Build a new extended vector type given the element type and
 434   /// number of elements.
 435   ///
 436   /// By default, performs semantic analysis when building the vector type.
 437   /// Subclasses may override this routine to provide different behavior.
 438   QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements,
 439                                 SourceLocation AttributeLoc);
 440
 441   /// \brief Build a new potentially dependently-sized extended vector type
 442   /// given the element type and number of elements.
 443   ///
 444   /// By default, performs semantic analysis when building the vector type.
 445   /// Subclasses may override this routine to provide different behavior.
 446   QualType RebuildDependentSizedExtVectorType(QualType ElementType,
 447                                               ExprArg SizeExpr,
 448                                               SourceLocation AttributeLoc);
 449
 450   /// \brief Build a new function type.
 451   ///
 452   /// By default, performs semantic analysis when building the function type.
 453   /// Subclasses may override this routine to provide different behavior.
 454   QualType RebuildFunctionProtoType(QualType T,
 455                                     QualType *ParamTypes,
 456                                     unsigned NumParamTypes,
 457                                     bool Variadic, unsigned Quals);
 458
 459   /// \brief Build a new unprototyped function type.
 460   QualType RebuildFunctionNoProtoType(QualType ResultType);
 461
 462   /// \brief Build a new typedef type.
 463   QualType RebuildTypedefType(TypedefDecl *Typedef) {
 464     return SemaRef.Context.getTypeDeclType(Typedef);
 465   }
 466
 467   /// \brief Build a new class/struct/union type.
 468   QualType RebuildRecordType(RecordDecl *Record) {
 469     return SemaRef.Context.getTypeDeclType(Record);
 470   }
 471
 472   /// \brief Build a new Enum type.
 473   QualType RebuildEnumType(EnumDecl *Enum) {
 474     return SemaRef.Context.getTypeDeclType(Enum);
 475   }
 476
 477   /// \brief Build a new elaborated type.
 478   QualType RebuildElaboratedType(QualType T, ElaboratedType::TagKind Tag) {
 479     return SemaRef.Context.getElaboratedType(T, Tag);
 480   }
 481
 482   /// \brief Build a new typeof(expr) type.
 483   ///
 484   /// By default, performs semantic analysis when building the typeof type.
 485   /// Subclasses may override this routine to provide different behavior.
 486   QualType RebuildTypeOfExprType(ExprArg Underlying);
 487
 488   /// \brief Build a new typeof(type) type.
 489   ///
 490   /// By default, builds a new TypeOfType with the given underlying type.
 491   QualType RebuildTypeOfType(QualType Underlying);
 492
 493   /// \brief Build a new C++0x decltype type.
 494   ///
 495   /// By default, performs semantic analysis when building the decltype type.
 496   /// Subclasses may override this routine to provide different behavior.
 497   QualType RebuildDecltypeType(ExprArg Underlying);
 498
 499   /// \brief Build a new template specialization type.
 500   ///
 501   /// By default, performs semantic analysis when building the template
 502   /// specialization type. Subclasses may override this routine to provide
 503   /// different behavior.
 504   QualType RebuildTemplateSpecializationType(TemplateName Template,
 505                                              SourceLocation TemplateLoc,
 506                                              SourceLocation LAngleLoc,
 507                                              const TemplateArgumentLoc *Args,
 508                                              unsigned NumArgs,
 509                                              SourceLocation RAngleLoc);
 510
 511   /// \brief Build a new qualified name type.
 512   ///
 513   /// By default, builds a new QualifiedNameType type from the
 514   /// nested-name-specifier and the named type. Subclasses may override
 515   /// this routine to provide different behavior.
 516   QualType RebuildQualifiedNameType(NestedNameSpecifier *NNS, QualType Named) {
 517     return SemaRef.Context.getQualifiedNameType(NNS, Named);
 518   }
 519
 520   /// \brief Build a new typename type that refers to a template-id.
 521   ///
 522   /// By default, builds a new TypenameType type from the nested-name-specifier
 523   /// and the given type. Subclasses may override this routine to provide
 524   /// different behavior.
 525   QualType RebuildTypenameType(NestedNameSpecifier *NNS, QualType T) {
 526     if (NNS->isDependent())
 527       return SemaRef.Context.getTypenameType(NNS,
 528                                           cast<TemplateSpecializationType>(T));
 529
 530     return SemaRef.Context.getQualifiedNameType(NNS, T);
 531   }
 532
 533   /// \brief Build a new typename type that refers to an identifier.
 534   ///
 535   /// By default, performs semantic analysis when building the typename type
 536   /// (or qualified name type). Subclasses may override this routine to provide
 537   /// different behavior.
 538   QualType RebuildTypenameType(NestedNameSpecifier *NNS,
 539                                const IdentifierInfo *Id,
 540                                SourceRange SR) {
 541     return SemaRef.CheckTypenameType(NNS, *Id, SR);
 542   }
 543
 544   /// \brief Build a new nested-name-specifier given the prefix and an
 545   /// identifier that names the next step in the nested-name-specifier.
 546   ///
 547   /// By default, performs semantic analysis when building the new
 548   /// nested-name-specifier. Subclasses may override this routine to provide
 549   /// different behavior.
 550   NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
 551                                                   SourceRange Range,
 552                                                   IdentifierInfo &II,
 553                                                   QualType ObjectType,
 554                                               NamedDecl *FirstQualifierInScope);
 555
 556   /// \brief Build a new nested-name-specifier given the prefix and the
 557   /// namespace named in the next step in the nested-name-specifier.
 558   ///
 559   /// By default, performs semantic analysis when building the new
 560   /// nested-name-specifier. Subclasses may override this routine to provide
 561   /// different behavior.
 562   NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
 563                                                   SourceRange Range,
 564                                                   NamespaceDecl *NS);
 565
 566   /// \brief Build a new nested-name-specifier given the prefix and the
 567   /// type named in the next step in the nested-name-specifier.
 568   ///
 569   /// By default, performs semantic analysis when building the new
 570   /// nested-name-specifier. Subclasses may override this routine to provide
 571   /// different behavior.
 572   NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
 573                                                   SourceRange Range,
 574                                                   bool TemplateKW,
 575                                                   QualType T);
 576
 577   /// \brief Build a new template name given a nested name specifier, a flag
 578   /// indicating whether the "template" keyword was provided, and the template
 579   /// that the template name refers to.
 580   ///
 581   /// By default, builds the new template name directly. Subclasses may override
 582   /// this routine to provide different behavior.
 583   TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier,
 584                                    bool TemplateKW,
 585                                    TemplateDecl *Template);
 586
 587   /// \brief Build a new template name given a nested name specifier, a flag
 588   /// indicating whether the "template" keyword was provided, and a set of
 589   /// overloaded function templates.
 590   ///
 591   /// By default, builds the new template name directly. Subclasses may override
 592   /// this routine to provide different behavior.
 593   TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier,
 594                                    bool TemplateKW,
 595                                    OverloadedFunctionDecl *Ovl);
 596
 597   /// \brief Build a new template name given a nested name specifier and the
 598   /// name that is referred to as a template.
 599   ///
 600   /// By default, performs semantic analysis to determine whether the name can
 601   /// be resolved to a specific template, then builds the appropriate kind of
 602   /// template name. Subclasses may override this routine to provide different
 603   /// behavior.
 604   TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier,
 605                                    const IdentifierInfo &II,
 606                                    QualType ObjectType);
 607
 608   /// \brief Build a new template name given a nested name specifier and the
 609   /// overloaded operator name that is referred to as a template.
 610   ///
 611   /// By default, performs semantic analysis to determine whether the name can
 612   /// be resolved to a specific template, then builds the appropriate kind of
 613   /// template name. Subclasses may override this routine to provide different
 614   /// behavior.
 615   TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier,
 616                                    OverloadedOperatorKind Operator,
 617                                    QualType ObjectType);
 618
 619   /// \brief Build a new compound statement.
 620   ///
 621   /// By default, performs semantic analysis to build the new statement.
 622   /// Subclasses may override this routine to provide different behavior.
 623   OwningStmtResult RebuildCompoundStmt(SourceLocation LBraceLoc,
 624                                        MultiStmtArg Statements,
 625                                        SourceLocation RBraceLoc,
 626                                        bool IsStmtExpr) {
 627     return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, move(Statements),
 628                                        IsStmtExpr);
 629   }
 630
 631   /// \brief Build a new case statement.
 632   ///
 633   /// By default, performs semantic analysis to build the new statement.
 634   /// Subclasses may override this routine to provide different behavior.
 635   OwningStmtResult RebuildCaseStmt(SourceLocation CaseLoc,
 636                                    ExprArg LHS,
 637                                    SourceLocation EllipsisLoc,
 638                                    ExprArg RHS,
 639                                    SourceLocation ColonLoc) {
 640     return getSema().ActOnCaseStmt(CaseLoc, move(LHS), EllipsisLoc, move(RHS),
 641                                    ColonLoc);
 642   }
 643
 644   /// \brief Attach the body to a new case statement.
 645   ///
 646   /// By default, performs semantic analysis to build the new statement.
 647   /// Subclasses may override this routine to provide different behavior.
 648   OwningStmtResult RebuildCaseStmtBody(StmtArg S, StmtArg Body) {
 649     getSema().ActOnCaseStmtBody(S.get(), move(Body));
 650     return move(S);
 651   }
 652
 653   /// \brief Build a new default statement.
 654   ///
 655   /// By default, performs semantic analysis to build the new statement.
 656   /// Subclasses may override this routine to provide different behavior.
 657   OwningStmtResult RebuildDefaultStmt(SourceLocation DefaultLoc,
 658                                       SourceLocation ColonLoc,
 659                                       StmtArg SubStmt) {
 660     return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, move(SubStmt),
 661                                       /*CurScope=*/0);
 662   }
 663
 664   /// \brief Build a new label statement.
 665   ///
 666   /// By default, performs semantic analysis to build the new statement.
 667   /// Subclasses may override this routine to provide different behavior.
 668   OwningStmtResult RebuildLabelStmt(SourceLocation IdentLoc,
 669                                     IdentifierInfo *Id,
 670                                     SourceLocation ColonLoc,
 671                                     StmtArg SubStmt) {
 672     return SemaRef.ActOnLabelStmt(IdentLoc, Id, ColonLoc, move(SubStmt));
 673   }
 674
 675   /// \brief Build a new "if" statement.
 676   ///
 677   /// By default, performs semantic analysis to build the new statement.
 678   /// Subclasses may override this routine to provide different behavior.
 679   OwningStmtResult RebuildIfStmt(SourceLocation IfLoc, Sema::FullExprArg Cond,
 680                                  StmtArg Then, SourceLocation ElseLoc,
 681                                  StmtArg Else) {
 682     return getSema().ActOnIfStmt(IfLoc, Cond, move(Then), ElseLoc, move(Else));
 683   }
 684
 685   /// \brief Start building a new switch statement.
 686   ///
 687   /// By default, performs semantic analysis to build the new statement.
 688   /// Subclasses may override this routine to provide different behavior.
 689   OwningStmtResult RebuildSwitchStmtStart(ExprArg Cond) {
 690     return getSema().ActOnStartOfSwitchStmt(move(Cond));
 691   }
 692
 693   /// \brief Attach the body to the switch statement.
 694   ///
 695   /// By default, performs semantic analysis to build the new statement.
 696   /// Subclasses may override this routine to provide different behavior.
 697   OwningStmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc,
 698                                          StmtArg Switch, StmtArg Body) {
 699     return getSema().ActOnFinishSwitchStmt(SwitchLoc, move(Switch),
 700                                          move(Body));
 701   }
 702
 703   /// \brief Build a new while statement.
 704   ///
 705   /// By default, performs semantic analysis to build the new statement.
 706   /// Subclasses may override this routine to provide different behavior.
 707   OwningStmtResult RebuildWhileStmt(SourceLocation WhileLoc,
 708                                     Sema::FullExprArg Cond,
 709                                     StmtArg Body) {
 710     return getSema().ActOnWhileStmt(WhileLoc, Cond, move(Body));
 711   }
 712
 713   /// \brief Build a new do-while statement.
 714   ///
 715   /// By default, performs semantic analysis to build the new statement.
 716   /// Subclasses may override this routine to provide different behavior.
 717   OwningStmtResult RebuildDoStmt(SourceLocation DoLoc, StmtArg Body,
 718                                  SourceLocation WhileLoc,
 719                                  SourceLocation LParenLoc,
 720                                  ExprArg Cond,
 721                                  SourceLocation RParenLoc) {
 722     return getSema().ActOnDoStmt(DoLoc, move(Body), WhileLoc, LParenLoc,
 723                                  move(Cond), RParenLoc);
 724   }
 725
 726   /// \brief Build a new for statement.
 727   ///
 728   /// By default, performs semantic analysis to build the new statement.
 729   /// Subclasses may override this routine to provide different behavior.
 730   OwningStmtResult RebuildForStmt(SourceLocation ForLoc,
 731                                   SourceLocation LParenLoc,
 732                                   StmtArg Init, ExprArg Cond, ExprArg Inc,
 733                                   SourceLocation RParenLoc, StmtArg Body) {
 734     return getSema().ActOnForStmt(ForLoc, LParenLoc, move(Init), move(Cond),
 735                                   move(Inc), RParenLoc, move(Body));
 736   }
 737
 738   /// \brief Build a new goto statement.
 739   ///
 740   /// By default, performs semantic analysis to build the new statement.
 741   /// Subclasses may override this routine to provide different behavior.
 742   OwningStmtResult RebuildGotoStmt(SourceLocation GotoLoc,
 743                                    SourceLocation LabelLoc,
 744                                    LabelStmt *Label) {
 745     return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label->getID());
 746   }
 747
 748   /// \brief Build a new indirect goto statement.
 749   ///
 750   /// By default, performs semantic analysis to build the new statement.
 751   /// Subclasses may override this routine to provide different behavior.
 752   OwningStmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc,
 753                                            SourceLocation StarLoc,
 754                                            ExprArg Target) {
 755     return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, move(Target));
 756   }
 757
 758   /// \brief Build a new return statement.
 759   ///
 760   /// By default, performs semantic analysis to build the new statement.
 761   /// Subclasses may override this routine to provide different behavior.
 762   OwningStmtResult RebuildReturnStmt(SourceLocation ReturnLoc,
 763                                      ExprArg Result) {
 764
 765     return getSema().ActOnReturnStmt(ReturnLoc, move(Result));
 766   }
 767
 768   /// \brief Build a new declaration statement.
 769   ///
 770   /// By default, performs semantic analysis to build the new statement.
 771   /// Subclasses may override this routine to provide different behavior.
 772   OwningStmtResult RebuildDeclStmt(Decl **Decls, unsigned NumDecls,
 773                                    SourceLocation StartLoc,
 774                                    SourceLocation EndLoc) {
 775     return getSema().Owned(
 776              new (getSema().Context) DeclStmt(
 777                                         DeclGroupRef::Create(getSema().Context,
 778                                                              Decls, NumDecls),
 779                                               StartLoc, EndLoc));
 780   }
 781
 782   /// \brief Build a new C++ exception declaration.
 783   ///
 784   /// By default, performs semantic analysis to build the new decaration.
 785   /// Subclasses may override this routine to provide different behavior.
 786   VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl, QualType T,
 787                                 DeclaratorInfo *Declarator,
 788                                 IdentifierInfo *Name,
 789                                 SourceLocation Loc,
 790                                 SourceRange TypeRange) {
 791     return getSema().BuildExceptionDeclaration(0, T, Declarator, Name, Loc,
 792                                                TypeRange);
 793   }
 794
 795   /// \brief Build a new C++ catch statement.
 796   ///
 797   /// By default, performs semantic analysis to build the new statement.
 798   /// Subclasses may override this routine to provide different behavior.
 799   OwningStmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc,
 800                                        VarDecl *ExceptionDecl,
 801                                        StmtArg Handler) {
 802     return getSema().Owned(
 803              new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl,
 804                                                   Handler.takeAs<Stmt>()));
 805   }
 806
 807   /// \brief Build a new C++ try statement.
 808   ///
 809   /// By default, performs semantic analysis to build the new statement.
 810   /// Subclasses may override this routine to provide different behavior.
 811   OwningStmtResult RebuildCXXTryStmt(SourceLocation TryLoc,
 812                                      StmtArg TryBlock,
 813                                      MultiStmtArg Handlers) {
 814     return getSema().ActOnCXXTryBlock(TryLoc, move(TryBlock), move(Handlers));
 815   }
 816
 817   /// \brief Build a new expression that references a declaration.
 818   ///
 819   /// By default, performs semantic analysis to build the new expression.
 820   /// Subclasses may override this routine to provide different behavior.
 821   OwningExprResult RebuildDeclRefExpr(NestedNameSpecifier *Qualifier,
 822                                       SourceRange QualifierRange,
 823                                       NamedDecl *ND, SourceLocation Loc,
 824                                       bool isAddressOfOperand) {
 825     CXXScopeSpec SS;
 826     SS.setScopeRep(Qualifier);
 827     SS.setRange(QualifierRange);
 828     return getSema().BuildDeclarationNameExpr(Loc, ND,
 829                                               /*FIXME:*/false,
 830                                               &SS,
 831                                               isAddressOfOperand);
 832   }
 833
 834   /// \brief Build a new expression in parentheses.
 835   ///
 836   /// By default, performs semantic analysis to build the new expression.
 837   /// Subclasses may override this routine to provide different behavior.
 838   OwningExprResult RebuildParenExpr(ExprArg SubExpr, SourceLocation LParen,
 839                                     SourceLocation RParen) {
 840     return getSema().ActOnParenExpr(LParen, RParen, move(SubExpr));
 841   }
 842
 843   /// \brief Build a new pseudo-destructor expression.
 844   ///
 845   /// By default, performs semantic analysis to build the new expression.
 846   /// Subclasses may override this routine to provide different behavior.
 847   OwningExprResult RebuildCXXPseudoDestructorExpr(ExprArg Base,
 848                                                   SourceLocation OperatorLoc,
 849                                                   bool isArrow,
 850                                               SourceLocation DestroyedTypeLoc,
 851                                                   QualType DestroyedType,
 852                                                NestedNameSpecifier *Qualifier,
 853                                                   SourceRange QualifierRange) {
 854     CXXScopeSpec SS;
 855     if (Qualifier) {
 856       SS.setRange(QualifierRange);
 857       SS.setScopeRep(Qualifier);
 858     }
 859
 860     DeclarationName Name
 861       = SemaRef.Context.DeclarationNames.getCXXDestructorName(
 862                                SemaRef.Context.getCanonicalType(DestroyedType));
 863
 864     return getSema().BuildMemberReferenceExpr(/*Scope=*/0, move(Base),
 865                                               OperatorLoc,
 866                                               isArrow? tok::arrow : tok::period,
 867                                               DestroyedTypeLoc,
 868                                               Name,
 869                                               Sema::DeclPtrTy::make((Decl *)0),
 870                                               &SS);
 871   }
 872
 873   /// \brief Build a new unary operator expression.
 874   ///
 875   /// By default, performs semantic analysis to build the new expression.
 876   /// Subclasses may override this routine to provide different behavior.
 877   OwningExprResult RebuildUnaryOperator(SourceLocation OpLoc,
 878                                         UnaryOperator::Opcode Opc,
 879                                         ExprArg SubExpr) {
 880     return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, move(SubExpr));
 881   }
 882
 883   /// \brief Build a new sizeof or alignof expression with a type argument.
 884   ///
 885   /// By default, performs semantic analysis to build the new expression.
 886   /// Subclasses may override this routine to provide different behavior.
 887   OwningExprResult RebuildSizeOfAlignOf(DeclaratorInfo *DInfo,
 888                                         SourceLocation OpLoc,
 889                                         bool isSizeOf, SourceRange R) {
 890     return getSema().CreateSizeOfAlignOfExpr(DInfo, OpLoc, isSizeOf, R);
 891   }
 892
 893   /// \brief Build a new sizeof or alignof expression with an expression
 894   /// argument.
 895   ///
 896   /// By default, performs semantic analysis to build the new expression.
 897   /// Subclasses may override this routine to provide different behavior.
 898   OwningExprResult RebuildSizeOfAlignOf(ExprArg SubExpr, SourceLocation OpLoc,
 899                                         bool isSizeOf, SourceRange R) {
 900     OwningExprResult Result
 901       = getSema().CreateSizeOfAlignOfExpr((Expr *)SubExpr.get(),
 902                                           OpLoc, isSizeOf, R);
 903     if (Result.isInvalid())
 904       return getSema().ExprError();
 905
 906     SubExpr.release();
 907     return move(Result);
 908   }
 909
 910   /// \brief Build a new array subscript expression.
 911   ///
 912   /// By default, performs semantic analysis to build the new expression.
 913   /// Subclasses may override this routine to provide different behavior.
 914   OwningExprResult RebuildArraySubscriptExpr(ExprArg LHS,
 915                                              SourceLocation LBracketLoc,
 916                                              ExprArg RHS,
 917                                              SourceLocation RBracketLoc) {
 918     return getSema().ActOnArraySubscriptExpr(/*Scope=*/0, move(LHS),
 919                                              LBracketLoc, move(RHS),
 920                                              RBracketLoc);
 921   }
 922
 923   /// \brief Build a new call expression.
 924   ///
 925   /// By default, performs semantic analysis to build the new expression.
 926   /// Subclasses may override this routine to provide different behavior.
 927   OwningExprResult RebuildCallExpr(ExprArg Callee, SourceLocation LParenLoc,
 928                                    MultiExprArg Args,
 929                                    SourceLocation *CommaLocs,
 930                                    SourceLocation RParenLoc) {
 931     return getSema().ActOnCallExpr(/*Scope=*/0, move(Callee), LParenLoc,
 932                                    move(Args), CommaLocs, RParenLoc);
 933   }
 934
 935   /// \brief Build a new member access expression.
 936   ///
 937   /// By default, performs semantic analysis to build the new expression.
 938   /// Subclasses may override this routine to provide different behavior.
 939   OwningExprResult RebuildMemberExpr(ExprArg Base, SourceLocation OpLoc,
 940                                      bool isArrow,
 941                                      NestedNameSpecifier *Qualifier,
 942                                      SourceRange QualifierRange,
 943                                      SourceLocation MemberLoc,
 944                                      NamedDecl *Member) {
 945     if (!Member->getDeclName()) {
 946       // We have a reference to an unnamed field.
 947       assert(!Qualifier && "Can't have an unnamed field with a qualifier!");
 948
 949       MemberExpr *ME =
 950         new (getSema().Context) MemberExpr(Base.takeAs<Expr>(), isArrow,
 951                                            Member, MemberLoc,
 952                                            cast<FieldDecl>(Member)->getType());
 953       return getSema().Owned(ME);
 954     }
 955
 956     CXXScopeSpec SS;
 957     if (Qualifier) {
 958       SS.setRange(QualifierRange);
 959       SS.setScopeRep(Qualifier);
 960     }
 961
 962     return getSema().BuildMemberReferenceExpr(/*Scope=*/0, move(Base), OpLoc,
 963                                               isArrow? tok::arrow : tok::period,
 964                                               MemberLoc,
 965                                               Member->getDeclName(),
 966                                      /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0),
 967                                               &SS);
 968   }
 969
 970   /// \brief Build a new binary operator expression.
 971   ///
 972   /// By default, performs semantic analysis to build the new expression.
 973   /// Subclasses may override this routine to provide different behavior.
 974   OwningExprResult RebuildBinaryOperator(SourceLocation OpLoc,
 975                                          BinaryOperator::Opcode Opc,
 976                                          ExprArg LHS, ExprArg RHS) {
 977     OwningExprResult Result
 978       = getSema().CreateBuiltinBinOp(OpLoc, Opc, (Expr *)LHS.get(),
 979                                      (Expr *)RHS.get());
 980     if (Result.isInvalid())
 981       return SemaRef.ExprError();
 982
 983     LHS.release();
 984     RHS.release();
 985     return move(Result);
 986   }
 987
 988   /// \brief Build a new conditional operator expression.
 989   ///
 990   /// By default, performs semantic analysis to build the new expression.
 991   /// Subclasses may override this routine to provide different behavior.
 992   OwningExprResult RebuildConditionalOperator(ExprArg Cond,
 993                                               SourceLocation QuestionLoc,
 994                                               ExprArg LHS,
 995                                               SourceLocation ColonLoc,
 996                                               ExprArg RHS) {
 997     return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, move(Cond),
 998                                         move(LHS), move(RHS));
 999   }
1000
1001   /// \brief Build a new implicit cast expression.
1002   ///
1003   /// By default, builds a new implicit cast without any semantic analysis.
1004   /// Subclasses may override this routine to provide different behavior.
1005   OwningExprResult RebuildImplicitCastExpr(QualType T, CastExpr::CastKind Kind,
1006                                            ExprArg SubExpr, bool isLvalue) {
1007     ImplicitCastExpr *ICE
1008       = new (getSema().Context) ImplicitCastExpr(T, Kind,
1009                                                  (Expr *)SubExpr.release(),
1010                                                  isLvalue);
1011     return getSema().Owned(ICE);
1012   }
1013
1014   /// \brief Build a new C-style cast expression.
1015   ///
1016   /// By default, performs semantic analysis to build the new expression.
1017   /// Subclasses may override this routine to provide different behavior.
1018   OwningExprResult RebuildCStyleCaseExpr(SourceLocation LParenLoc,
1019                                          QualType ExplicitTy,
1020                                          SourceLocation RParenLoc,
1021                                          ExprArg SubExpr) {
1022     return getSema().ActOnCastExpr(/*Scope=*/0,
1023                                    LParenLoc,
1024                                    ExplicitTy.getAsOpaquePtr(),
1025                                    RParenLoc,
1026                                    move(SubExpr));
1027   }
1028
1029   /// \brief Build a new compound literal expression.
1030   ///
1031   /// By default, performs semantic analysis to build the new expression.
1032   /// Subclasses may override this routine to provide different behavior.
1033   OwningExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc,
1034                                               QualType T,
1035                                               SourceLocation RParenLoc,
1036                                               ExprArg Init) {
1037     return getSema().ActOnCompoundLiteral(LParenLoc, T.getAsOpaquePtr(),
1038                                           RParenLoc, move(Init));
1039   }
1040
1041   /// \brief Build a new extended vector element access expression.
1042   ///
1043   /// By default, performs semantic analysis to build the new expression.
1044   /// Subclasses may override this routine to provide different behavior.
1045   OwningExprResult RebuildExtVectorElementExpr(ExprArg Base,
1046                                                SourceLocation OpLoc,
1047                                                SourceLocation AccessorLoc,
1048                                                IdentifierInfo &Accessor) {
1049     return getSema().BuildMemberReferenceExpr(/*Scope=*/0, move(Base), OpLoc,
1050                                               tok::period, AccessorLoc,
1051                                               DeclarationName(&Accessor),
1052                                      /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0));
1053   }
1054
1055   /// \brief Build a new initializer list expression.
1056   ///
1057   /// By default, performs semantic analysis to build the new expression.
1058   /// Subclasses may override this routine to provide different behavior.
1059   OwningExprResult RebuildInitList(SourceLocation LBraceLoc,
1060                                    MultiExprArg Inits,
1061                                    SourceLocation RBraceLoc) {
1062     return SemaRef.ActOnInitList(LBraceLoc, move(Inits), RBraceLoc);
1063   }
1064
1065   /// \brief Build a new designated initializer expression.
1066   ///
1067   /// By default, performs semantic analysis to build the new expression.
1068   /// Subclasses may override this routine to provide different behavior.
1069   OwningExprResult RebuildDesignatedInitExpr(Designation &Desig,
1070                                              MultiExprArg ArrayExprs,
1071                                              SourceLocation EqualOrColonLoc,
1072                                              bool GNUSyntax,
1073                                              ExprArg Init) {
1074     OwningExprResult Result
1075       = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
1076                                            move(Init));
1077     if (Result.isInvalid())
1078       return SemaRef.ExprError();
1079
1080     ArrayExprs.release();
1081     return move(Result);
1082   }
1083
1084   /// \brief Build a new value-initialized expression.
1085   ///
1086   /// By default, builds the implicit value initialization without performing
1087   /// any semantic analysis. Subclasses may override this routine to provide
1088   /// different behavior.
1089   OwningExprResult RebuildImplicitValueInitExpr(QualType T) {
1090     return SemaRef.Owned(new (SemaRef.Context) ImplicitValueInitExpr(T));
1091   }
1092
1093   /// \brief Build a new \c va_arg expression.
1094   ///
1095   /// By default, performs semantic analysis to build the new expression.
1096   /// Subclasses may override this routine to provide different behavior.
1097   OwningExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc, ExprArg SubExpr,
1098                                     QualType T, SourceLocation RParenLoc) {
1099     return getSema().ActOnVAArg(BuiltinLoc, move(SubExpr), T.getAsOpaquePtr(),
1100                                 RParenLoc);
1101   }
1102
1103   /// \brief Build a new expression list in parentheses.
1104   ///
1105   /// By default, performs semantic analysis to build the new expression.
1106   /// Subclasses may override this routine to provide different behavior.
1107   OwningExprResult RebuildParenListExpr(SourceLocation LParenLoc,
1108                                         MultiExprArg SubExprs,
1109                                         SourceLocation RParenLoc) {
1110     return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, move(SubExprs));
1111   }
1112
1113   /// \brief Build a new address-of-label expression.
1114   ///
1115   /// By default, performs semantic analysis, using the name of the label
1116   /// rather than attempting to map the label statement itself.
1117   /// Subclasses may override this routine to provide different behavior.
1118   OwningExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc,
1119                                         SourceLocation LabelLoc,
1120                                         LabelStmt *Label) {
1121     return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label->getID());
1122   }
1123
1124   /// \brief Build a new GNU statement expression.
1125   ///
1126   /// By default, performs semantic analysis to build the new expression.
1127   /// Subclasses may override this routine to provide different behavior.
1128   OwningExprResult RebuildStmtExpr(SourceLocation LParenLoc,
1129                                    StmtArg SubStmt,
1130                                    SourceLocation RParenLoc) {
1131     return getSema().ActOnStmtExpr(LParenLoc, move(SubStmt), RParenLoc);
1132   }
1133
1134   /// \brief Build a new __builtin_types_compatible_p expression.
1135   ///
1136   /// By default, performs semantic analysis to build the new expression.
1137   /// Subclasses may override this routine to provide different behavior.
1138   OwningExprResult RebuildTypesCompatibleExpr(SourceLocation BuiltinLoc,
1139                                               QualType T1, QualType T2,
1140                                               SourceLocation RParenLoc) {
1141     return getSema().ActOnTypesCompatibleExpr(BuiltinLoc,
1142                                               T1.getAsOpaquePtr(),
1143                                               T2.getAsOpaquePtr(),
1144                                               RParenLoc);
1145   }
1146
1147   /// \brief Build a new __builtin_choose_expr expression.
1148   ///
1149   /// By default, performs semantic analysis to build the new expression.
1150   /// Subclasses may override this routine to provide different behavior.
1151   OwningExprResult RebuildChooseExpr(SourceLocation BuiltinLoc,
1152                                      ExprArg Cond, ExprArg LHS, ExprArg RHS,
1153                                      SourceLocation RParenLoc) {
1154     return SemaRef.ActOnChooseExpr(BuiltinLoc,
1155                                    move(Cond), move(LHS), move(RHS),
1156                                    RParenLoc);
1157   }
1158
1159   /// \brief Build a new overloaded operator call expression.
1160   ///
1161   /// By default, performs semantic analysis to build the new expression.
1162   /// The semantic analysis provides the behavior of template instantiation,
1163   /// copying with transformations that turn what looks like an overloaded
1164   /// operator call into a use of a builtin operator, performing
1165   /// argument-dependent lookup, etc. Subclasses may override this routine to
1166   /// provide different behavior.
1167   OwningExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
1168                                               SourceLocation OpLoc,
1169                                               ExprArg Callee,
1170                                               ExprArg First,
1171                                               ExprArg Second);
1172
1173   /// \brief Build a new C++ "named" cast expression, such as static_cast or
1174   /// reinterpret_cast.
1175   ///
1176   /// By default, this routine dispatches to one of the more-specific routines
1177   /// for a particular named case, e.g., RebuildCXXStaticCastExpr().
1178   /// Subclasses may override this routine to provide different behavior.
1179   OwningExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc,
1180                                            Stmt::StmtClass Class,
1181                                            SourceLocation LAngleLoc,
1182                                            QualType T,
1183                                            SourceLocation RAngleLoc,
1184                                            SourceLocation LParenLoc,
1185                                            ExprArg SubExpr,
1186                                            SourceLocation RParenLoc) {
1187     switch (Class) {
1188     case Stmt::CXXStaticCastExprClass:
1189       return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, T,
1190                                                    RAngleLoc, LParenLoc,
1191                                                    move(SubExpr), RParenLoc);
1192
1193     case Stmt::CXXDynamicCastExprClass:
1194       return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, T,
1195                                                     RAngleLoc, LParenLoc,
1196                                                     move(SubExpr), RParenLoc);
1197
1198     case Stmt::CXXReinterpretCastExprClass:
1199       return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, T,
1200                                                         RAngleLoc, LParenLoc,
1201                                                         move(SubExpr),
1202                                                         RParenLoc);
1203
1204     case Stmt::CXXConstCastExprClass:
1205       return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, T,
1206                                                    RAngleLoc, LParenLoc,
1207                                                    move(SubExpr), RParenLoc);
1208
1209     default:
1210       assert(false && "Invalid C++ named cast");
1211       break;
1212     }
1213
1214     return getSema().ExprError();
1215   }
1216
1217   /// \brief Build a new C++ static_cast expression.
1218   ///
1219   /// By default, performs semantic analysis to build the new expression.
1220   /// Subclasses may override this routine to provide different behavior.
1221   OwningExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc,
1222                                             SourceLocation LAngleLoc,
1223                                             QualType T,
1224                                             SourceLocation RAngleLoc,
1225                                             SourceLocation LParenLoc,
1226                                             ExprArg SubExpr,
1227                                             SourceLocation RParenLoc) {
1228     return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_static_cast,
1229                                        LAngleLoc, T.getAsOpaquePtr(), RAngleLoc,
1230                                        LParenLoc, move(SubExpr), RParenLoc);
1231   }
1232
1233   /// \brief Build a new C++ dynamic_cast expression.
1234   ///
1235   /// By default, performs semantic analysis to build the new expression.
1236   /// Subclasses may override this routine to provide different behavior.
1237   OwningExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc,
1238                                              SourceLocation LAngleLoc,
1239                                              QualType T,
1240                                              SourceLocation RAngleLoc,
1241                                              SourceLocation LParenLoc,
1242                                              ExprArg SubExpr,
1243                                              SourceLocation RParenLoc) {
1244     return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
1245                                        LAngleLoc, T.getAsOpaquePtr(), RAngleLoc,
1246                                        LParenLoc, move(SubExpr), RParenLoc);
1247   }
1248
1249   /// \brief Build a new C++ reinterpret_cast expression.
1250   ///
1251   /// By default, performs semantic analysis to build the new expression.
1252   /// Subclasses may override this routine to provide different behavior.
1253   OwningExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc,
1254                                                  SourceLocation LAngleLoc,
1255                                                  QualType T,
1256                                                  SourceLocation RAngleLoc,
1257                                                  SourceLocation LParenLoc,
1258                                                  ExprArg SubExpr,
1259                                                  SourceLocation RParenLoc) {
1260     return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
1261                                        LAngleLoc, T.getAsOpaquePtr(), RAngleLoc,
1262                                        LParenLoc, move(SubExpr), RParenLoc);
1263   }
1264
1265   /// \brief Build a new C++ const_cast expression.
1266   ///
1267   /// By default, performs semantic analysis to build the new expression.
1268   /// Subclasses may override this routine to provide different behavior.
1269   OwningExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc,
1270                                            SourceLocation LAngleLoc,
1271                                            QualType T,
1272                                            SourceLocation RAngleLoc,
1273                                            SourceLocation LParenLoc,
1274                                            ExprArg SubExpr,
1275                                            SourceLocation RParenLoc) {
1276     return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_const_cast,
1277                                        LAngleLoc, T.getAsOpaquePtr(), RAngleLoc,
1278                                        LParenLoc, move(SubExpr), RParenLoc);
1279   }
1280
1281   /// \brief Build a new C++ functional-style cast expression.
1282   ///
1283   /// By default, performs semantic analysis to build the new expression.
1284   /// Subclasses may override this routine to provide different behavior.
1285   OwningExprResult RebuildCXXFunctionalCastExpr(SourceRange TypeRange,
1286                                                 QualType T,
1287                                                 SourceLocation LParenLoc,
1288                                                 ExprArg SubExpr,
1289                                                 SourceLocation RParenLoc) {
1290     void *Sub = SubExpr.takeAs<Expr>();
1291     return getSema().ActOnCXXTypeConstructExpr(TypeRange,
1292                                                T.getAsOpaquePtr(),
1293                                                LParenLoc,
1294                                          Sema::MultiExprArg(getSema(), &Sub, 1),
1295                                                /*CommaLocs=*/0,
1296                                                RParenLoc);
1297   }
1298
1299   /// \brief Build a new C++ typeid(type) expression.
1300   ///
1301   /// By default, performs semantic analysis to build the new expression.
1302   /// Subclasses may override this routine to provide different behavior.
1303   OwningExprResult RebuildCXXTypeidExpr(SourceLocation TypeidLoc,
1304                                         SourceLocation LParenLoc,
1305                                         QualType T,
1306                                         SourceLocation RParenLoc) {
1307     return getSema().ActOnCXXTypeid(TypeidLoc, LParenLoc, true,
1308                                     T.getAsOpaquePtr(), RParenLoc);
1309   }
1310
1311   /// \brief Build a new C++ typeid(expr) expression.
1312   ///
1313   /// By default, performs semantic analysis to build the new expression.
1314   /// Subclasses may override this routine to provide different behavior.
1315   OwningExprResult RebuildCXXTypeidExpr(SourceLocation TypeidLoc,
1316                                         SourceLocation LParenLoc,
1317                                         ExprArg Operand,
1318                                         SourceLocation RParenLoc) {
1319     OwningExprResult Result
1320       = getSema().ActOnCXXTypeid(TypeidLoc, LParenLoc, false, Operand.get(),
1321                                  RParenLoc);
1322     if (Result.isInvalid())
1323       return getSema().ExprError();
1324
1325     Operand.release(); // FIXME: since ActOnCXXTypeid silently took ownership
1326     return move(Result);
1327   }
1328
1329   /// \brief Build a new C++ "this" expression.
1330   ///
1331   /// By default, builds a new "this" expression without performing any
1332   /// semantic analysis. Subclasses may override this routine to provide
1333   /// different behavior.
1334   OwningExprResult RebuildCXXThisExpr(SourceLocation ThisLoc,
1335                                       QualType ThisType) {
1336     return getSema().Owned(
1337                       new (getSema().Context) CXXThisExpr(ThisLoc, ThisType));
1338   }
1339
1340   /// \brief Build a new C++ throw expression.
1341   ///
1342   /// By default, performs semantic analysis to build the new expression.
1343   /// Subclasses may override this routine to provide different behavior.
1344   OwningExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, ExprArg Sub) {
1345     return getSema().ActOnCXXThrow(ThrowLoc, move(Sub));
1346   }
1347
1348   /// \brief Build a new C++ default-argument expression.
1349   ///
1350   /// By default, builds a new default-argument expression, which does not
1351   /// require any semantic analysis. Subclasses may override this routine to
1352   /// provide different behavior.
1353   OwningExprResult RebuildCXXDefaultArgExpr(ParmVarDecl *Param) {
1354     return getSema().Owned(CXXDefaultArgExpr::Create(getSema().Context, Param));
1355   }
1356
1357   /// \brief Build a new C++ zero-initialization expression.
1358   ///
1359   /// By default, performs semantic analysis to build the new expression.
1360   /// Subclasses may override this routine to provide different behavior.
1361   OwningExprResult RebuildCXXZeroInitValueExpr(SourceLocation TypeStartLoc,
1362                                                SourceLocation LParenLoc,
1363                                                QualType T,
1364                                                SourceLocation RParenLoc) {
1365     return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeStartLoc),
1366                                                T.getAsOpaquePtr(), LParenLoc,
1367                                                MultiExprArg(getSema(), 0, 0),
1368                                                0, RParenLoc);
1369   }
1370
1371   /// \brief Build a new C++ conditional declaration expression.
1372   ///
1373   /// By default, performs semantic analysis to build the new expression.
1374   /// Subclasses may override this routine to provide different behavior.
1375   OwningExprResult RebuildCXXConditionDeclExpr(SourceLocation StartLoc,
1376                                                SourceLocation EqLoc,
1377                                                VarDecl *Var) {
1378     return SemaRef.Owned(new (SemaRef.Context) CXXConditionDeclExpr(StartLoc,
1379                                                                     EqLoc,
1380                                                                     Var));
1381   }
1382
1383   /// \brief Build a new C++ "new" expression.
1384   ///
1385   /// By default, performs semantic analysis to build the new expression.
1386   /// Subclasses may override this routine to provide different behavior.
1387   OwningExprResult RebuildCXXNewExpr(SourceLocation StartLoc,
1388                                      bool UseGlobal,
1389                                      SourceLocation PlacementLParen,
1390                                      MultiExprArg PlacementArgs,
1391                                      SourceLocation PlacementRParen,
1392                                      bool ParenTypeId,
1393                                      QualType AllocType,
1394                                      SourceLocation TypeLoc,
1395                                      SourceRange TypeRange,
1396                                      ExprArg ArraySize,
1397                                      SourceLocation ConstructorLParen,
1398                                      MultiExprArg ConstructorArgs,
1399                                      SourceLocation ConstructorRParen) {
1400     return getSema().BuildCXXNew(StartLoc, UseGlobal,
1401                                  PlacementLParen,
1402                                  move(PlacementArgs),
1403                                  PlacementRParen,
1404                                  ParenTypeId,
1405                                  AllocType,
1406                                  TypeLoc,
1407                                  TypeRange,
1408                                  move(ArraySize),
1409                                  ConstructorLParen,
1410                                  move(ConstructorArgs),
1411                                  ConstructorRParen);
1412   }
1413
1414   /// \brief Build a new C++ "delete" expression.
1415   ///
1416   /// By default, performs semantic analysis to build the new expression.
1417   /// Subclasses may override this routine to provide different behavior.
1418   OwningExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc,
1419                                         bool IsGlobalDelete,
1420                                         bool IsArrayForm,
1421                                         ExprArg Operand) {
1422     return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
1423                                     move(Operand));
1424   }
1425
1426   /// \brief Build a new unary type trait expression.
1427   ///
1428   /// By default, performs semantic analysis to build the new expression.
1429   /// Subclasses may override this routine to provide different behavior.
1430   OwningExprResult RebuildUnaryTypeTrait(UnaryTypeTrait Trait,
1431                                          SourceLocation StartLoc,
1432                                          SourceLocation LParenLoc,
1433                                          QualType T,
1434                                          SourceLocation RParenLoc) {
1435     return getSema().ActOnUnaryTypeTrait(Trait, StartLoc, LParenLoc,
1436                                          T.getAsOpaquePtr(), RParenLoc);
1437   }
1438
1439   /// \brief Build a new (previously unresolved) declaration reference
1440   /// expression.
1441   ///
1442   /// By default, performs semantic analysis to build the new expression.
1443   /// Subclasses may override this routine to provide different behavior.
1444   OwningExprResult RebuildUnresolvedDeclRefExpr(NestedNameSpecifier *NNS,
1445                                                 SourceRange QualifierRange,
1446                                                 DeclarationName Name,
1447                                                 SourceLocation Location,
1448                                                 bool IsAddressOfOperand) {
1449     CXXScopeSpec SS;
1450     SS.setRange(QualifierRange);
1451     SS.setScopeRep(NNS);
1452     return getSema().ActOnDeclarationNameExpr(/*Scope=*/0,
1453                                               Location,
1454                                               Name,
1455                                               /*Trailing lparen=*/false,
1456                                               &SS,
1457                                               IsAddressOfOperand);
1458   }
1459
1460   /// \brief Build a new template-id expression.
1461   ///
1462   /// By default, performs semantic analysis to build the new expression.
1463   /// Subclasses may override this routine to provide different behavior.
1464   OwningExprResult RebuildTemplateIdExpr(NestedNameSpecifier *Qualifier,
1465                                          SourceRange QualifierRange,
1466                                          TemplateName Template,
1467                                          SourceLocation TemplateLoc,
1468                                          SourceLocation LAngleLoc,
1469                                          TemplateArgumentLoc *TemplateArgs,
1470                                          unsigned NumTemplateArgs,
1471                                          SourceLocation RAngleLoc) {
1472     return getSema().BuildTemplateIdExpr(Qualifier, QualifierRange,
1473                                          Template, TemplateLoc,
1474                                          LAngleLoc,
1475                                          TemplateArgs, NumTemplateArgs,
1476                                          RAngleLoc);
1477   }
1478
1479   /// \brief Build a new object-construction expression.
1480   ///
1481   /// By default, performs semantic analysis to build the new expression.
1482   /// Subclasses may override this routine to provide different behavior.
1483   OwningExprResult RebuildCXXConstructExpr(QualType T,
1484                                            CXXConstructorDecl *Constructor,
1485                                            bool IsElidable,
1486                                            MultiExprArg Args) {
1487     return getSema().BuildCXXConstructExpr(/*FIXME:ConstructLoc*/
1488                                            SourceLocation(),
1489                                            T, Constructor, IsElidable,
1490                                            move(Args));
1491   }
1492
1493   /// \brief Build a new object-construction expression.
1494   ///
1495   /// By default, performs semantic analysis to build the new expression.
1496   /// Subclasses may override this routine to provide different behavior.
1497   OwningExprResult RebuildCXXTemporaryObjectExpr(SourceLocation TypeBeginLoc,
1498                                                  QualType T,
1499                                                  SourceLocation LParenLoc,
1500                                                  MultiExprArg Args,
1501                                                  SourceLocation *Commas,
1502                                                  SourceLocation RParenLoc) {
1503     return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeBeginLoc),
1504                                                T.getAsOpaquePtr(),
1505                                                LParenLoc,
1506                                                move(Args),
1507                                                Commas,
1508                                                RParenLoc);
1509   }
1510
1511   /// \brief Build a new object-construction expression.
1512   ///
1513   /// By default, performs semantic analysis to build the new expression.
1514   /// Subclasses may override this routine to provide different behavior.
1515   OwningExprResult RebuildCXXUnresolvedConstructExpr(SourceLocation TypeBeginLoc,
1516                                                      QualType T,
1517                                                      SourceLocation LParenLoc,
1518                                                      MultiExprArg Args,
1519                                                      SourceLocation *Commas,
1520                                                      SourceLocation RParenLoc) {
1521     return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeBeginLoc,
1522                                                            /*FIXME*/LParenLoc),
1523                                                T.getAsOpaquePtr(),
1524                                                LParenLoc,
1525                                                move(Args),
1526                                                Commas,
1527                                                RParenLoc);
1528   }
1529
1530   /// \brief Build a new member reference expression.
1531   ///
1532   /// By default, performs semantic analysis to build the new expression.
1533   /// Subclasses may override this routine to provide different behavior.
1534   OwningExprResult RebuildCXXUnresolvedMemberExpr(ExprArg BaseE,
1535                                                   bool IsArrow,
1536                                                   SourceLocation OperatorLoc,
1537                                               NestedNameSpecifier *Qualifier,
1538                                                   SourceRange QualifierRange,
1539                                                   DeclarationName Name,
1540                                                   SourceLocation MemberLoc,
1541                                              NamedDecl *FirstQualifierInScope) {
1542     OwningExprResult Base = move(BaseE);
1543     tok::TokenKind OpKind = IsArrow? tok::arrow : tok::period;
1544
1545     CXXScopeSpec SS;
1546     SS.setRange(QualifierRange);
1547     SS.setScopeRep(Qualifier);
1548
1549     return SemaRef.BuildMemberReferenceExpr(/*Scope=*/0,
1550                                             move(Base), OperatorLoc, OpKind,
1551                                             MemberLoc,
1552                                             Name,
1553                                     /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0),
1554                                             &SS,
1555                                             FirstQualifierInScope);
1556   }
1557
1558   /// \brief Build a new member reference expression with explicit template
1559   /// arguments.
1560   ///
1561   /// By default, performs semantic analysis to build the new expression.
1562   /// Subclasses may override this routine to provide different behavior.
1563   OwningExprResult RebuildCXXUnresolvedMemberExpr(ExprArg BaseE,
1564                                                   bool IsArrow,
1565                                                   SourceLocation OperatorLoc,
1566                                                 NestedNameSpecifier *Qualifier,
1567                                                   SourceRange QualifierRange,
1568                                                   TemplateName Template,
1569                                                 SourceLocation TemplateNameLoc,
1570                                               NamedDecl *FirstQualifierInScope,
1571                                                   SourceLocation LAngleLoc,
1572                                        const TemplateArgumentLoc *TemplateArgs,
1573                                                   unsigned NumTemplateArgs,
1574                                                   SourceLocation RAngleLoc) {
1575     OwningExprResult Base = move(BaseE);
1576     tok::TokenKind OpKind = IsArrow? tok::arrow : tok::period;
1577
1578     CXXScopeSpec SS;
1579     SS.setRange(QualifierRange);
1580     SS.setScopeRep(Qualifier);
1581
1582     // FIXME: We're going to end up looking up the template based on its name,
1583     // twice! Also, duplicates part of Sema::BuildMemberAccessExpr.
1584     DeclarationName Name;
1585     if (TemplateDecl *ActualTemplate = Template.getAsTemplateDecl())
1586       Name = ActualTemplate->getDeclName();
1587     else if (OverloadedFunctionDecl *Ovl
1588                = Template.getAsOverloadedFunctionDecl())
1589       Name = Ovl->getDeclName();
1590     else {
1591       DependentTemplateName *DTN = Template.getAsDependentTemplateName();
1592       if (DTN->isIdentifier())
1593         Name = DTN->getIdentifier();
1594       else
1595         Name = SemaRef.Context.DeclarationNames.getCXXOperatorName(
1596                                                           DTN->getOperator());
1597     }
1598       return SemaRef.BuildMemberReferenceExpr(/*Scope=*/0, move(Base),
1599                                               OperatorLoc, OpKind,
1600                                               TemplateNameLoc, Name, true,
1601                                               LAngleLoc, TemplateArgs,
1602                                               NumTemplateArgs, RAngleLoc,
1603                                               Sema::DeclPtrTy(), &SS);
1604   }
1605
1606   /// \brief Build a new Objective-C @encode expression.
1607   ///
1608   /// By default, performs semantic analysis to build the new expression.
1609   /// Subclasses may override this routine to provide different behavior.
1610   OwningExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc,
1611                                          QualType T,
1612                                          SourceLocation RParenLoc) {
1613     return SemaRef.Owned(SemaRef.BuildObjCEncodeExpression(AtLoc, T,
1614                                                            RParenLoc));
1615   }
1616
1617   /// \brief Build a new Objective-C protocol expression.
1618   ///
1619   /// By default, performs semantic analysis to build the new expression.
1620   /// Subclasses may override this routine to provide different behavior.
1621   OwningExprResult RebuildObjCProtocolExpr(ObjCProtocolDecl *Protocol,
1622                                            SourceLocation AtLoc,
1623                                            SourceLocation ProtoLoc,
1624                                            SourceLocation LParenLoc,
1625                                            SourceLocation RParenLoc) {
1626     return SemaRef.Owned(SemaRef.ParseObjCProtocolExpression(
1627                                               Protocol->getIdentifier(),
1628                                                              AtLoc,
1629                                                              ProtoLoc,
1630                                                              LParenLoc,
1631                                                              RParenLoc));
1632   }
1633
1634   /// \brief Build a new shuffle vector expression.
1635   ///
1636   /// By default, performs semantic analysis to build the new expression.
1637   /// Subclasses may override this routine to provide different behavior.
1638   OwningExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc,
1639                                             MultiExprArg SubExprs,
1640                                             SourceLocation RParenLoc) {
1641     // Find the declaration for __builtin_shufflevector
1642     const IdentifierInfo &Name
1643       = SemaRef.Context.Idents.get("__builtin_shufflevector");
1644     TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl();
1645     DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name));
1646     assert(Lookup.first != Lookup.second && "No __builtin_shufflevector?");
1647
1648     // Build a reference to the __builtin_shufflevector builtin
1649     FunctionDecl *Builtin = cast<FunctionDecl>(*Lookup.first);
1650     Expr *Callee
1651       = new (SemaRef.Context) DeclRefExpr(Builtin, Builtin->getType(),
1652                                           BuiltinLoc, false, false);
1653     SemaRef.UsualUnaryConversions(Callee);
1654
1655     // Build the CallExpr
1656     unsigned NumSubExprs = SubExprs.size();
1657     Expr **Subs = (Expr **)SubExprs.release();
1658     CallExpr *TheCall = new (SemaRef.Context) CallExpr(SemaRef.Context, Callee,
1659                                                        Subs, NumSubExprs,
1660                                                        Builtin->getResultType(),
1661                                                        RParenLoc);
1662     OwningExprResult OwnedCall(SemaRef.Owned(TheCall));
1663
1664     // Type-check the __builtin_shufflevector expression.
1665     OwningExprResult Result = SemaRef.SemaBuiltinShuffleVector(TheCall);
1666     if (Result.isInvalid())
1667       return SemaRef.ExprError();
1668
1669     OwnedCall.release();
1670     return move(Result);
1671   }
1672 };
1673
1674 template<typename Derived>
1675 Sema::OwningStmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) {
1676   if (!S)
1677     return SemaRef.Owned(S);
1678
1679   switch (S->getStmtClass()) {
1680   case Stmt::NoStmtClass: break;
1681
1682   // Transform individual statement nodes
1683 #define STMT(Node, Parent)                                              \
1684   case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
1685 #define EXPR(Node, Parent)
1686 #include "clang/AST/StmtNodes.def"
1687
1688   // Transform expressions by calling TransformExpr.
1689 #define STMT(Node, Parent)
1690 #define EXPR(Node, Parent) case Stmt::Node##Class:
1691 #include "clang/AST/StmtNodes.def"
1692     {
1693       Sema::OwningExprResult E = getDerived().TransformExpr(cast<Expr>(S));
1694       if (E.isInvalid())
1695         return getSema().StmtError();
1696
1697       return getSema().Owned(E.takeAs<Stmt>());
1698     }
1699   }
1700
1701   return SemaRef.Owned(S->Retain());
1702 }
1703
1704
1705 template<typename Derived>
1706 Sema::OwningExprResult TreeTransform<Derived>::TransformExpr(Expr *E,
1707                                                     bool isAddressOfOperand) {
1708   if (!E)
1709     return SemaRef.Owned(E);
1710
1711   switch (E->getStmtClass()) {
1712     case Stmt::NoStmtClass: break;
1713 #define STMT(Node, Parent) case Stmt::Node##Class: break;
1714 #define EXPR(Node, Parent)                                              \
1715     case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E), \
1716                                                             isAddressOfOperand);
1717 #include "clang/AST/StmtNodes.def"
1718   }
1719
1720   return SemaRef.Owned(E->Retain());
1721 }
1722
1723 template<typename Derived>
1724 NestedNameSpecifier *
1725 TreeTransform<Derived>::TransformNestedNameSpecifier(NestedNameSpecifier *NNS,
1726                                                      SourceRange Range,
1727                                                      QualType ObjectType,
1728                                              NamedDecl *FirstQualifierInScope) {
1729   if (!NNS)
1730     return 0;
1731
1732   // Transform the prefix of this nested name specifier.
1733   NestedNameSpecifier *Prefix = NNS->getPrefix();
1734   if (Prefix) {
1735     Prefix = getDerived().TransformNestedNameSpecifier(Prefix, Range,
1736                                                        ObjectType,
1737                                                        FirstQualifierInScope);
1738     if (!Prefix)
1739       return 0;
1740
1741     // Clear out the object type and the first qualifier in scope; they only
1742     // apply to the first element in the nested-name-specifier.
1743     ObjectType = QualType();
1744     FirstQualifierInScope = 0;
1745   }
1746
1747   switch (NNS->getKind()) {
1748   case NestedNameSpecifier::Identifier:
1749     assert((Prefix || !ObjectType.isNull()) &&
1750             "Identifier nested-name-specifier with no prefix or object type");
1751     if (!getDerived().AlwaysRebuild() && Prefix == NNS->getPrefix() &&
1752         ObjectType.isNull())
1753       return NNS;
1754
1755     return getDerived().RebuildNestedNameSpecifier(Prefix, Range,
1756                                                    *NNS->getAsIdentifier(),
1757                                                    ObjectType,
1758                                                    FirstQualifierInScope);
1759
1760   case NestedNameSpecifier::Namespace: {
1761     NamespaceDecl *NS
1762       = cast_or_null<NamespaceDecl>(
1763                             getDerived().TransformDecl(NNS->getAsNamespace()));
1764     if (!getDerived().AlwaysRebuild() &&
1765         Prefix == NNS->getPrefix() &&
1766         NS == NNS->getAsNamespace())
1767       return NNS;
1768
1769     return getDerived().RebuildNestedNameSpecifier(Prefix, Range, NS);
1770   }
1771
1772   case NestedNameSpecifier::Global:
1773     // There is no meaningful transformation that one could perform on the
1774     // global scope.
1775     return NNS;
1776
1777   case NestedNameSpecifier::TypeSpecWithTemplate:
1778   case NestedNameSpecifier::TypeSpec: {
1779     TemporaryBase Rebase(*this, Range.getBegin(), DeclarationName());
1780     QualType T = getDerived().TransformType(QualType(NNS->getAsType(), 0));
1781     if (T.isNull())
1782       return 0;
1783
1784     if (!getDerived().AlwaysRebuild() &&
1785         Prefix == NNS->getPrefix() &&
1786         T == QualType(NNS->getAsType(), 0))
1787       return NNS;
1788
1789     return getDerived().RebuildNestedNameSpecifier(Prefix, Range,
1790                   NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate,
1791                                                    T);
1792   }
1793   }
1794
1795   // Required to silence a GCC warning
1796   return 0;
1797 }
1798
1799 template<typename Derived>
1800 DeclarationName
1801 TreeTransform<Derived>::TransformDeclarationName(DeclarationName Name,
1802                                                  SourceLocation Loc,
1803                                                  QualType ObjectType) {
1804   if (!Name)
1805     return Name;
1806
1807   switch (Name.getNameKind()) {
1808   case DeclarationName::Identifier:
1809   case DeclarationName::ObjCZeroArgSelector:
1810   case DeclarationName::ObjCOneArgSelector:
1811   case DeclarationName::ObjCMultiArgSelector:
1812   case DeclarationName::CXXOperatorName:
1813   case DeclarationName::CXXUsingDirective:
1814     return Name;
1815
1816   case DeclarationName::CXXConstructorName:
1817   case DeclarationName::CXXDestructorName:
1818   case DeclarationName::CXXConversionFunctionName: {
1819     TemporaryBase Rebase(*this, Loc, Name);
1820     QualType T;
1821     if (!ObjectType.isNull() &&
1822         isa<TemplateSpecializationType>(Name.getCXXNameType())) {
1823       TemplateSpecializationType *SpecType
1824         = cast<TemplateSpecializationType>(Name.getCXXNameType());
1825       T = TransformTemplateSpecializationType(SpecType, ObjectType);
1826     } else
1827       T = getDerived().TransformType(Name.getCXXNameType());
1828     if (T.isNull())
1829       return DeclarationName();
1830
1831     return SemaRef.Context.DeclarationNames.getCXXSpecialName(
1832                                                            Name.getNameKind(),
1833                                           SemaRef.Context.getCanonicalType(T));
1834   }
1835   }
1836
1837   return DeclarationName();
1838 }
1839
1840 template<typename Derived>
1841 TemplateName
1842 TreeTransform<Derived>::TransformTemplateName(TemplateName Name,
1843                                               QualType ObjectType) {
1844   if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) {
1845     NestedNameSpecifier *NNS
1846       = getDerived().TransformNestedNameSpecifier(QTN->getQualifier(),
1847                       /*FIXME:*/SourceRange(getDerived().getBaseLocation()));
1848     if (!NNS)
1849       return TemplateName();
1850
1851     if (TemplateDecl *Template = QTN->getTemplateDecl()) {
1852       TemplateDecl *TransTemplate
1853         = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Template));
1854       if (!TransTemplate)
1855         return TemplateName();
1856
1857       if (!getDerived().AlwaysRebuild() &&
1858           NNS == QTN->getQualifier() &&
1859           TransTemplate == Template)
1860         return Name;
1861
1862       return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(),
1863                                               TransTemplate);
1864     }
1865
1866     OverloadedFunctionDecl *Ovl = QTN->getOverloadedFunctionDecl();
1867     assert(Ovl && "Not a template name or an overload set?");
1868     OverloadedFunctionDecl *TransOvl
1869       = cast_or_null<OverloadedFunctionDecl>(getDerived().TransformDecl(Ovl));
1870     if (!TransOvl)
1871       return TemplateName();
1872
1873     if (!getDerived().AlwaysRebuild() &&
1874         NNS == QTN->getQualifier() &&
1875         TransOvl == Ovl)
1876       return Name;
1877
1878     return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(),
1879                                             TransOvl);
1880   }
1881
1882   if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) {
1883     NestedNameSpecifier *NNS
1884       = getDerived().TransformNestedNameSpecifier(DTN->getQualifier(),
1885                         /*FIXME:*/SourceRange(getDerived().getBaseLocation()));
1886     if (!NNS && DTN->getQualifier())
1887       return TemplateName();
1888
1889     if (!getDerived().AlwaysRebuild() &&
1890         NNS == DTN->getQualifier() &&
1891         ObjectType.isNull())
1892       return Name;
1893
1894     if (DTN->isIdentifier())
1895       return getDerived().RebuildTemplateName(NNS, *DTN->getIdentifier(),
1896                                               ObjectType);
1897
1898     return getDerived().RebuildTemplateName(NNS, DTN->getOperator(),
1899                                             ObjectType);
1900   }
1901
1902   if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
1903     TemplateDecl *TransTemplate
1904       = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Template));
1905     if (!TransTemplate)
1906       return TemplateName();
1907
1908     if (!getDerived().AlwaysRebuild() &&
1909         TransTemplate == Template)
1910       return Name;
1911
1912     return TemplateName(TransTemplate);
1913   }
1914
1915   OverloadedFunctionDecl *Ovl = Name.getAsOverloadedFunctionDecl();
1916   assert(Ovl && "Not a template name or an overload set?");
1917   OverloadedFunctionDecl *TransOvl
1918     = cast_or_null<OverloadedFunctionDecl>(getDerived().TransformDecl(Ovl));
1919   if (!TransOvl)
1920     return TemplateName();
1921
1922   if (!getDerived().AlwaysRebuild() &&
1923       TransOvl == Ovl)
1924     return Name;
1925
1926   return TemplateName(TransOvl);
1927 }
1928
1929 template<typename Derived>
1930 void TreeTransform<Derived>::InventTemplateArgumentLoc(
1931                                          const TemplateArgument &Arg,
1932                                          TemplateArgumentLoc &Output) {
1933   SourceLocation Loc = getDerived().getBaseLocation();
1934   switch (Arg.getKind()) {
1935   case TemplateArgument::Null:
1936     llvm::llvm_unreachable("null template argument in TreeTransform");
1937     break;
1938
1939   case TemplateArgument::Type:
1940     Output = TemplateArgumentLoc(Arg,
1941                SemaRef.Context.getTrivialDeclaratorInfo(Arg.getAsType(), Loc));
1942
1943     break;
1944
1945   case TemplateArgument::Expression:
1946     Output = TemplateArgumentLoc(Arg, Arg.getAsExpr());
1947     break;
1948
1949   case TemplateArgument::Declaration:
1950   case TemplateArgument::Integral:
1951   case TemplateArgument::Pack:
1952     Output = TemplateArgumentLoc(Arg, TemplateArgumentLocInfo());
1953     break;
1954   }
1955 }
1956
1957 template<typename Derived>
1958 bool TreeTransform<Derived>::TransformTemplateArgument(
1959                                          const TemplateArgumentLoc &Input,
1960                                          TemplateArgumentLoc &Output) {
1961   const TemplateArgument &Arg = Input.getArgument();
1962   switch (Arg.getKind()) {
1963   case TemplateArgument::Null:
1964   case TemplateArgument::Integral:
1965     Output = Input;
1966     return false;
1967
1968   case TemplateArgument::Type: {
1969     DeclaratorInfo *DI = Input.getSourceDeclaratorInfo();
1970     if (DI == NULL)
1971       DI = InventDeclaratorInfo(Input.getArgument().getAsType());
1972
1973     DI = getDerived().TransformType(DI);
1974     if (!DI) return true;
1975
1976     Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
1977     return false;
1978   }
1979
1980   case TemplateArgument::Declaration: {
1981     // FIXME: we should never have to transform one of these.
1982     DeclarationName Name;
1983     if (NamedDecl *ND = dyn_cast<NamedDecl>(Arg.getAsDecl()))
1984       Name = ND->getDeclName();
1985     TemporaryBase Rebase(*this, SourceLocation(), Name);
1986     Decl *D = getDerived().TransformDecl(Arg.getAsDecl());
1987     if (!D) return true;
1988
1989     Expr *SourceExpr = Input.getSourceDeclExpression();
1990     if (SourceExpr) {
1991       EnterExpressionEvaluationContext Unevaluated(getSema(),
1992                                                    Action::Unevaluated);
1993       Sema::OwningExprResult E = getDerived().TransformExpr(SourceExpr);
1994       if (E.isInvalid())
1995         SourceExpr = NULL;
1996       else {
1997         SourceExpr = E.takeAs<Expr>();
1998         SourceExpr->Retain();
1999       }
2000     }
2001
2002     Output = TemplateArgumentLoc(TemplateArgument(D), SourceExpr);
2003     return false;
2004   }
2005
2006   case TemplateArgument::Expression: {
2007     // Template argument expressions are not potentially evaluated.
2008     EnterExpressionEvaluationContext Unevaluated(getSema(),
2009                                                  Action::Unevaluated);
2010
2011     Expr *InputExpr = Input.getSourceExpression();
2012     if (!InputExpr) InputExpr = Input.getArgument().getAsExpr();
2013
2014     Sema::OwningExprResult E
2015       = getDerived().TransformExpr(InputExpr);
2016     if (E.isInvalid()) return true;
2017
2018     Expr *ETaken = E.takeAs<Expr>();
2019     ETaken->Retain();
2020     Output = TemplateArgumentLoc(TemplateArgument(ETaken), ETaken);
2021     return false;
2022   }
2023
2024   case TemplateArgument::Pack: {
2025     llvm::SmallVector<TemplateArgument, 4> TransformedArgs;
2026     TransformedArgs.reserve(Arg.pack_size());
2027     for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
2028                                       AEnd = Arg.pack_end();
2029          A != AEnd; ++A) {
2030
2031       // FIXME: preserve source information here when we start
2032       // caring about parameter packs.
2033
2034       TemplateArgumentLoc InputArg;
2035       TemplateArgumentLoc OutputArg;
2036       getDerived().InventTemplateArgumentLoc(*A, InputArg);
2037       if (getDerived().TransformTemplateArgument(InputArg, OutputArg))
2038         return true;
2039
2040       TransformedArgs.push_back(OutputArg.getArgument());
2041     }
2042     TemplateArgument Result;
2043     Result.setArgumentPack(TransformedArgs.data(), TransformedArgs.size(),
2044                            true);
2045     Output = TemplateArgumentLoc(Result, Input.getLocInfo());
2046     return false;
2047   }
2048   }
2049
2050   // Work around bogus GCC warning
2051   return true;
2052 }
2053
2054 //===----------------------------------------------------------------------===//
2055 // Type transformation
2056 //===----------------------------------------------------------------------===//
2057
2058 template<typename Derived>
2059 QualType TreeTransform<Derived>::TransformType(QualType T) {
2060   if (getDerived().AlreadyTransformed(T))
2061     return T;
2062
2063   // Temporary workaround.  All of these transformations should
2064   // eventually turn into transformations on TypeLocs.
2065   DeclaratorInfo *DI = getSema().Context.CreateDeclaratorInfo(T);
2066   DI->getTypeLoc().initialize(getDerived().getBaseLocation());
2067
2068   DeclaratorInfo *NewDI = getDerived().TransformType(DI);
2069
2070   if (!NewDI)
2071     return QualType();
2072
2073   return NewDI->getType();
2074 }
2075
2076 template<typename Derived>
2077 DeclaratorInfo *TreeTransform<Derived>::TransformType(DeclaratorInfo *DI) {
2078   if (getDerived().AlreadyTransformed(DI->getType()))
2079     return DI;
2080
2081   TypeLocBuilder TLB;
2082
2083   TypeLoc TL = DI->getTypeLoc();
2084   TLB.reserve(TL.getFullDataSize());
2085
2086   QualType Result = getDerived().TransformType(TLB, TL);
2087   if (Result.isNull())
2088     return 0;
2089
2090   return TLB.getDeclaratorInfo(SemaRef.Context, Result);
2091 }
2092
2093 template<typename Derived>
2094 QualType
2095 TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) {
2096   switch (T.getTypeLocClass()) {
2097 #define ABSTRACT_TYPELOC(CLASS, PARENT)
2098 #define TYPELOC(CLASS, PARENT) \
2099   case TypeLoc::CLASS: \
2100     return getDerived().Transform##CLASS##Type(TLB, cast<CLASS##TypeLoc>(T));
2101 #include "clang/AST/TypeLocNodes.def"
2102   }
2103
2104   llvm::llvm_unreachable("unhandled type loc!");
2105   return QualType();
2106 }
2107
2108 /// FIXME: By default, this routine adds type qualifiers only to types
2109 /// that can have qualifiers, and silently suppresses those qualifiers
2110 /// that are not permitted (e.g., qualifiers on reference or function
2111 /// types). This is the right thing for template instantiation, but
2112 /// probably not for other clients.
2113 template<typename Derived>
2114 QualType
2115 TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB,
2116                                                QualifiedTypeLoc T) {
2117   Qualifiers Quals = T.getType().getQualifiers();
2118
2119   QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc());
2120   if (Result.isNull())
2121     return QualType();
2122
2123   // Silently suppress qualifiers if the result type can't be qualified.
2124   // FIXME: this is the right thing for template instantiation, but
2125   // probably not for other clients.
2126   if (Result->isFunctionType() || Result->isReferenceType())
2127     return Result;
2128
2129   Result = SemaRef.Context.getQualifiedType(Result, Quals);
2130
2131   TLB.push<QualifiedTypeLoc>(Result);
2132
2133   // No location information to preserve.
2134
2135   return Result;
2136 }
2137
2138 template <class TyLoc> static inline
2139 QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) {
2140   TyLoc NewT = TLB.push<TyLoc>(T.getType());
2141   NewT.setNameLoc(T.getNameLoc());
2142   return T.getType();
2143 }
2144
2145 // Ugly metaprogramming macros because I couldn't be bothered to make
2146 // the equivalent template version work.
2147 #define TransformPointerLikeType(TypeClass) do { \
2148   QualType PointeeType                                       \
2149     = getDerived().TransformType(TLB, TL.getPointeeLoc());   \
2150   if (PointeeType.isNull())                                  \
2151     return QualType();                                       \
2152                                                              \
2153   QualType Result = TL.getType();                            \
2154   if (getDerived().AlwaysRebuild() ||                        \
2155       PointeeType != TL.getPointeeLoc().getType()) {         \
2156     Result = getDerived().Rebuild##TypeClass(PointeeType,    \
2157                                           TL.getSigilLoc()); \
2158     if (Result.isNull())                                     \
2159       return QualType();                                     \
2160   }                                                          \
2161                                                              \
2162   TypeClass##Loc NewT = TLB.push<TypeClass##Loc>(Result);    \
2163   NewT.setSigilLoc(TL.getSigilLoc());                        \
2164                                                              \
2165   return Result;                                             \
2166 } while(0)
2167
2168 template<typename Derived>
2169 QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
2170                                                       BuiltinTypeLoc T) {
2171   return TransformTypeSpecType(TLB, T);
2172 }
2173
2174 template<typename Derived>
2175 QualType
2176 TreeTransform<Derived>::TransformFixedWidthIntType(TypeLocBuilder &TLB,
2177                                                    FixedWidthIntTypeLoc T) {
2178   return TransformTypeSpecType(TLB, T);
2179 }
2180
2181 template<typename Derived>
2182 QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
2183                                                       ComplexTypeLoc T) {
2184   // FIXME: recurse?
2185   return TransformTypeSpecType(TLB, T);
2186 }
2187
2188 template<typename Derived>
2189 QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
2190                                                       PointerTypeLoc TL) {
2191   TransformPointerLikeType(PointerType);
2192 }
2193
2194 template<typename Derived>
2195 QualType
2196 TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
2197                                                   BlockPointerTypeLoc TL) {
2198   TransformPointerLikeType(BlockPointerType);
2199 }
2200
2201 /// Transforms a reference type.  Note that somewhat paradoxically we
2202 /// don't care whether the type itself is an l-value type or an r-value
2203 /// type;  we only care if the type was *written* as an l-value type
2204 /// or an r-value type.
2205 template<typename Derived>
2206 QualType
2207 TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB,
2208                                                ReferenceTypeLoc TL) {
2209   const ReferenceType *T = TL.getTypePtr();
2210
2211   // Note that this works with the pointee-as-written.
2212   QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
2213   if (PointeeType.isNull())
2214     return QualType();
2215
2216   QualType Result = TL.getType();
2217   if (getDerived().AlwaysRebuild() ||
2218       PointeeType != T->getPointeeTypeAsWritten()) {
2219     Result = getDerived().RebuildReferenceType(PointeeType,
2220                                                T->isSpelledAsLValue(),
2221                                                TL.getSigilLoc());
2222     if (Result.isNull())
2223       return QualType();
2224   }
2225
2226   // r-value references can be rebuilt as l-value references.
2227   ReferenceTypeLoc NewTL;
2228   if (isa<LValueReferenceType>(Result))
2229     NewTL = TLB.push<LValueReferenceTypeLoc>(Result);
2230   else
2231     NewTL = TLB.push<RValueReferenceTypeLoc>(Result);
2232   NewTL.setSigilLoc(TL.getSigilLoc());
2233
2234   return Result;
2235 }
2236
2237 template<typename Derived>
2238 QualType
2239 TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB,
2240                                                  LValueReferenceTypeLoc TL) {
2241   return TransformReferenceType(TLB, TL);
2242 }
2243
2244 template<typename Derived>
2245 QualType
2246 TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
2247                                                  RValueReferenceTypeLoc TL) {
2248   return TransformReferenceType(TLB, TL);
2249 }
2250
2251 template<typename Derived>
2252 QualType
2253 TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
2254                                                    MemberPointerTypeLoc TL) {
2255   MemberPointerType *T = TL.getTypePtr();
2256
2257   QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
2258   if (PointeeType.isNull())
2259     return QualType();
2260
2261   // TODO: preserve source information for this.
2262   QualType ClassType
2263     = getDerived().TransformType(QualType(T->getClass(), 0));
2264   if (ClassType.isNull())
2265     return QualType();
2266
2267   QualType Result = TL.getType();
2268   if (getDerived().AlwaysRebuild() ||
2269       PointeeType != T->getPointeeType() ||
2270       ClassType != QualType(T->getClass(), 0)) {
2271     Result = getDerived().RebuildMemberPointerType(PointeeType, ClassType,
2272                                                    TL.getStarLoc());
2273     if (Result.isNull())
2274       return QualType();
2275   }
2276
2277   MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
2278   NewTL.setSigilLoc(TL.getSigilLoc());
2279
2280   return Result;
2281 }
2282
2283 template<typename Derived>
2284 QualType
2285 TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
2286                                                    ConstantArrayTypeLoc TL) {
2287   ConstantArrayType *T = TL.getTypePtr();
2288   QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
2289   if (ElementType.isNull())
2290     return QualType();
2291
2292   QualType Result = TL.getType();
2293   if (getDerived().AlwaysRebuild() ||
2294       ElementType != T->getElementType()) {
2295     Result = getDerived().RebuildConstantArrayType(ElementType,
2296                                                    T->getSizeModifier(),
2297                                                    T->getSize(),
2298                                              T->getIndexTypeCVRQualifiers(),
2299                                                    TL.getBracketsRange());
2300     if (Result.isNull())
2301       return QualType();
2302   }
2303
2304   ConstantArrayTypeLoc NewTL = TLB.push<ConstantArrayTypeLoc>(Result);
2305   NewTL.setLBracketLoc(TL.getLBracketLoc());
2306   NewTL.setRBracketLoc(TL.getRBracketLoc());
2307
2308   Expr *Size = TL.getSizeExpr();
2309   if (Size) {
2310     EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2311     Size = getDerived().TransformExpr(Size).template takeAs<Expr>();
2312   }
2313   NewTL.setSizeExpr(Size);
2314
2315   return Result;
2316 }
2317
2318 template<typename Derived>
2319 QualType TreeTransform<Derived>::TransformIncompleteArrayType(
2320                                               TypeLocBuilder &TLB,
2321                                               IncompleteArrayTypeLoc TL) {
2322   IncompleteArrayType *T = TL.getTypePtr();
2323   QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
2324   if (ElementType.isNull())
2325     return QualType();
2326
2327   QualType Result = TL.getType();
2328   if (getDerived().AlwaysRebuild() ||
2329       ElementType != T->getElementType()) {
2330     Result = getDerived().RebuildIncompleteArrayType(ElementType,
2331                                                      T->getSizeModifier(),
2332                                            T->getIndexTypeCVRQualifiers(),
2333                                                      TL.getBracketsRange());
2334     if (Result.isNull())
2335       return QualType();
2336   }
2337
2338   IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
2339   NewTL.setLBracketLoc(TL.getLBracketLoc());
2340   NewTL.setRBracketLoc(TL.getRBracketLoc());
2341   NewTL.setSizeExpr(0);
2342
2343   return Result;
2344 }
2345
2346 template<typename Derived>
2347 QualType
2348 TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
2349                                                    VariableArrayTypeLoc TL) {
2350   VariableArrayType *T = TL.getTypePtr();
2351   QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
2352   if (ElementType.isNull())
2353     return QualType();
2354
2355   // Array bounds are not potentially evaluated contexts
2356   EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2357
2358   Sema::OwningExprResult SizeResult
2359     = getDerived().TransformExpr(T->getSizeExpr());
2360   if (SizeResult.isInvalid())
2361     return QualType();
2362
2363   Expr *Size = static_cast<Expr*>(SizeResult.get());
2364
2365   QualType Result = TL.getType();
2366   if (getDerived().AlwaysRebuild() ||
2367       ElementType != T->getElementType() ||
2368       Size != T->getSizeExpr()) {
2369     Result = getDerived().RebuildVariableArrayType(ElementType,
2370                                                    T->getSizeModifier(),
2371                                                    move(SizeResult),
2372                                              T->getIndexTypeCVRQualifiers(),
2373                                                    TL.getBracketsRange());
2374     if (Result.isNull())
2375       return QualType();
2376   }
2377   else SizeResult.take();
2378
2379   VariableArrayTypeLoc NewTL = TLB.push<VariableArrayTypeLoc>(Result);
2380   NewTL.setLBracketLoc(TL.getLBracketLoc());
2381   NewTL.setRBracketLoc(TL.getRBracketLoc());
2382   NewTL.setSizeExpr(Size);
2383
2384   return Result;
2385 }
2386
2387 template<typename Derived>
2388 QualType
2389 TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
2390                                              DependentSizedArrayTypeLoc TL) {
2391   DependentSizedArrayType *T = TL.getTypePtr();
2392   QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
2393   if (ElementType.isNull())
2394     return QualType();
2395
2396   // Array bounds are not potentially evaluated contexts
2397   EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2398
2399   Sema::OwningExprResult SizeResult
2400     = getDerived().TransformExpr(T->getSizeExpr());
2401   if (SizeResult.isInvalid())
2402     return QualType();
2403
2404   Expr *Size = static_cast<Expr*>(SizeResult.get());
2405
2406   QualType Result = TL.getType();
2407   if (getDerived().AlwaysRebuild() ||
2408       ElementType != T->getElementType() ||
2409       Size != T->getSizeExpr()) {
2410     Result = getDerived().RebuildDependentSizedArrayType(ElementType,
2411                                                          T->getSizeModifier(),
2412                                                          move(SizeResult),
2413                                                 T->getIndexTypeCVRQualifiers(),
2414                                                         TL.getBracketsRange());
2415     if (Result.isNull())
2416       return QualType();
2417   }
2418   else SizeResult.take();
2419
2420   // We might have any sort of array type now, but fortunately they
2421   // all have the same location layout.
2422   ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
2423   NewTL.setLBracketLoc(TL.getLBracketLoc());
2424   NewTL.setRBracketLoc(TL.getRBracketLoc());
2425   NewTL.setSizeExpr(Size);
2426
2427   return Result;
2428 }
2429
2430 template<typename Derived>
2431 QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
2432                                       TypeLocBuilder &TLB,
2433                                       DependentSizedExtVectorTypeLoc TL) {
2434   DependentSizedExtVectorType *T = TL.getTypePtr();
2435
2436   // FIXME: ext vector locs should be nested
2437   QualType ElementType = getDerived().TransformType(T->getElementType());
2438   if (ElementType.isNull())
2439     return QualType();
2440
2441   // Vector sizes are not potentially evaluated contexts
2442   EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2443
2444   Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
2445   if (Size.isInvalid())
2446     return QualType();
2447
2448   QualType Result = TL.getType();
2449   if (getDerived().AlwaysRebuild() ||
2450       ElementType != T->getElementType() ||
2451       Size.get() != T->getSizeExpr()) {
2452     Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
2453                                                          move(Size),
2454                                                          T->getAttributeLoc());
2455     if (Result.isNull())
2456       return QualType();
2457   }
2458   else Size.take();
2459
2460   // Result might be dependent or not.
2461   if (isa<DependentSizedExtVectorType>(Result)) {
2462     DependentSizedExtVectorTypeLoc NewTL
2463       = TLB.push<DependentSizedExtVectorTypeLoc>(Result);
2464     NewTL.setNameLoc(TL.getNameLoc());
2465   } else {
2466     ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
2467     NewTL.setNameLoc(TL.getNameLoc());
2468   }
2469
2470   return Result;
2471 }
2472
2473 template<typename Derived>
2474 QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
2475                                                      VectorTypeLoc TL) {
2476   VectorType *T = TL.getTypePtr();
2477   QualType ElementType = getDerived().TransformType(T->getElementType());
2478   if (ElementType.isNull())
2479     return QualType();
2480
2481   QualType Result = TL.getType();
2482   if (getDerived().AlwaysRebuild() ||
2483       ElementType != T->getElementType()) {
2484     Result = getDerived().RebuildVectorType(ElementType, T->getNumElements());
2485     if (Result.isNull())
2486       return QualType();
2487   }
2488
2489   VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
2490   NewTL.setNameLoc(TL.getNameLoc());
2491
2492   return Result;
2493 }
2494
2495 template<typename Derived>
2496 QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
2497                                                         ExtVectorTypeLoc TL) {
2498   VectorType *T = TL.getTypePtr();
2499   QualType ElementType = getDerived().TransformType(T->getElementType());
2500   if (ElementType.isNull())
2501     return QualType();
2502
2503   QualType Result = TL.getType();
2504   if (getDerived().AlwaysRebuild() ||
2505       ElementType != T->getElementType()) {
2506     Result = getDerived().RebuildExtVectorType(ElementType,
2507                                                T->getNumElements(),
2508                                                /*FIXME*/ SourceLocation());
2509     if (Result.isNull())
2510       return QualType();
2511   }
2512
2513   ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
2514   NewTL.setNameLoc(TL.getNameLoc());
2515
2516   return Result;
2517 }
2518
2519 template<typename Derived>
2520 QualType
2521 TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB,
2522                                                    FunctionProtoTypeLoc TL) {
2523   FunctionProtoType *T = TL.getTypePtr();
2524   QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc());
2525   if (ResultType.isNull())
2526     return QualType();
2527
2528   // Transform the parameters.
2529   llvm::SmallVector<QualType, 4> ParamTypes;
2530   llvm::SmallVector<ParmVarDecl*, 4> ParamDecls;
2531   for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
2532     ParmVarDecl *OldParm = TL.getArg(i);
2533
2534     QualType NewType;
2535     ParmVarDecl *NewParm;
2536
2537     if (OldParm) {
2538       DeclaratorInfo *OldDI = OldParm->getDeclaratorInfo();
2539       assert(OldDI->getType() == T->getArgType(i));
2540
2541       DeclaratorInfo *NewDI = getDerived().TransformType(OldDI);
2542       if (!NewDI)
2543         return QualType();
2544
2545       if (NewDI == OldDI)
2546         NewParm = OldParm;
2547       else
2548         NewParm = ParmVarDecl::Create(SemaRef.Context,
2549                                       OldParm->getDeclContext(),
2550                                       OldParm->getLocation(),
2551                                       OldParm->getIdentifier(),
2552                                       NewDI->getType(),
2553                                       NewDI,
2554                                       OldParm->getStorageClass(),
2555                                       /* DefArg */ NULL);
2556       NewType = NewParm->getType();
2557
2558     // Deal with the possibility that we don't have a parameter
2559     // declaration for this parameter.
2560     } else {
2561       NewParm = 0;
2562
2563       QualType OldType = T->getArgType(i);
2564       NewType = getDerived().TransformType(OldType);
2565       if (NewType.isNull())
2566         return QualType();
2567     }
2568
2569     ParamTypes.push_back(NewType);
2570     ParamDecls.push_back(NewParm);
2571   }
2572
2573   QualType Result = TL.getType();
2574   if (getDerived().AlwaysRebuild() ||
2575       ResultType != T->getResultType() ||
2576       !std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) {
2577     Result = getDerived().RebuildFunctionProtoType(ResultType,
2578                                                    ParamTypes.data(),
2579                                                    ParamTypes.size(),
2580                                                    T->isVariadic(),
2581                                                    T->getTypeQuals());
2582     if (Result.isNull())
2583       return QualType();
2584   }
2585
2586   FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result);
2587   NewTL.setLParenLoc(TL.getLParenLoc());
2588   NewTL.setRParenLoc(TL.getRParenLoc());
2589   for (unsigned i = 0, e = NewTL.getNumArgs(); i != e; ++i)
2590     NewTL.setArg(i, ParamDecls[i]);
2591
2592   return Result;
2593 }
2594
2595 template<typename Derived>
2596 QualType TreeTransform<Derived>::TransformFunctionNoProtoType(
2597                                                  TypeLocBuilder &TLB,
2598                                                  FunctionNoProtoTypeLoc TL) {
2599   FunctionNoProtoType *T = TL.getTypePtr();
2600   QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc());
2601   if (ResultType.isNull())
2602     return QualType();
2603
2604   QualType Result = TL.getType();
2605   if (getDerived().AlwaysRebuild() ||
2606       ResultType != T->getResultType())
2607     Result = getDerived().RebuildFunctionNoProtoType(ResultType);
2608
2609   FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result);
2610   NewTL.setLParenLoc(TL.getLParenLoc());
2611   NewTL.setRParenLoc(TL.getRParenLoc());
2612
2613   return Result;
2614 }
2615
2616 template<typename Derived>
2617 QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
2618                                                       TypedefTypeLoc TL) {
2619   TypedefType *T = TL.getTypePtr();
2620   TypedefDecl *Typedef
2621     = cast_or_null<TypedefDecl>(getDerived().TransformDecl(T->getDecl()));
2622   if (!Typedef)
2623     return QualType();
2624
2625   QualType Result = TL.getType();
2626   if (getDerived().AlwaysRebuild() ||
2627       Typedef != T->getDecl()) {
2628     Result = getDerived().RebuildTypedefType(Typedef);
2629     if (Result.isNull())
2630       return QualType();
2631   }
2632
2633   TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result);
2634   NewTL.setNameLoc(TL.getNameLoc());
2635
2636   return Result;
2637 }
2638
2639 template<typename Derived>
2640 QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
2641                                                       TypeOfExprTypeLoc TL) {
2642   TypeOfExprType *T = TL.getTypePtr();
2643
2644   // typeof expressions are not potentially evaluated contexts
2645   EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2646
2647   Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
2648   if (E.isInvalid())
2649     return QualType();
2650
2651   QualType Result = TL.getType();
2652   if (getDerived().AlwaysRebuild() ||
2653       E.get() != T->getUnderlyingExpr()) {
2654     Result = getDerived().RebuildTypeOfExprType(move(E));
2655     if (Result.isNull())
2656       return QualType();
2657   }
2658   else E.take();
2659
2660   TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result);
2661   NewTL.setNameLoc(TL.getNameLoc());
2662
2663   return Result;
2664 }
2665
2666 template<typename Derived>
2667 QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
2668                                                      TypeOfTypeLoc TL) {
2669   TypeOfType *T = TL.getTypePtr();
2670
2671   // FIXME: should be an inner type, or at least have a DeclaratorInfo.
2672   QualType Underlying = getDerived().TransformType(T->getUnderlyingType());
2673   if (Underlying.isNull())
2674     return QualType();
2675
2676   QualType Result = TL.getType();
2677   if (getDerived().AlwaysRebuild() ||
2678       Underlying != T->getUnderlyingType()) {
2679     Result = getDerived().RebuildTypeOfType(Underlying);
2680     if (Result.isNull())
2681       return QualType();
2682   }
2683
2684   TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result);
2685   NewTL.setNameLoc(TL.getNameLoc());
2686
2687   return Result;
2688 }
2689
2690 template<typename Derived>
2691 QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
2692                                                        DecltypeTypeLoc TL) {
2693   DecltypeType *T = TL.getTypePtr();
2694
2695   // decltype expressions are not potentially evaluated contexts
2696   EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2697
2698   Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
2699   if (E.isInvalid())
2700     return QualType();
2701
2702   QualType Result = TL.getType();
2703   if (getDerived().AlwaysRebuild() ||
2704       E.get() != T->getUnderlyingExpr()) {
2705     Result = getDerived().RebuildDecltypeType(move(E));
2706     if (Result.isNull())
2707       return QualType();
2708   }
2709   else E.take();
2710
2711   DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
2712   NewTL.setNameLoc(TL.getNameLoc());
2713
2714   return Result;
2715 }
2716
2717 template<typename Derived>
2718 QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,
2719                                                      RecordTypeLoc TL) {
2720   RecordType *T = TL.getTypePtr();
2721   RecordDecl *Record
2722     = cast_or_null<RecordDecl>(getDerived().TransformDecl(T->getDecl()));
2723   if (!Record)
2724     return QualType();
2725
2726   QualType Result = TL.getType();
2727   if (getDerived().AlwaysRebuild() ||
2728       Record != T->getDecl()) {
2729     Result = getDerived().RebuildRecordType(Record);
2730     if (Result.isNull())
2731       return QualType();
2732   }
2733
2734   RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
2735   NewTL.setNameLoc(TL.getNameLoc());
2736
2737   return Result;
2738 }
2739
2740 template<typename Derived>
2741 QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
2742                                                    EnumTypeLoc TL) {
2743   EnumType *T = TL.getTypePtr();
2744   EnumDecl *Enum
2745     = cast_or_null<EnumDecl>(getDerived().TransformDecl(T->getDecl()));
2746   if (!Enum)
2747     return QualType();
2748
2749   QualType Result = TL.getType();
2750   if (getDerived().AlwaysRebuild() ||
2751       Enum != T->getDecl()) {
2752     Result = getDerived().RebuildEnumType(Enum);
2753     if (Result.isNull())
2754       return QualType();
2755   }
2756
2757   EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result);
2758   NewTL.setNameLoc(TL.getNameLoc());
2759
2760   return Result;
2761 }
2762
2763 template <typename Derived>
2764 QualType TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB,
2765                                                       ElaboratedTypeLoc TL) {
2766   ElaboratedType *T = TL.getTypePtr();
2767
2768   // FIXME: this should be a nested type.
2769   QualType Underlying = getDerived().TransformType(T->getUnderlyingType());
2770   if (Underlying.isNull())
2771     return QualType();
2772
2773   QualType Result = TL.getType();
2774   if (getDerived().AlwaysRebuild() ||
2775       Underlying != T->getUnderlyingType()) {
2776     Result = getDerived().RebuildElaboratedType(Underlying, T->getTagKind());
2777     if (Result.isNull())
2778       return QualType();
2779   }
2780
2781   ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
2782   NewTL.setNameLoc(TL.getNameLoc());
2783
2784   return Result;
2785 }
2786
2787
2788 template<typename Derived>
2789 QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
2790                                                 TypeLocBuilder &TLB,
2791                                                 TemplateTypeParmTypeLoc TL) {
2792   return TransformTypeSpecType(TLB, TL);
2793 }
2794
2795 template<typename Derived>
2796 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
2797                                          TypeLocBuilder &TLB,
2798                                          SubstTemplateTypeParmTypeLoc TL) {
2799   return TransformTypeSpecType(TLB, TL);
2800 }
2801
2802 template<typename Derived>
2803 inline QualType
2804 TreeTransform<Derived>::TransformTemplateSpecializationType(
2805                                           TypeLocBuilder &TLB,
2806                                           TemplateSpecializationTypeLoc TL) {
2807   return TransformTemplateSpecializationType(TLB, TL, QualType());
2808 }
2809
2810 template<typename Derived>
2811 QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
2812                                       const TemplateSpecializationType *TST,
2813                                                         QualType ObjectType) {
2814   // FIXME: this entire method is a temporary workaround; callers
2815   // should be rewritten to provide real type locs.
2816
2817   // Fake up a TemplateSpecializationTypeLoc.
2818   TypeLocBuilder TLB;
2819   TemplateSpecializationTypeLoc TL
2820     = TLB.push<TemplateSpecializationTypeLoc>(QualType(TST, 0));
2821
2822   SourceLocation BaseLoc = getDerived().getBaseLocation();
2823
2824   TL.setTemplateNameLoc(BaseLoc);
2825   TL.setLAngleLoc(BaseLoc);
2826   TL.setRAngleLoc(BaseLoc);
2827   for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
2828     const TemplateArgument &TA = TST->getArg(i);
2829     TemplateArgumentLoc TAL;
2830     getDerived().InventTemplateArgumentLoc(TA, TAL);
2831     TL.setArgLocInfo(i, TAL.getLocInfo());
2832   }
2833
2834   TypeLocBuilder IgnoredTLB;
2835   return TransformTemplateSpecializationType(IgnoredTLB, TL, ObjectType);
2836 }
2837
2838 template<typename Derived>
2839 QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
2840                                                         TypeLocBuilder &TLB,
2841                                            TemplateSpecializationTypeLoc TL,
2842                                                         QualType ObjectType) {
2843   const TemplateSpecializationType *T = TL.getTypePtr();
2844
2845   TemplateName Template
2846     = getDerived().TransformTemplateName(T->getTemplateName(), ObjectType);
2847   if (Template.isNull())
2848     return QualType();
2849
2850   llvm::SmallVector<TemplateArgumentLoc, 4> NewTemplateArgs(T->getNumArgs());
2851   for (unsigned i = 0, e = T->getNumArgs(); i != e; ++i)
2852     if (getDerived().TransformTemplateArgument(TL.getArgLoc(i),
2853                                                NewTemplateArgs[i]))
2854       return QualType();
2855
2856   // FIXME: maybe don't rebuild if all the template arguments are the same.
2857
2858   QualType Result =
2859     getDerived().RebuildTemplateSpecializationType(Template,
2860                                                    TL.getTemplateNameLoc(),
2861                                                    TL.getLAngleLoc(),
2862                                                    NewTemplateArgs.data(),
2863                                                    NewTemplateArgs.size(),
2864                                                    TL.getRAngleLoc());
2865
2866   if (!Result.isNull()) {
2867     TemplateSpecializationTypeLoc NewTL
2868       = TLB.push<TemplateSpecializationTypeLoc>(Result);
2869     NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
2870     NewTL.setLAngleLoc(TL.getLAngleLoc());
2871     NewTL.setRAngleLoc(TL.getRAngleLoc());
2872     for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
2873       NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
2874   }
2875
2876   return Result;
2877 }
2878
2879 template<typename Derived>
2880 QualType
2881 TreeTransform<Derived>::TransformQualifiedNameType(TypeLocBuilder &TLB,
2882                                                    QualifiedNameTypeLoc TL) {
2883   QualifiedNameType *T = TL.getTypePtr();
2884   NestedNameSpecifier *NNS
2885     = getDerived().TransformNestedNameSpecifier(T->getQualifier(),
2886                                                 SourceRange());
2887   if (!NNS)
2888     return QualType();
2889
2890   QualType Named = getDerived().TransformType(T->getNamedType());
2891   if (Named.isNull())
2892     return QualType();
2893
2894   QualType Result = TL.getType();
2895   if (getDerived().AlwaysRebuild() ||
2896       NNS != T->getQualifier() ||
2897       Named != T->getNamedType()) {
2898     Result = getDerived().RebuildQualifiedNameType(NNS, Named);
2899     if (Result.isNull())
2900       return QualType();
2901   }
2902
2903   QualifiedNameTypeLoc NewTL = TLB.push<QualifiedNameTypeLoc>(Result);
2904   NewTL.setNameLoc(TL.getNameLoc());
2905
2906   return Result;
2907 }
2908
2909 template<typename Derived>
2910 QualType TreeTransform<Derived>::TransformTypenameType(TypeLocBuilder &TLB,
2911                                                        TypenameTypeLoc TL) {
2912   TypenameType *T = TL.getTypePtr();
2913
2914   /* FIXME: preserve source information better than this */
2915   SourceRange SR(TL.getNameLoc());
2916
2917   NestedNameSpecifier *NNS
2918     = getDerived().TransformNestedNameSpecifier(T->getQualifier(), SR);
2919   if (!NNS)
2920     return QualType();
2921
2922   QualType Result;
2923
2924   if (const TemplateSpecializationType *TemplateId = T->getTemplateId()) {
2925     QualType NewTemplateId
2926       = getDerived().TransformType(QualType(TemplateId, 0));
2927     if (NewTemplateId.isNull())
2928       return QualType();
2929
2930     if (!getDerived().AlwaysRebuild() &&
2931         NNS == T->getQualifier() &&
2932         NewTemplateId == QualType(TemplateId, 0))
2933       return QualType(T, 0);
2934
2935     Result = getDerived().RebuildTypenameType(NNS, NewTemplateId);
2936   } else {
2937     Result = getDerived().RebuildTypenameType(NNS, T->getIdentifier(), SR);
2938   }
2939   if (Result.isNull())
2940     return QualType();
2941
2942   TypenameTypeLoc NewTL = TLB.push<TypenameTypeLoc>(Result);
2943   NewTL.setNameLoc(TL.getNameLoc());
2944
2945   return Result;
2946 }
2947
2948 template<typename Derived>
2949 QualType
2950 TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
2951                                                    ObjCInterfaceTypeLoc TL) {
2952   assert(false && "TransformObjCInterfaceType unimplemented");
2953   return QualType();
2954 }
2955
2956 template<typename Derived>
2957 QualType
2958 TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
2959                                                ObjCObjectPointerTypeLoc TL) {
2960   assert(false && "TransformObjCObjectPointerType unimplemented");
2961   return QualType();
2962 }
2963
2964 //===----------------------------------------------------------------------===//
2965 // Statement transformation
2966 //===----------------------------------------------------------------------===//
2967 template<typename Derived>
2968 Sema::OwningStmtResult
2969 TreeTransform<Derived>::TransformNullStmt(NullStmt *S) {
2970   return SemaRef.Owned(S->Retain());
2971 }
2972
2973 template<typename Derived>
2974 Sema::OwningStmtResult
2975 TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) {
2976   return getDerived().TransformCompoundStmt(S, false);
2977 }
2978
2979 template<typename Derived>
2980 Sema::OwningStmtResult
2981 TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S,
2982                                               bool IsStmtExpr) {
2983   bool SubStmtChanged = false;
2984   ASTOwningVector<&ActionBase::DeleteStmt> Statements(getSema());
2985   for (CompoundStmt::body_iterator B = S->body_begin(), BEnd = S->body_end();
2986        B != BEnd; ++B) {
2987     OwningStmtResult Result = getDerived().TransformStmt(*B);
2988     if (Result.isInvalid())
2989       return getSema().StmtError();
2990
2991     SubStmtChanged = SubStmtChanged || Result.get() != *B;
2992     Statements.push_back(Result.takeAs<Stmt>());
2993   }
2994
2995   if (!getDerived().AlwaysRebuild() &&
2996       !SubStmtChanged)
2997     return SemaRef.Owned(S->Retain());
2998
2999   return getDerived().RebuildCompoundStmt(S->getLBracLoc(),
3000                                           move_arg(Statements),
3001                                           S->getRBracLoc(),
3002                                           IsStmtExpr);
3003 }
3004
3005 template<typename Derived>
3006 Sema::OwningStmtResult
3007 TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
3008   // The case value expressions are not potentially evaluated.
3009   EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
3010
3011   // Transform the left-hand case value.
3012   OwningExprResult LHS = getDerived().TransformExpr(S->getLHS());
3013   if (LHS.isInvalid())
3014     return SemaRef.StmtError();
3015
3016   // Transform the right-hand case value (for the GNU case-range extension).
3017   OwningExprResult RHS = getDerived().TransformExpr(S->getRHS());
3018   if (RHS.isInvalid())
3019     return SemaRef.StmtError();
3020
3021   // Build the case statement.
3022   // Case statements are always rebuilt so that they will attached to their
3023   // transformed switch statement.
3024   OwningStmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
3025                                                        move(LHS),
3026                                                        S->getEllipsisLoc(),
3027                                                        move(RHS),
3028                                                        S->getColonLoc());
3029   if (Case.isInvalid())
3030     return SemaRef.StmtError();
3031
3032   // Transform the statement following the case
3033   OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
3034   if (SubStmt.isInvalid())
3035     return SemaRef.StmtError();
3036
3037   // Attach the body to the case statement
3038   return getDerived().RebuildCaseStmtBody(move(Case), move(SubStmt));
3039 }
3040
3041 template<typename Derived>
3042 Sema::OwningStmtResult
3043 TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
3044   // Transform the statement following the default case
3045   OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
3046   if (SubStmt.isInvalid())
3047     return SemaRef.StmtError();
3048
3049   // Default statements are always rebuilt
3050   return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
3051                                          move(SubStmt));
3052 }
3053
3054 template<typename Derived>
3055 Sema::OwningStmtResult
3056 TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) {
3057   OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
3058   if (SubStmt.isInvalid())
3059     return SemaRef.StmtError();
3060
3061   // FIXME: Pass the real colon location in.
3062   SourceLocation ColonLoc = SemaRef.PP.getLocForEndOfToken(S->getIdentLoc());
3063   return getDerived().RebuildLabelStmt(S->getIdentLoc(), S->getID(), ColonLoc,
3064                                        move(SubStmt));
3065 }
3066
3067 template<typename Derived>
3068 Sema::OwningStmtResult
3069 TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
3070   // Transform the condition
3071   OwningExprResult Cond = getDerived().TransformExpr(S->getCond());
3072   if (Cond.isInvalid())
3073     return SemaRef.StmtError();
3074
3075   Sema::FullExprArg FullCond(getSema().FullExpr(Cond));
3076
3077   // Transform the "then" branch.
3078   OwningStmtResult Then = getDerived().TransformStmt(S->getThen());
3079   if (Then.isInvalid())
3080     return SemaRef.StmtError();
3081
3082   // Transform the "else" branch.
3083   OwningStmtResult Else = getDerived().TransformStmt(S->getElse());
3084   if (Else.isInvalid())
3085     return SemaRef.StmtError();
3086
3087   if (!getDerived().AlwaysRebuild() &&
3088       FullCond->get() == S->getCond() &&
3089       Then.get() == S->getThen() &&
3090       Else.get() == S->getElse())
3091     return SemaRef.Owned(S->Retain());
3092
3093   return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, move(Then),
3094                                     S->getElseLoc(), move(Else));
3095 }
3096
3097 template<typename Derived>
3098 Sema::OwningStmtResult
3099 TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
3100   // Transform the condition.
3101   OwningExprResult Cond = getDerived().TransformExpr(S->getCond());
3102   if (Cond.isInvalid())
3103     return SemaRef.StmtError();
3104
3105   // Rebuild the switch statement.
3106   OwningStmtResult Switch = getDerived().RebuildSwitchStmtStart(move(Cond));
3107   if (Switch.isInvalid())
3108     return SemaRef.StmtError();
3109
3110   // Transform the body of the switch statement.
3111   OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3112   if (Body.isInvalid())
3113     return SemaRef.StmtError();
3114
3115   // Complete the switch statement.
3116   return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), move(Switch),
3117                                             move(Body));
3118 }
3119
3120 template<typename Derived>
3121 Sema::OwningStmtResult
3122 TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
3123   // Transform the condition
3124   OwningExprResult Cond = getDerived().TransformExpr(S->getCond());
3125   if (Cond.isInvalid())
3126     return SemaRef.StmtError();
3127
3128   Sema::FullExprArg FullCond(getSema().FullExpr(Cond));
3129
3130   // Transform the body
3131   OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3132   if (Body.isInvalid())
3133     return SemaRef.StmtError();
3134
3135   if (!getDerived().AlwaysRebuild() &&
3136       FullCond->get() == S->getCond() &&
3137       Body.get() == S->getBody())
3138     return SemaRef.Owned(S->Retain());
3139
3140   return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond, move(Body));
3141 }
3142
3143 template<typename Derived>
3144 Sema::OwningStmtResult
3145 TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
3146   // Transform the condition
3147   OwningExprResult Cond = getDerived().TransformExpr(S->getCond());
3148   if (Cond.isInvalid())
3149     return SemaRef.StmtError();
3150
3151   // Transform the body
3152   OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3153   if (Body.isInvalid())
3154     return SemaRef.StmtError();
3155
3156   if (!getDerived().AlwaysRebuild() &&
3157       Cond.get() == S->getCond() &&
3158       Body.get() == S->getBody())
3159     return SemaRef.Owned(S->Retain());
3160
3161   return getDerived().RebuildDoStmt(S->getDoLoc(), move(Body), S->getWhileLoc(),
3162                                     /*FIXME:*/S->getWhileLoc(), move(Cond),
3163                                     S->getRParenLoc());
3164 }
3165
3166 template<typename Derived>
3167 Sema::OwningStmtResult
3168 TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
3169   // Transform the initialization statement
3170   OwningStmtResult Init = getDerived().TransformStmt(S->getInit());
3171   if (Init.isInvalid())
3172     return SemaRef.StmtError();
3173
3174   // Transform the condition
3175   OwningExprResult Cond = getDerived().TransformExpr(S->getCond());
3176   if (Cond.isInvalid())
3177     return SemaRef.StmtError();
3178
3179   // Transform the increment
3180   OwningExprResult Inc = getDerived().TransformExpr(S->getInc());
3181   if (Inc.isInvalid())
3182     return SemaRef.StmtError();
3183
3184   // Transform the body
3185   OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3186   if (Body.isInvalid())
3187     return SemaRef.StmtError();
3188
3189   if (!getDerived().AlwaysRebuild() &&
3190       Init.get() == S->getInit() &&
3191       Cond.get() == S->getCond() &&
3192       Inc.get() == S->getInc() &&
3193       Body.get() == S->getBody())
3194     return SemaRef.Owned(S->Retain());
3195
3196   return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
3197                                      move(Init), move(Cond), move(Inc),
3198                                      S->getRParenLoc(), move(Body));
3199 }
3200
3201 template<typename Derived>
3202 Sema::OwningStmtResult
3203 TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
3204   // Goto statements must always be rebuilt, to resolve the label.
3205   return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
3206                                       S->getLabel());
3207 }
3208
3209 template<typename Derived>
3210 Sema::OwningStmtResult
3211 TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
3212   OwningExprResult Target = getDerived().TransformExpr(S->getTarget());
3213   if (Target.isInvalid())
3214     return SemaRef.StmtError();
3215
3216   if (!getDerived().AlwaysRebuild() &&
3217       Target.get() == S->getTarget())
3218     return SemaRef.Owned(S->Retain());
3219
3220   return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
3221                                               move(Target));
3222 }
3223
3224 template<typename Derived>
3225 Sema::OwningStmtResult
3226 TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
3227   return SemaRef.Owned(S->Retain());
3228 }
3229
3230 template<typename Derived>
3231 Sema::OwningStmtResult
3232 TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
3233   return SemaRef.Owned(S->Retain());
3234 }
3235
3236 template<typename Derived>
3237 Sema::OwningStmtResult
3238 TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
3239   Sema::OwningExprResult Result = getDerived().TransformExpr(S->getRetValue());
3240   if (Result.isInvalid())
3241     return SemaRef.StmtError();
3242
3243   // FIXME: We always rebuild the return statement because there is no way
3244   // to tell whether the return type of the function has changed.
3245   return getDerived().RebuildReturnStmt(S->getReturnLoc(), move(Result));
3246 }
3247
3248 template<typename Derived>
3249 Sema::OwningStmtResult
3250 TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
3251   bool DeclChanged = false;
3252   llvm::SmallVector<Decl *, 4> Decls;
3253   for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end();
3254        D != DEnd; ++D) {
3255     Decl *Transformed = getDerived().TransformDefinition(*D);
3256     if (!Transformed)
3257       return SemaRef.StmtError();
3258
3259     if (Transformed != *D)
3260       DeclChanged = true;
3261
3262     Decls.push_back(Transformed);
3263   }
3264
3265   if (!getDerived().AlwaysRebuild() && !DeclChanged)
3266     return SemaRef.Owned(S->Retain());
3267
3268   return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(),
3269                                       S->getStartLoc(), S->getEndLoc());
3270 }
3271
3272 template<typename Derived>
3273 Sema::OwningStmtResult
3274 TreeTransform<Derived>::TransformSwitchCase(SwitchCase *S) {
3275   assert(false && "SwitchCase is abstract and cannot be transformed");
3276   return SemaRef.Owned(S->Retain());
3277 }
3278
3279 template<typename Derived>
3280 Sema::OwningStmtResult
3281 TreeTransform<Derived>::TransformAsmStmt(AsmStmt *S) {
3282   // FIXME: Implement!
3283   assert(false && "Inline assembly cannot be transformed");
3284   return SemaRef.Owned(S->Retain());
3285 }
3286
3287
3288 template<typename Derived>
3289 Sema::OwningStmtResult
3290 TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
3291   // FIXME: Implement this
3292   assert(false && "Cannot transform an Objective-C @try statement");
3293   return SemaRef.Owned(S->Retain());
3294 }
3295
3296 template<typename Derived>
3297 Sema::OwningStmtResult
3298 TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
3299   // FIXME: Implement this
3300   assert(false && "Cannot transform an Objective-C @catch statement");
3301   return SemaRef.Owned(S->Retain());
3302 }
3303
3304 template<typename Derived>
3305 Sema::OwningStmtResult
3306 TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
3307   // FIXME: Implement this
3308   assert(false && "Cannot transform an Objective-C @finally statement");
3309   return SemaRef.Owned(S->Retain());
3310 }
3311
3312 template<typename Derived>
3313 Sema::OwningStmtResult
3314 TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
3315   // FIXME: Implement this
3316   assert(false && "Cannot transform an Objective-C @throw statement");
3317   return SemaRef.Owned(S->Retain());
3318 }
3319
3320 template<typename Derived>
3321 Sema::OwningStmtResult
3322 TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
3323                                                   ObjCAtSynchronizedStmt *S) {
3324   // FIXME: Implement this
3325   assert(false && "Cannot transform an Objective-C @synchronized statement");
3326   return SemaRef.Owned(S->Retain());
3327 }
3328
3329 template<typename Derived>
3330 Sema::OwningStmtResult
3331 TreeTransform<Derived>::TransformObjCForCollectionStmt(
3332                                                   ObjCForCollectionStmt *S) {
3333   // FIXME: Implement this
3334   assert(false && "Cannot transform an Objective-C for-each statement");
3335   return SemaRef.Owned(S->Retain());
3336 }
3337
3338
3339 template<typename Derived>
3340 Sema::OwningStmtResult
3341 TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
3342   // Transform the exception declaration, if any.
3343   VarDecl *Var = 0;
3344   if (S->getExceptionDecl()) {
3345     VarDecl *ExceptionDecl = S->getExceptionDecl();
3346     TemporaryBase Rebase(*this, ExceptionDecl->getLocation(),
3347                          ExceptionDecl->getDeclName());
3348
3349     QualType T = getDerived().TransformType(ExceptionDecl->getType());
3350     if (T.isNull())
3351       return SemaRef.StmtError();
3352
3353     Var = getDerived().RebuildExceptionDecl(ExceptionDecl,
3354                                             T,
3355                                             ExceptionDecl->getDeclaratorInfo(),
3356                                             ExceptionDecl->getIdentifier(),
3357                                             ExceptionDecl->getLocation(),
3358                                             /*FIXME: Inaccurate*/
3359                                     SourceRange(ExceptionDecl->getLocation()));
3360     if (!Var || Var->isInvalidDecl()) {
3361       if (Var)
3362         Var->Destroy(SemaRef.Context);
3363       return SemaRef.StmtError();
3364     }
3365   }
3366
3367   // Transform the actual exception handler.
3368   OwningStmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
3369   if (Handler.isInvalid()) {
3370     if (Var)
3371       Var->Destroy(SemaRef.Context);
3372     return SemaRef.StmtError();
3373   }
3374
3375   if (!getDerived().AlwaysRebuild() &&
3376       !Var &&
3377       Handler.get() == S->getHandlerBlock())
3378     return SemaRef.Owned(S->Retain());
3379
3380   return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(),
3381                                           Var,
3382                                           move(Handler));
3383 }
3384
3385 template<typename Derived>
3386 Sema::OwningStmtResult
3387 TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
3388   // Transform the try block itself.
3389   OwningStmtResult TryBlock
3390     = getDerived().TransformCompoundStmt(S->getTryBlock());
3391   if (TryBlock.isInvalid())
3392     return SemaRef.StmtError();
3393
3394   // Transform the handlers.
3395   bool HandlerChanged = false;
3396   ASTOwningVector<&ActionBase::DeleteStmt> Handlers(SemaRef);
3397   for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) {
3398     OwningStmtResult Handler
3399       = getDerived().TransformCXXCatchStmt(S->getHandler(I));
3400     if (Handler.isInvalid())
3401       return SemaRef.StmtError();
3402
3403     HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I);
3404     Handlers.push_back(Handler.takeAs<Stmt>());
3405   }
3406
3407   if (!getDerived().AlwaysRebuild() &&
3408       TryBlock.get() == S->getTryBlock() &&
3409       !HandlerChanged)
3410     return SemaRef.Owned(S->Retain());
3411
3412   return getDerived().RebuildCXXTryStmt(S->getTryLoc(), move(TryBlock),
3413                                         move_arg(Handlers));
3414 }
3415
3416 //===----------------------------------------------------------------------===//
3417 // Expression transformation
3418 //===----------------------------------------------------------------------===//
3419 template<typename Derived>
3420 Sema::OwningExprResult
3421 TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E,
3422                                                 bool isAddressOfOperand) {
3423   return SemaRef.Owned(E->Retain());
3424 }
3425
3426 template<typename Derived>
3427 Sema::OwningExprResult
3428 TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E,
3429                                              bool isAddressOfOperand) {
3430   NestedNameSpecifier *Qualifier = 0;
3431   if (E->getQualifier()) {
3432     Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
3433                                                        E->getQualifierRange());
3434     if (!Qualifier)
3435       return SemaRef.ExprError();
3436   }
3437
3438   NamedDecl *ND
3439     = dyn_cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getDecl()));
3440   if (!ND)
3441     return SemaRef.ExprError();
3442
3443   if (!getDerived().AlwaysRebuild() &&
3444       Qualifier == E->getQualifier() &&
3445       ND == E->getDecl() &&
3446       !E->hasExplicitTemplateArgumentList())
3447     return SemaRef.Owned(E->Retain());
3448
3449   // FIXME: We're losing the explicit template arguments in this transformation.
3450
3451   llvm::SmallVector<TemplateArgumentLoc, 4> TransArgs(E->getNumTemplateArgs());
3452   for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
3453     if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I],
3454                                                TransArgs[I]))
3455       return SemaRef.ExprError();
3456   }
3457
3458   // FIXME: Pass the qualifier/qualifier range along.
3459   return getDerived().RebuildDeclRefExpr(Qualifier, E->getQualifierRange(),
3460                                          ND, E->getLocation(),
3461                                          isAddressOfOperand);
3462 }
3463
3464 template<typename Derived>
3465 Sema::OwningExprResult
3466 TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E,
3467                                                 bool isAddressOfOperand) {
3468   return SemaRef.Owned(E->Retain());
3469 }
3470
3471 template<typename Derived>
3472 Sema::OwningExprResult
3473 TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E,
3474                                                  bool isAddressOfOperand) {
3475   return SemaRef.Owned(E->Retain());
3476 }
3477
3478 template<typename Derived>
3479 Sema::OwningExprResult
3480 TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E,
3481                                                   bool isAddressOfOperand) {
3482   return SemaRef.Owned(E->Retain());
3483 }
3484
3485 template<typename Derived>
3486 Sema::OwningExprResult
3487 TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E,
3488                                                bool isAddressOfOperand) {
3489   return SemaRef.Owned(E->Retain());
3490 }
3491
3492 template<typename Derived>
3493 Sema::OwningExprResult
3494 TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E,
3495                                                   bool isAddressOfOperand) {
3496   return SemaRef.Owned(E->Retain());
3497 }
3498
3499 template<typename Derived>
3500 Sema::OwningExprResult
3501 TreeTransform<Derived>::TransformParenExpr(ParenExpr *E,
3502                                            bool isAddressOfOperand) {
3503   OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
3504   if (SubExpr.isInvalid())
3505     return SemaRef.ExprError();
3506
3507   if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
3508     return SemaRef.Owned(E->Retain());
3509
3510   return getDerived().RebuildParenExpr(move(SubExpr), E->getLParen(),
3511                                        E->getRParen());
3512 }
3513
3514 template<typename Derived>
3515 Sema::OwningExprResult
3516 TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E,
3517                                                bool isAddressOfOperand) {
3518   OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr(),
3519                                        E->getOpcode() == UnaryOperator::AddrOf);
3520   if (SubExpr.isInvalid())
3521     return SemaRef.ExprError();
3522
3523   if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
3524     return SemaRef.Owned(E->Retain());
3525
3526   return getDerived().RebuildUnaryOperator(E->getOperatorLoc(),
3527                                            E->getOpcode(),
3528                                            move(SubExpr));
3529 }
3530
3531 template<typename Derived>
3532 Sema::OwningExprResult
3533 TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E,
3534                                                    bool isAddressOfOperand) {
3535   if (E->isArgumentType()) {
3536     DeclaratorInfo *OldT = E->getArgumentTypeInfo();
3537
3538     DeclaratorInfo *NewT = getDerived().TransformType(OldT);
3539     if (!NewT)
3540       return SemaRef.ExprError();
3541
3542     if (!getDerived().AlwaysRebuild() && OldT == NewT)
3543       return SemaRef.Owned(E->Retain());
3544
3545     return getDerived().RebuildSizeOfAlignOf(NewT, E->getOperatorLoc(),
3546                                              E->isSizeOf(),
3547                                              E->getSourceRange());
3548   }
3549
3550   Sema::OwningExprResult SubExpr(SemaRef);
3551   {
3552     // C++0x [expr.sizeof]p1:
3553     //   The operand is either an expression, which is an unevaluated operand
3554     //   [...]
3555     EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
3556
3557     SubExpr = getDerived().TransformExpr(E->getArgumentExpr());
3558     if (SubExpr.isInvalid())
3559       return SemaRef.ExprError();
3560
3561     if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
3562       return SemaRef.Owned(E->Retain());
3563   }
3564
3565   return getDerived().RebuildSizeOfAlignOf(move(SubExpr), E->getOperatorLoc(),
3566                                            E->isSizeOf(),
3567                                            E->getSourceRange());
3568 }
3569
3570 template<typename Derived>
3571 Sema::OwningExprResult
3572 TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E,
3573                                                     bool isAddressOfOperand) {
3574   OwningExprResult LHS = getDerived().TransformExpr(E->getLHS());
3575   if (LHS.isInvalid())
3576     return SemaRef.ExprError();
3577
3578   OwningExprResult RHS = getDerived().TransformExpr(E->getRHS());
3579   if (RHS.isInvalid())
3580     return SemaRef.ExprError();
3581
3582
3583   if (!getDerived().AlwaysRebuild() &&
3584       LHS.get() == E->getLHS() &&
3585       RHS.get() == E->getRHS())
3586     return SemaRef.Owned(E->Retain());
3587
3588   return getDerived().RebuildArraySubscriptExpr(move(LHS),
3589                                            /*FIXME:*/E->getLHS()->getLocStart(),
3590                                                 move(RHS),
3591                                                 E->getRBracketLoc());
3592 }
3593
3594 template<typename Derived>
3595 Sema::OwningExprResult
3596 TreeTransform<Derived>::TransformCallExpr(CallExpr *E,
3597                                           bool isAddressOfOperand) {
3598   // Transform the callee.
3599   OwningExprResult Callee = getDerived().TransformExpr(E->getCallee());
3600   if (Callee.isInvalid())
3601     return SemaRef.ExprError();
3602
3603   // Transform arguments.
3604   bool ArgChanged = false;
3605   ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
3606   llvm::SmallVector<SourceLocation, 4> FakeCommaLocs;
3607   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
3608     OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I));
3609     if (Arg.isInvalid())
3610       return SemaRef.ExprError();
3611
3612     // FIXME: Wrong source location information for the ','.
3613     FakeCommaLocs.push_back(
3614        SemaRef.PP.getLocForEndOfToken(E->getArg(I)->getSourceRange().getEnd()));
3615
3616     ArgChanged = ArgChanged || Arg.get() != E->getArg(I);
3617     Args.push_back(Arg.takeAs<Expr>());
3618   }
3619
3620   if (!getDerived().AlwaysRebuild() &&
3621       Callee.get() == E->getCallee() &&
3622       !ArgChanged)
3623     return SemaRef.Owned(E->Retain());
3624
3625   // FIXME: Wrong source location information for the '('.
3626   SourceLocation FakeLParenLoc
3627     = ((Expr *)Callee.get())->getSourceRange().getBegin();
3628   return getDerived().RebuildCallExpr(move(Callee), FakeLParenLoc,
3629                                       move_arg(Args),
3630                                       FakeCommaLocs.data(),
3631                                       E->getRParenLoc());
3632 }
3633
3634 template<typename Derived>
3635 Sema::OwningExprResult
3636 TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E,
3637                                             bool isAddressOfOperand) {
3638   OwningExprResult Base = getDerived().TransformExpr(E->getBase());
3639   if (Base.isInvalid())
3640     return SemaRef.ExprError();
3641
3642   NestedNameSpecifier *Qualifier = 0;
3643   if (E->hasQualifier()) {
3644     Qualifier
3645       = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
3646                                                   E->getQualifierRange());
3647     if (Qualifier == 0)
3648       return SemaRef.ExprError();
3649   }
3650
3651   NamedDecl *Member
3652     = cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getMemberDecl()));
3653   if (!Member)
3654     return SemaRef.ExprError();
3655
3656   if (!getDerived().AlwaysRebuild() &&
3657       Base.get() == E->getBase() &&
3658       Qualifier == E->getQualifier() &&
3659       Member == E->getMemberDecl())
3660     return SemaRef.Owned(E->Retain());
3661
3662   // FIXME: Bogus source location for the operator
3663   SourceLocation FakeOperatorLoc
3664     = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd());
3665
3666   return getDerived().RebuildMemberExpr(move(Base), FakeOperatorLoc,
3667                                         E->isArrow(),
3668                                         Qualifier,
3669                                         E->getQualifierRange(),
3670                                         E->getMemberLoc(),
3671                                         Member);
3672 }
3673
3674 template<typename Derived>
3675 Sema::OwningExprResult
3676 TreeTransform<Derived>::TransformCastExpr(CastExpr *E,
3677                                           bool isAddressOfOperand) {
3678   assert(false && "Cannot transform abstract class");
3679   return SemaRef.Owned(E->Retain());
3680 }
3681
3682 template<typename Derived>
3683 Sema::OwningExprResult
3684 TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E,
3685                                                 bool isAddressOfOperand) {
3686   OwningExprResult LHS = getDerived().TransformExpr(E->getLHS());
3687   if (LHS.isInvalid())
3688     return SemaRef.ExprError();
3689
3690   OwningExprResult RHS = getDerived().TransformExpr(E->getRHS());
3691   if (RHS.isInvalid())
3692     return SemaRef.ExprError();
3693
3694   if (!getDerived().AlwaysRebuild() &&
3695       LHS.get() == E->getLHS() &&
3696       RHS.get() == E->getRHS())
3697     return SemaRef.Owned(E->Retain());
3698
3699   return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
3700                                             move(LHS), move(RHS));
3701 }
3702
3703 template<typename Derived>
3704 Sema::OwningExprResult
3705 TreeTransform<Derived>::TransformCompoundAssignOperator(
3706                                                       CompoundAssignOperator *E,
3707                                                       bool isAddressOfOperand) {
3708   return getDerived().TransformBinaryOperator(E, isAddressOfOperand);
3709 }
3710
3711 template<typename Derived>
3712 Sema::OwningExprResult
3713 TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E,
3714                                                      bool isAddressOfOperand) {
3715   OwningExprResult Cond = getDerived().TransformExpr(E->getCond());
3716   if (Cond.isInvalid())
3717     return SemaRef.ExprError();
3718
3719   OwningExprResult LHS = getDerived().TransformExpr(E->getLHS());
3720   if (LHS.isInvalid())
3721     return SemaRef.ExprError();
3722
3723   OwningExprResult RHS = getDerived().TransformExpr(E->getRHS());
3724   if (RHS.isInvalid())
3725     return SemaRef.ExprError();
3726
3727   if (!getDerived().AlwaysRebuild() &&
3728       Cond.get() == E->getCond() &&
3729       LHS.get() == E->getLHS() &&
3730       RHS.get() == E->getRHS())
3731     return SemaRef.Owned(E->Retain());
3732
3733   return getDerived().RebuildConditionalOperator(move(Cond),
3734                                                  E->getQuestionLoc(),
3735                                                  move(LHS),
3736                                                  E->getColonLoc(),
3737                                                  move(RHS));
3738 }
3739
3740 template<typename Derived>
3741 Sema::OwningExprResult
3742 TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E,
3743                                                   bool isAddressOfOperand) {
3744   TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName());
3745
3746   // FIXME: Will we ever have type information here? It seems like we won't,
3747   // so do we even need to transform the type?
3748   QualType T = getDerived().TransformType(E->getType());
3749   if (T.isNull())
3750     return SemaRef.ExprError();
3751
3752   OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
3753   if (SubExpr.isInvalid())
3754     return SemaRef.ExprError();
3755
3756   if (!getDerived().AlwaysRebuild() &&
3757       T == E->getType() &&
3758       SubExpr.get() == E->getSubExpr())
3759     return SemaRef.Owned(E->Retain());
3760
3761   return getDerived().RebuildImplicitCastExpr(T, E->getCastKind(),
3762                                               move(SubExpr),
3763                                               E->isLvalueCast());
3764 }
3765
3766 template<typename Derived>
3767 Sema::OwningExprResult
3768 TreeTransform<Derived>::TransformExplicitCastExpr(ExplicitCastExpr *E,
3769                                                   bool isAddressOfOperand) {
3770   assert(false && "Cannot transform abstract class");
3771   return SemaRef.Owned(E->Retain());
3772 }
3773
3774 template<typename Derived>
3775 Sema::OwningExprResult
3776 TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E,
3777                                                 bool isAddressOfOperand) {
3778   QualType T;
3779   {
3780     // FIXME: Source location isn't quite accurate.
3781     SourceLocation TypeStartLoc
3782       = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc());
3783     TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName());
3784
3785     T = getDerived().TransformType(E->getTypeAsWritten());
3786     if (T.isNull())
3787       return SemaRef.ExprError();
3788   }
3789
3790   OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
3791   if (SubExpr.isInvalid())
3792     return SemaRef.ExprError();
3793
3794   if (!getDerived().AlwaysRebuild() &&
3795       T == E->getTypeAsWritten() &&
3796       SubExpr.get() == E->getSubExpr())
3797     return SemaRef.Owned(E->Retain());
3798
3799   return getDerived().RebuildCStyleCaseExpr(E->getLParenLoc(), T,
3800                                             E->getRParenLoc(),
3801                                             move(SubExpr));
3802 }
3803
3804 template<typename Derived>
3805 Sema::OwningExprResult
3806 TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E,
3807                                                      bool isAddressOfOperand) {
3808   QualType T;
3809   {
3810     // FIXME: Source location isn't quite accurate.
3811     SourceLocation FakeTypeLoc
3812       = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc());
3813     TemporaryBase Rebase(*this, FakeTypeLoc, DeclarationName());
3814
3815     T = getDerived().TransformType(E->getType());
3816     if (T.isNull())
3817       return SemaRef.ExprError();
3818   }
3819
3820   OwningExprResult Init = getDerived().TransformExpr(E->getInitializer());
3821   if (Init.isInvalid())
3822     return SemaRef.ExprError();
3823
3824   if (!getDerived().AlwaysRebuild() &&
3825       T == E->getType() &&
3826       Init.get() == E->getInitializer())
3827     return SemaRef.Owned(E->Retain());
3828
3829   return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), T,
3830                                    /*FIXME:*/E->getInitializer()->getLocEnd(),
3831                                                  move(Init));
3832 }
3833
3834 template<typename Derived>
3835 Sema::OwningExprResult
3836 TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E,
3837                                                       bool isAddressOfOperand) {
3838   OwningExprResult Base = getDerived().TransformExpr(E->getBase());
3839   if (Base.isInvalid())
3840     return SemaRef.ExprError();
3841
3842   if (!getDerived().AlwaysRebuild() &&
3843       Base.get() == E->getBase())
3844     return SemaRef.Owned(E->Retain());
3845
3846   // FIXME: Bad source location
3847   SourceLocation FakeOperatorLoc
3848     = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd());
3849   return getDerived().RebuildExtVectorElementExpr(move(Base), FakeOperatorLoc,
3850                                                   E->getAccessorLoc(),
3851                                                   E->getAccessor());
3852 }
3853
3854 template<typename Derived>
3855 Sema::OwningExprResult
3856 TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E,
3857                                               bool isAddressOfOperand) {
3858   bool InitChanged = false;
3859
3860   ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef);
3861   for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) {
3862     OwningExprResult Init = getDerived().TransformExpr(E->getInit(I));
3863     if (Init.isInvalid())
3864       return SemaRef.ExprError();
3865
3866     InitChanged = InitChanged || Init.get() != E->getInit(I);
3867     Inits.push_back(Init.takeAs<Expr>());
3868   }
3869
3870   if (!getDerived().AlwaysRebuild() && !InitChanged)
3871     return SemaRef.Owned(E->Retain());
3872
3873   return getDerived().RebuildInitList(E->getLBraceLoc(), move_arg(Inits),
3874                                       E->getRBraceLoc());
3875 }
3876
3877 template<typename Derived>
3878 Sema::OwningExprResult
3879 TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E,
3880                                                     bool isAddressOfOperand) {
3881   Designation Desig;
3882
3883   // transform the initializer value
3884   OwningExprResult Init = getDerived().TransformExpr(E->getInit());
3885   if (Init.isInvalid())
3886     return SemaRef.ExprError();
3887
3888   // transform the designators.
3889   ASTOwningVector<&ActionBase::DeleteExpr, 4> ArrayExprs(SemaRef);
3890   bool ExprChanged = false;
3891   for (DesignatedInitExpr::designators_iterator D = E->designators_begin(),
3892                                              DEnd = E->designators_end();
3893        D != DEnd; ++D) {
3894     if (D->isFieldDesignator()) {
3895       Desig.AddDesignator(Designator::getField(D->getFieldName(),
3896                                                D->getDotLoc(),
3897                                                D->getFieldLoc()));
3898       continue;
3899     }
3900
3901     if (D->isArrayDesignator()) {
3902       OwningExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D));
3903       if (Index.isInvalid())
3904         return SemaRef.ExprError();
3905
3906       Desig.AddDesignator(Designator::getArray(Index.get(),
3907                                                D->getLBracketLoc()));
3908
3909       ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D);
3910       ArrayExprs.push_back(Index.release());
3911       continue;
3912     }
3913
3914     assert(D->isArrayRangeDesignator() && "New kind of designator?");
3915     OwningExprResult Start
3916       = getDerived().TransformExpr(E->getArrayRangeStart(*D));
3917     if (Start.isInvalid())
3918       return SemaRef.ExprError();
3919
3920     OwningExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D));
3921     if (End.isInvalid())
3922       return SemaRef.ExprError();
3923
3924     Desig.AddDesignator(Designator::getArrayRange(Start.get(),
3925                                                   End.get(),
3926                                                   D->getLBracketLoc(),
3927                                                   D->getEllipsisLoc()));
3928
3929     ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) ||
3930       End.get() != E->getArrayRangeEnd(*D);
3931
3932     ArrayExprs.push_back(Start.release());
3933     ArrayExprs.push_back(End.release());
3934   }
3935
3936   if (!getDerived().AlwaysRebuild() &&
3937       Init.get() == E->getInit() &&
3938       !ExprChanged)
3939     return SemaRef.Owned(E->Retain());
3940
3941   return getDerived().RebuildDesignatedInitExpr(Desig, move_arg(ArrayExprs),
3942                                                 E->getEqualOrColonLoc(),
3943                                                 E->usesGNUSyntax(), move(Init));
3944 }
3945
3946 template<typename Derived>
3947 Sema::OwningExprResult
3948 TreeTransform<Derived>::TransformImplicitValueInitExpr(
3949                                                      ImplicitValueInitExpr *E,
3950                                                      bool isAddressOfOperand) {
3951   TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName());
3952
3953   // FIXME: Will we ever have proper type location here? Will we actually
3954   // need to transform the type?
3955   QualType T = getDerived().TransformType(E->getType());
3956   if (T.isNull())
3957     return SemaRef.ExprError();
3958
3959   if (!getDerived().AlwaysRebuild() &&
3960       T == E->getType())
3961     return SemaRef.Owned(E->Retain());
3962
3963   return getDerived().RebuildImplicitValueInitExpr(T);
3964 }
3965
3966 template<typename Derived>
3967 Sema::OwningExprResult
3968 TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E,
3969                                            bool isAddressOfOperand) {
3970   // FIXME: Do we want the type as written?
3971   QualType T;
3972
3973   {
3974     // FIXME: Source location isn't quite accurate.
3975     TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName());
3976     T = getDerived().TransformType(E->getType());
3977     if (T.isNull())
3978       return SemaRef.ExprError();
3979   }
3980
3981   OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
3982   if (SubExpr.isInvalid())
3983     return SemaRef.ExprError();
3984
3985   if (!getDerived().AlwaysRebuild() &&
3986       T == E->getType() &&
3987       SubExpr.get() == E->getSubExpr())
3988     return SemaRef.Owned(E->Retain());
3989
3990   return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), move(SubExpr),
3991                                        T, E->getRParenLoc());
3992 }
3993
3994 template<typename Derived>
3995 Sema::OwningExprResult
3996 TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E,
3997                                                bool isAddressOfOperand) {
3998   bool ArgumentChanged = false;
3999   ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef);
4000   for (unsigned I = 0, N = E->getNumExprs(); I != N; ++I) {
4001     OwningExprResult Init = getDerived().TransformExpr(E->getExpr(I));
4002     if (Init.isInvalid())
4003       return SemaRef.ExprError();
4004
4005     ArgumentChanged = ArgumentChanged || Init.get() != E->getExpr(I);
4006     Inits.push_back(Init.takeAs<Expr>());
4007   }
4008
4009   return getDerived().RebuildParenListExpr(E->getLParenLoc(),
4010                                            move_arg(Inits),
4011                                            E->getRParenLoc());
4012 }
4013
4014 /// \brief Transform an address-of-label expression.
4015 ///
4016 /// By default, the transformation of an address-of-label expression always
4017 /// rebuilds the expression, so that the label identifier can be resolved to
4018 /// the corresponding label statement by semantic analysis.
4019 template<typename Derived>
4020 Sema::OwningExprResult
4021 TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E,
4022                                                bool isAddressOfOperand) {
4023   return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
4024                                            E->getLabel());
4025 }
4026
4027 template<typename Derived>
4028 Sema::OwningExprResult
4029 TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E,
4030                                           bool isAddressOfOperand) {
4031   OwningStmtResult SubStmt
4032     = getDerived().TransformCompoundStmt(E->getSubStmt(), true);
4033   if (SubStmt.isInvalid())
4034     return SemaRef.ExprError();
4035
4036   if (!getDerived().AlwaysRebuild() &&
4037       SubStmt.get() == E->getSubStmt())
4038     return SemaRef.Owned(E->Retain());
4039
4040   return getDerived().RebuildStmtExpr(E->getLParenLoc(),
4041                                       move(SubStmt),
4042                                       E->getRParenLoc());
4043 }
4044
4045 template<typename Derived>
4046 Sema::OwningExprResult
4047 TreeTransform<Derived>::TransformTypesCompatibleExpr(TypesCompatibleExpr *E,
4048                                                      bool isAddressOfOperand) {
4049   QualType T1, T2;
4050   {
4051     // FIXME: Source location isn't quite accurate.
4052     TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName());
4053
4054     T1 = getDerived().TransformType(E->getArgType1());
4055     if (T1.isNull())
4056       return SemaRef.ExprError();
4057
4058     T2 = getDerived().TransformType(E->getArgType2());
4059     if (T2.isNull())
4060       return SemaRef.ExprError();
4061   }
4062
4063   if (!getDerived().AlwaysRebuild() &&
4064       T1 == E->getArgType1() &&
4065       T2 == E->getArgType2())
4066     return SemaRef.Owned(E->Retain());
4067
4068   return getDerived().RebuildTypesCompatibleExpr(E->getBuiltinLoc(),
4069                                                  T1, T2, E->getRParenLoc());
4070 }
4071
4072 template<typename Derived>
4073 Sema::OwningExprResult
4074 TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E,
4075                                             bool isAddressOfOperand) {
4076   OwningExprResult Cond = getDerived().TransformExpr(E->getCond());
4077   if (Cond.isInvalid())
4078     return SemaRef.ExprError();
4079
4080   OwningExprResult LHS = getDerived().TransformExpr(E->getLHS());
4081   if (LHS.isInvalid())
4082     return SemaRef.ExprError();
4083
4084   OwningExprResult RHS = getDerived().TransformExpr(E->getRHS());
4085   if (RHS.isInvalid())
4086     return SemaRef.ExprError();
4087
4088   if (!getDerived().AlwaysRebuild() &&
4089       Cond.get() == E->getCond() &&
4090       LHS.get() == E->getLHS() &&
4091       RHS.get() == E->getRHS())
4092     return SemaRef.Owned(E->Retain());
4093
4094   return getDerived().RebuildChooseExpr(E->getBuiltinLoc(),
4095                                         move(Cond), move(LHS), move(RHS),
4096                                         E->getRParenLoc());
4097 }
4098
4099 template<typename Derived>
4100 Sema::OwningExprResult
4101 TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E,
4102                                              bool isAddressOfOperand) {
4103   return SemaRef.Owned(E->Retain());
4104 }
4105
4106 template<typename Derived>
4107 Sema::OwningExprResult
4108 TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E,
4109                                                      bool isAddressOfOperand) {
4110   OwningExprResult Callee = getDerived().TransformExpr(E->getCallee());
4111   if (Callee.isInvalid())
4112     return SemaRef.ExprError();
4113
4114   OwningExprResult First
4115     = getDerived().TransformExpr(E->getArg(0),
4116                            E->getNumArgs() == 1 && E->getOperator() == OO_Amp);
4117   if (First.isInvalid())
4118     return SemaRef.ExprError();
4119
4120   OwningExprResult Second(SemaRef);
4121   if (E->getNumArgs() == 2) {
4122     Second = getDerived().TransformExpr(E->getArg(1));
4123     if (Second.isInvalid())
4124       return SemaRef.ExprError();
4125   }
4126
4127   if (!getDerived().AlwaysRebuild() &&
4128       Callee.get() == E->getCallee() &&
4129       First.get() == E->getArg(0) &&
4130       (E->getNumArgs() != 2 || Second.get() == E->getArg(1)))
4131     return SemaRef.Owned(E->Retain());
4132
4133   return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(),
4134                                                  E->getOperatorLoc(),
4135                                                  move(Callee),
4136                                                  move(First),
4137                                                  move(Second));
4138 }
4139
4140 template<typename Derived>
4141 Sema::OwningExprResult
4142 TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E,
4143                                                    bool isAddressOfOperand) {
4144   return getDerived().TransformCallExpr(E, isAddressOfOperand);
4145 }
4146
4147 template<typename Derived>
4148 Sema::OwningExprResult
4149 TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E,
4150                                                   bool isAddressOfOperand) {
4151   QualType ExplicitTy;
4152   {
4153     // FIXME: Source location isn't quite accurate.
4154     SourceLocation TypeStartLoc
4155       = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc());
4156     TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName());
4157
4158     ExplicitTy = getDerived().TransformType(E->getTypeAsWritten());
4159     if (ExplicitTy.isNull())
4160       return SemaRef.ExprError();
4161   }
4162
4163   OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
4164   if (SubExpr.isInvalid())
4165     return SemaRef.ExprError();
4166
4167   if (!getDerived().AlwaysRebuild() &&
4168       ExplicitTy == E->getTypeAsWritten() &&
4169       SubExpr.get() == E->getSubExpr())
4170     return SemaRef.Owned(E->Retain());
4171
4172   // FIXME: Poor source location information here.
4173   SourceLocation FakeLAngleLoc
4174     = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc());
4175   SourceLocation FakeRAngleLoc = E->getSubExpr()->getSourceRange().getBegin();
4176   SourceLocation FakeRParenLoc
4177     = SemaRef.PP.getLocForEndOfToken(
4178                                   E->getSubExpr()->getSourceRange().getEnd());
4179   return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(),
4180                                               E->getStmtClass(),
4181                                               FakeLAngleLoc,
4182                                               ExplicitTy,
4183                                               FakeRAngleLoc,
4184                                               FakeRAngleLoc,
4185                                               move(SubExpr),
4186                                               FakeRParenLoc);
4187 }
4188
4189 template<typename Derived>
4190 Sema::OwningExprResult
4191 TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E,
4192                                                    bool isAddressOfOperand) {
4193   return getDerived().TransformCXXNamedCastExpr(E, isAddressOfOperand);
4194 }
4195
4196 template<typename Derived>
4197 Sema::OwningExprResult
4198 TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E,
4199                                                     bool isAddressOfOperand) {
4200   return getDerived().TransformCXXNamedCastExpr(E, isAddressOfOperand);
4201 }
4202
4203 template<typename Derived>
4204 Sema::OwningExprResult
4205 TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
4206                                                       CXXReinterpretCastExpr *E,
4207                                                       bool isAddressOfOperand) {
4208   return getDerived().TransformCXXNamedCastExpr(E, isAddressOfOperand);
4209 }
4210
4211 template<typename Derived>
4212 Sema::OwningExprResult
4213 TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E,
4214                                                   bool isAddressOfOperand) {
4215   return getDerived().TransformCXXNamedCastExpr(E, isAddressOfOperand);
4216 }
4217
4218 template<typename Derived>
4219 Sema::OwningExprResult
4220 TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
4221                                                      CXXFunctionalCastExpr *E,
4222                                                      bool isAddressOfOperand) {
4223   QualType ExplicitTy;
4224   {
4225     TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
4226
4227     ExplicitTy = getDerived().TransformType(E->getTypeAsWritten());
4228     if (ExplicitTy.isNull())
4229       return SemaRef.ExprError();
4230   }
4231
4232   OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
4233   if (SubExpr.isInvalid())
4234     return SemaRef.ExprError();
4235
4236   if (!getDerived().AlwaysRebuild() &&
4237       ExplicitTy == E->getTypeAsWritten() &&
4238       SubExpr.get() == E->getSubExpr())
4239     return SemaRef.Owned(E->Retain());
4240
4241   // FIXME: The end of the type's source range is wrong
4242   return getDerived().RebuildCXXFunctionalCastExpr(
4243                                   /*FIXME:*/SourceRange(E->getTypeBeginLoc()),
4244                                                    ExplicitTy,
4245                                       /*FIXME:*/E->getSubExpr()->getLocStart(),
4246                                                    move(SubExpr),
4247                                                    E->getRParenLoc());
4248 }
4249
4250 template<typename Derived>
4251 Sema::OwningExprResult
4252 TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E,
4253                                                bool isAddressOfOperand) {
4254   if (E->isTypeOperand()) {
4255     TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName());
4256
4257     QualType T = getDerived().TransformType(E->getTypeOperand());
4258     if (T.isNull())
4259       return SemaRef.ExprError();
4260
4261     if (!getDerived().AlwaysRebuild() &&
4262         T == E->getTypeOperand())
4263       return SemaRef.Owned(E->Retain());
4264
4265     return getDerived().RebuildCXXTypeidExpr(E->getLocStart(),
4266                                              /*FIXME:*/E->getLocStart(),
4267                                              T,
4268                                              E->getLocEnd());
4269   }
4270
4271   // We don't know whether the expression is potentially evaluated until
4272   // after we perform semantic analysis, so the expression is potentially
4273   // potentially evaluated.
4274   EnterExpressionEvaluationContext Unevaluated(SemaRef,
4275                                       Action::PotentiallyPotentiallyEvaluated);
4276
4277   OwningExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
4278   if (SubExpr.isInvalid())
4279     return SemaRef.ExprError();
4280
4281   if (!getDerived().AlwaysRebuild() &&
4282       SubExpr.get() == E->getExprOperand())
4283     return SemaRef.Owned(E->Retain());
4284
4285   return getDerived().RebuildCXXTypeidExpr(E->getLocStart(),
4286                                            /*FIXME:*/E->getLocStart(),
4287                                            move(SubExpr),
4288                                            E->getLocEnd());
4289 }
4290
4291 template<typename Derived>
4292 Sema::OwningExprResult
4293 TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E,
4294                                                     bool isAddressOfOperand) {
4295   return SemaRef.Owned(E->Retain());
4296 }
4297
4298 template<typename Derived>
4299 Sema::OwningExprResult
4300 TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
4301                                                      CXXNullPtrLiteralExpr *E,
4302                                                      bool isAddressOfOperand) {
4303   return SemaRef.Owned(E->Retain());
4304 }
4305
4306 template<typename Derived>
4307 Sema::OwningExprResult
4308 TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E,
4309                                              bool isAddressOfOperand) {
4310   TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName());
4311
4312   QualType T = getDerived().TransformType(E->getType());
4313   if (T.isNull())
4314     return SemaRef.ExprError();
4315
4316   if (!getDerived().AlwaysRebuild() &&
4317       T == E->getType())
4318     return SemaRef.Owned(E->Retain());
4319
4320   return getDerived().RebuildCXXThisExpr(E->getLocStart(), T);
4321 }
4322
4323 template<typename Derived>
4324 Sema::OwningExprResult
4325 TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E,
4326                                               bool isAddressOfOperand) {
4327   OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
4328   if (SubExpr.isInvalid())
4329     return SemaRef.ExprError();
4330
4331   if (!getDerived().AlwaysRebuild() &&
4332       SubExpr.get() == E->getSubExpr())
4333     return SemaRef.Owned(E->Retain());
4334
4335   return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), move(SubExpr));
4336 }
4337
4338 template<typename Derived>
4339 Sema::OwningExprResult
4340 TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E,
4341                                                    bool isAddressOfOperand) {
4342   ParmVarDecl *Param
4343     = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getParam()));
4344   if (!Param)
4345     return SemaRef.ExprError();
4346
4347   if (getDerived().AlwaysRebuild() &&
4348       Param == E->getParam())
4349     return SemaRef.Owned(E->Retain());
4350
4351   return getDerived().RebuildCXXDefaultArgExpr(Param);
4352 }
4353
4354 template<typename Derived>
4355 Sema::OwningExprResult
4356 TreeTransform<Derived>::TransformCXXZeroInitValueExpr(CXXZeroInitValueExpr *E,
4357                                                       bool isAddressOfOperand) {
4358   TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
4359
4360   QualType T = getDerived().TransformType(E->getType());
4361   if (T.isNull())
4362     return SemaRef.ExprError();
4363
4364   if (!getDerived().AlwaysRebuild() &&
4365       T == E->getType())
4366     return SemaRef.Owned(E->Retain());
4367
4368   return getDerived().RebuildCXXZeroInitValueExpr(E->getTypeBeginLoc(),
4369                                                 /*FIXME:*/E->getTypeBeginLoc(),
4370                                                   T,
4371                                                   E->getRParenLoc());
4372 }
4373
4374 template<typename Derived>
4375 Sema::OwningExprResult
4376 TreeTransform<Derived>::TransformCXXConditionDeclExpr(CXXConditionDeclExpr *E,
4377                                                       bool isAddressOfOperand) {
4378   VarDecl *Var
4379     = cast_or_null<VarDecl>(getDerived().TransformDefinition(E->getVarDecl()));
4380   if (!Var)
4381     return SemaRef.ExprError();
4382
4383   if (!getDerived().AlwaysRebuild() &&
4384       Var == E->getVarDecl())
4385     return SemaRef.Owned(E->Retain());
4386
4387   return getDerived().RebuildCXXConditionDeclExpr(E->getStartLoc(),
4388                                                   /*FIXME:*/E->getStartLoc(),
4389                                                   Var);
4390 }
4391
4392 template<typename Derived>
4393 Sema::OwningExprResult
4394 TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E,
4395                                             bool isAddressOfOperand) {
4396   // Transform the type that we're allocating
4397   TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName());
4398   QualType AllocType = getDerived().TransformType(E->getAllocatedType());
4399   if (AllocType.isNull())
4400     return SemaRef.ExprError();
4401
4402   // Transform the size of the array we're allocating (if any).
4403   OwningExprResult ArraySize = getDerived().TransformExpr(E->getArraySize());
4404   if (ArraySize.isInvalid())
4405     return SemaRef.ExprError();
4406
4407   // Transform the placement arguments (if any).
4408   bool ArgumentChanged = false;
4409   ASTOwningVector<&ActionBase::DeleteExpr> PlacementArgs(SemaRef);
4410   for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) {
4411     OwningExprResult Arg = getDerived().TransformExpr(E->getPlacementArg(I));
4412     if (Arg.isInvalid())
4413       return SemaRef.ExprError();
4414
4415     ArgumentChanged = ArgumentChanged || Arg.get() != E->getPlacementArg(I);
4416     PlacementArgs.push_back(Arg.take());
4417   }
4418
4419   // transform the constructor arguments (if any).
4420   ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(SemaRef);
4421   for (unsigned I = 0, N = E->getNumConstructorArgs(); I != N; ++I) {
4422     OwningExprResult Arg = getDerived().TransformExpr(E->getConstructorArg(I));
4423     if (Arg.isInvalid())
4424       return SemaRef.ExprError();
4425
4426     ArgumentChanged = ArgumentChanged || Arg.get() != E->getConstructorArg(I);
4427     ConstructorArgs.push_back(Arg.take());
4428   }
4429
4430   if (!getDerived().AlwaysRebuild() &&
4431       AllocType == E->getAllocatedType() &&
4432       ArraySize.get() == E->getArraySize() &&
4433       !ArgumentChanged)
4434     return SemaRef.Owned(E->Retain());
4435
4436   return getDerived().RebuildCXXNewExpr(E->getLocStart(),
4437                                         E->isGlobalNew(),
4438                                         /*FIXME:*/E->getLocStart(),
4439                                         move_arg(PlacementArgs),
4440                                         /*FIXME:*/E->getLocStart(),
4441                                         E->isParenTypeId(),
4442                                         AllocType,
4443                                         /*FIXME:*/E->getLocStart(),
4444                                         /*FIXME:*/SourceRange(),
4445                                         move(ArraySize),
4446                                         /*FIXME:*/E->getLocStart(),
4447                                         move_arg(ConstructorArgs),
4448                                         E->getLocEnd());
4449 }
4450
4451 template<typename Derived>
4452 Sema::OwningExprResult
4453 TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E,
4454                                                bool isAddressOfOperand) {
4455   OwningExprResult Operand = getDerived().TransformExpr(E->getArgument());
4456   if (Operand.isInvalid())
4457     return SemaRef.ExprError();
4458
4459   if (!getDerived().AlwaysRebuild() &&
4460       Operand.get() == E->getArgument())
4461     return SemaRef.Owned(E->Retain());
4462
4463   return getDerived().RebuildCXXDeleteExpr(E->getLocStart(),
4464                                            E->isGlobalDelete(),
4465                                            E->isArrayForm(),
4466                                            move(Operand));
4467 }
4468
4469 template<typename Derived>
4470 Sema::OwningExprResult
4471 TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
4472                                                      CXXPseudoDestructorExpr *E,
4473                                                      bool isAddressOfOperand) {
4474   OwningExprResult Base = getDerived().TransformExpr(E->getBase());
4475   if (Base.isInvalid())
4476     return SemaRef.ExprError();
4477
4478   NestedNameSpecifier *Qualifier
4479     = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
4480                                                 E->getQualifierRange());
4481   if (E->getQualifier() && !Qualifier)
4482     return SemaRef.ExprError();
4483
4484   QualType DestroyedType;
4485   {
4486     TemporaryBase Rebase(*this, E->getDestroyedTypeLoc(), DeclarationName());
4487     DestroyedType = getDerived().TransformType(E->getDestroyedType());
4488     if (DestroyedType.isNull())
4489       return SemaRef.ExprError();
4490   }
4491
4492   if (!getDerived().AlwaysRebuild() &&
4493       Base.get() == E->getBase() &&
4494       Qualifier == E->getQualifier() &&
4495       DestroyedType == E->getDestroyedType())
4496     return SemaRef.Owned(E->Retain());
4497
4498   return getDerived().RebuildCXXPseudoDestructorExpr(move(Base),
4499                                                      E->getOperatorLoc(),
4500                                                      E->isArrow(),
4501                                                      E->getDestroyedTypeLoc(),
4502                                                      DestroyedType,
4503                                                      Qualifier,
4504                                                      E->getQualifierRange());
4505 }
4506
4507 template<typename Derived>
4508 Sema::OwningExprResult
4509 TreeTransform<Derived>::TransformUnresolvedFunctionNameExpr(
4510                                                   UnresolvedFunctionNameExpr *E,
4511                                                   bool isAddressOfOperand) {
4512   // There is no transformation we can apply to an unresolved function name.
4513   return SemaRef.Owned(E->Retain());
4514 }
4515
4516 template<typename Derived>
4517 Sema::OwningExprResult
4518 TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E,
4519                                                     bool isAddressOfOperand) {
4520   TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName());
4521
4522   QualType T = getDerived().TransformType(E->getQueriedType());
4523   if (T.isNull())
4524     return SemaRef.ExprError();
4525
4526   if (!getDerived().AlwaysRebuild() &&
4527       T == E->getQueriedType())
4528     return SemaRef.Owned(E->Retain());
4529
4530   // FIXME: Bad location information
4531   SourceLocation FakeLParenLoc
4532     = SemaRef.PP.getLocForEndOfToken(E->getLocStart());
4533
4534   return getDerived().RebuildUnaryTypeTrait(E->getTrait(),
4535                                             E->getLocStart(),
4536                                             /*FIXME:*/FakeLParenLoc,
4537                                             T,
4538                                             E->getLocEnd());
4539 }
4540
4541 template<typename Derived>
4542 Sema::OwningExprResult
4543 TreeTransform<Derived>::TransformUnresolvedDeclRefExpr(
4544                                                      UnresolvedDeclRefExpr *E,
4545                                                      bool isAddressOfOperand) {
4546   NestedNameSpecifier *NNS
4547     = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
4548                                                 E->getQualifierRange());
4549   if (!NNS)
4550     return SemaRef.ExprError();
4551
4552   DeclarationName Name
4553     = getDerived().TransformDeclarationName(E->getDeclName(), E->getLocation());
4554   if (!Name)
4555     return SemaRef.ExprError();
4556
4557   if (!getDerived().AlwaysRebuild() &&
4558       NNS == E->getQualifier() &&
4559       Name == E->getDeclName())
4560     return SemaRef.Owned(E->Retain());
4561
4562   return getDerived().RebuildUnresolvedDeclRefExpr(NNS,
4563                                                    E->getQualifierRange(),
4564                                                    Name,
4565                                                    E->getLocation(),
4566                                                    isAddressOfOperand);
4567 }
4568
4569 template<typename Derived>
4570 Sema::OwningExprResult
4571 TreeTransform<Derived>::TransformTemplateIdRefExpr(TemplateIdRefExpr *E,
4572                                                    bool isAddressOfOperand) {
4573   TemporaryBase Rebase(*this, E->getTemplateNameLoc(), DeclarationName());
4574
4575   TemplateName Template
4576     = getDerived().TransformTemplateName(E->getTemplateName());
4577   if (Template.isNull())
4578     return SemaRef.ExprError();
4579
4580   NestedNameSpecifier *Qualifier = 0;
4581   if (E->getQualifier()) {
4582     Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
4583                                                       E->getQualifierRange());
4584     if (!Qualifier)
4585       return SemaRef.ExprError();
4586   }
4587
4588   llvm::SmallVector<TemplateArgumentLoc, 4> TransArgs(E->getNumTemplateArgs());
4589   for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
4590     if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I],
4591                                                TransArgs[I]))
4592       return SemaRef.ExprError();
4593   }
4594
4595   // FIXME: Would like to avoid rebuilding if nothing changed, but we can't
4596   // compare template arguments (yet).
4597
4598   // FIXME: It's possible that we'll find out now that the template name
4599   // actually refers to a type, in which case the caller is actually dealing
4600   // with a functional cast. Give a reasonable error message!
4601   return getDerived().RebuildTemplateIdExpr(Qualifier, E->getQualifierRange(),
4602                                             Template, E->getTemplateNameLoc(),
4603                                             E->getLAngleLoc(),
4604                                             TransArgs.data(),
4605                                             TransArgs.size(),
4606                                             E->getRAngleLoc());
4607 }
4608
4609 template<typename Derived>
4610 Sema::OwningExprResult
4611 TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E,
4612                                                   bool isAddressOfOperand) {
4613   TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName());
4614
4615   QualType T = getDerived().TransformType(E->getType());
4616   if (T.isNull())
4617     return SemaRef.ExprError();
4618
4619   CXXConstructorDecl *Constructor
4620     = cast_or_null<CXXConstructorDecl>(
4621                               getDerived().TransformDecl(E->getConstructor()));
4622   if (!Constructor)
4623     return SemaRef.ExprError();
4624
4625   bool ArgumentChanged = false;
4626   ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
4627   for (CXXConstructExpr::arg_iterator Arg = E->arg_begin(),
4628        ArgEnd = E->arg_end();
4629        Arg != ArgEnd; ++Arg) {
4630     OwningExprResult TransArg = getDerived().TransformExpr(*Arg);
4631     if (TransArg.isInvalid())
4632       return SemaRef.ExprError();
4633
4634     ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg;
4635     Args.push_back(TransArg.takeAs<Expr>());
4636   }
4637
4638   if (!getDerived().AlwaysRebuild() &&
4639       T == E->getType() &&
4640       Constructor == E->getConstructor() &&
4641       !ArgumentChanged)
4642     return SemaRef.Owned(E->Retain());
4643
4644   return getDerived().RebuildCXXConstructExpr(T, Constructor, E->isElidable(),
4645                                               move_arg(Args));
4646 }
4647
4648 /// \brief Transform a C++ temporary-binding expression.
4649 ///
4650 /// The transformation of a temporary-binding expression always attempts to
4651 /// bind a new temporary variable to its subexpression, even if the
4652 /// subexpression itself did not change, because the temporary variable itself
4653 /// must be unique.
4654 template<typename Derived>
4655 Sema::OwningExprResult
4656 TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E,
4657                                                       bool isAddressOfOperand) {
4658   OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
4659   if (SubExpr.isInvalid())
4660     return SemaRef.ExprError();
4661
4662   return SemaRef.MaybeBindToTemporary(SubExpr.takeAs<Expr>());
4663 }
4664
4665 /// \brief Transform a C++ expression that contains temporaries that should
4666 /// be destroyed after the expression is evaluated.
4667 ///
4668 /// The transformation of a full expression always attempts to build a new
4669 /// CXXExprWithTemporaries expression, even if the
4670 /// subexpression itself did not change, because it will need to capture the
4671 /// the new temporary variables introduced in the subexpression.
4672 template<typename Derived>
4673 Sema::OwningExprResult
4674 TreeTransform<Derived>::TransformCXXExprWithTemporaries(
4675                                                       CXXExprWithTemporaries *E,
4676                                                       bool isAddressOfOperand) {
4677   OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
4678   if (SubExpr.isInvalid())
4679     return SemaRef.ExprError();
4680
4681   return SemaRef.Owned(
4682            SemaRef.MaybeCreateCXXExprWithTemporaries(SubExpr.takeAs<Expr>(),
4683                                                E->shouldDestroyTemporaries()));
4684 }
4685
4686 template<typename Derived>
4687 Sema::OwningExprResult
4688 TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
4689                                                       CXXTemporaryObjectExpr *E,
4690                                                       bool isAddressOfOperand) {
4691   TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
4692   QualType T = getDerived().TransformType(E->getType());
4693   if (T.isNull())
4694     return SemaRef.ExprError();
4695
4696   CXXConstructorDecl *Constructor
4697     = cast_or_null<CXXConstructorDecl>(
4698                             getDerived().TransformDecl(E->getConstructor()));
4699   if (!Constructor)
4700     return SemaRef.ExprError();
4701
4702   bool ArgumentChanged = false;
4703   ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
4704   Args.reserve(E->getNumArgs());
4705   for (CXXTemporaryObjectExpr::arg_iterator Arg = E->arg_begin(),
4706                                          ArgEnd = E->arg_end();
4707        Arg != ArgEnd; ++Arg) {
4708     OwningExprResult TransArg = getDerived().TransformExpr(*Arg);
4709     if (TransArg.isInvalid())
4710       return SemaRef.ExprError();
4711
4712     ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg;
4713     Args.push_back((Expr *)TransArg.release());
4714   }
4715
4716   if (!getDerived().AlwaysRebuild() &&
4717       T == E->getType() &&
4718       Constructor == E->getConstructor() &&
4719       !ArgumentChanged)
4720     return SemaRef.Owned(E->Retain());
4721
4722   // FIXME: Bogus location information
4723   SourceLocation CommaLoc;
4724   if (Args.size() > 1) {
4725     Expr *First = (Expr *)Args[0];
4726     CommaLoc
4727       = SemaRef.PP.getLocForEndOfToken(First->getSourceRange().getEnd());
4728   }
4729   return getDerived().RebuildCXXTemporaryObjectExpr(E->getTypeBeginLoc(),
4730                                                     T,
4731                                                 /*FIXME:*/E->getTypeBeginLoc(),
4732                                                     move_arg(Args),
4733                                                     &CommaLoc,
4734                                                     E->getLocEnd());
4735 }
4736
4737 template<typename Derived>
4738 Sema::OwningExprResult
4739 TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
4740                                                   CXXUnresolvedConstructExpr *E,
4741                                                   bool isAddressOfOperand) {
4742   TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
4743   QualType T = getDerived().TransformType(E->getTypeAsWritten());
4744   if (T.isNull())
4745     return SemaRef.ExprError();
4746
4747   bool ArgumentChanged = false;
4748   ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
4749   llvm::SmallVector<SourceLocation, 8> FakeCommaLocs;
4750   for (CXXUnresolvedConstructExpr::arg_iterator Arg = E->arg_begin(),
4751                                              ArgEnd = E->arg_end();
4752        Arg != ArgEnd; ++Arg) {
4753     OwningExprResult TransArg = getDerived().TransformExpr(*Arg);
4754     if (TransArg.isInvalid())
4755       return SemaRef.ExprError();
4756
4757     ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg;
4758     FakeCommaLocs.push_back(
4759                         SemaRef.PP.getLocForEndOfToken((*Arg)->getLocEnd()));
4760     Args.push_back(TransArg.takeAs<Expr>());
4761   }
4762
4763   if (!getDerived().AlwaysRebuild() &&
4764       T == E->getTypeAsWritten() &&
4765       !ArgumentChanged)
4766     return SemaRef.Owned(E->Retain());
4767
4768   // FIXME: we're faking the locations of the commas
4769   return getDerived().RebuildCXXUnresolvedConstructExpr(E->getTypeBeginLoc(),
4770                                                         T,
4771                                                         E->getLParenLoc(),
4772                                                         move_arg(Args),
4773                                                         FakeCommaLocs.data(),
4774                                                         E->getRParenLoc());
4775 }
4776
4777 template<typename Derived>
4778 Sema::OwningExprResult
4779 TreeTransform<Derived>::TransformCXXUnresolvedMemberExpr(
4780                                                      CXXUnresolvedMemberExpr *E,
4781                                                      bool isAddressOfOperand) {
4782   // Transform the base of the expression.
4783   OwningExprResult Base = getDerived().TransformExpr(E->getBase());
4784   if (Base.isInvalid())
4785     return SemaRef.ExprError();
4786
4787   // Start the member reference and compute the object's type.
4788   Sema::TypeTy *ObjectType = 0;
4789   Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base),
4790                                               E->getOperatorLoc(),
4791                                       E->isArrow()? tok::arrow : tok::period,
4792                                               ObjectType);
4793   if (Base.isInvalid())
4794     return SemaRef.ExprError();
4795
4796   // Transform the first part of the nested-name-specifier that qualifies
4797   // the member name.
4798   NamedDecl *FirstQualifierInScope
4799     = getDerived().TransformFirstQualifierInScope(
4800                                           E->getFirstQualifierFoundInScope(),
4801                                           E->getQualifierRange().getBegin());
4802
4803   NestedNameSpecifier *Qualifier = 0;
4804   if (E->getQualifier()) {
4805     Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
4806                                                       E->getQualifierRange(),
4807                                       QualType::getFromOpaquePtr(ObjectType),
4808                                                         FirstQualifierInScope);
4809     if (!Qualifier)
4810       return SemaRef.ExprError();
4811   }
4812
4813   DeclarationName Name
4814     = getDerived().TransformDeclarationName(E->getMember(), E->getMemberLoc(),
4815                                        QualType::getFromOpaquePtr(ObjectType));
4816   if (!Name)
4817     return SemaRef.ExprError();
4818
4819   if (!E->hasExplicitTemplateArgumentList()) {
4820     // This is a reference to a member without an explicitly-specified
4821     // template argument list. Optimize for this common case.
4822     if (!getDerived().AlwaysRebuild() &&
4823         Base.get() == E->getBase() &&
4824         Qualifier == E->getQualifier() &&
4825         Name == E->getMember() &&
4826         FirstQualifierInScope == E->getFirstQualifierFoundInScope())
4827       return SemaRef.Owned(E->Retain());
4828
4829     return getDerived().RebuildCXXUnresolvedMemberExpr(move(Base),
4830                                                        E->isArrow(),
4831                                                        E->getOperatorLoc(),
4832                                                        Qualifier,
4833                                                        E->getQualifierRange(),
4834                                                        Name,
4835                                                        E->getMemberLoc(),
4836                                                        FirstQualifierInScope);
4837   }
4838
4839   // FIXME: This is an ugly hack, which forces the same template name to
4840   // be looked up multiple times. Yuck!
4841   TemporaryBase Rebase(*this, E->getMemberLoc(), DeclarationName());
4842   TemplateName OrigTemplateName;
4843   if (const IdentifierInfo *II = Name.getAsIdentifierInfo())
4844     OrigTemplateName = SemaRef.Context.getDependentTemplateName(0, II);
4845   else
4846     OrigTemplateName
4847       = SemaRef.Context.getDependentTemplateName(0,
4848                                                Name.getCXXOverloadedOperator());
4849
4850   TemplateName Template
4851     = getDerived().TransformTemplateName(OrigTemplateName,
4852                                        QualType::getFromOpaquePtr(ObjectType));
4853   if (Template.isNull())
4854     return SemaRef.ExprError();
4855
4856   llvm::SmallVector<TemplateArgumentLoc, 4> TransArgs(E->getNumTemplateArgs());
4857   for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
4858     if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I],
4859                                                TransArgs[I]))
4860       return SemaRef.ExprError();
4861   }
4862
4863   return getDerived().RebuildCXXUnresolvedMemberExpr(move(Base),
4864                                                      E->isArrow(),
4865                                                      E->getOperatorLoc(),
4866                                                      Qualifier,
4867                                                      E->getQualifierRange(),
4868                                                      Template,
4869                                                      E->getMemberLoc(),
4870                                                      FirstQualifierInScope,
4871                                                      E->getLAngleLoc(),
4872                                                      TransArgs.data(),
4873                                                      TransArgs.size(),
4874                                                      E->getRAngleLoc());
4875 }
4876
4877 template<typename Derived>
4878 Sema::OwningExprResult
4879 TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E,
4880                                                    bool isAddressOfOperand) {
4881   return SemaRef.Owned(E->Retain());
4882 }
4883
4884 template<typename Derived>
4885 Sema::OwningExprResult
4886 TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E,
4887                                                 bool isAddressOfOperand) {
4888   // FIXME: poor source location
4889   TemporaryBase Rebase(*this, E->getAtLoc(), DeclarationName());
4890   QualType EncodedType = getDerived().TransformType(E->getEncodedType());
4891   if (EncodedType.isNull())
4892     return SemaRef.ExprError();
4893
4894   if (!getDerived().AlwaysRebuild() &&
4895       EncodedType == E->getEncodedType())
4896     return SemaRef.Owned(E->Retain());
4897
4898   return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(),
4899                                             EncodedType,
4900                                             E->getRParenLoc());
4901 }
4902
4903 template<typename Derived>
4904 Sema::OwningExprResult
4905 TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E,
4906                                                  bool isAddressOfOperand) {
4907   // FIXME: Implement this!
4908   assert(false && "Cannot transform Objective-C expressions yet");
4909   return SemaRef.Owned(E->Retain());
4910 }
4911
4912 template<typename Derived>
4913 Sema::OwningExprResult
4914 TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E,
4915                                                   bool isAddressOfOperand) {
4916   return SemaRef.Owned(E->Retain());
4917 }
4918
4919 template<typename Derived>
4920 Sema::OwningExprResult
4921 TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E,
4922                                                   bool isAddressOfOperand) {
4923   ObjCProtocolDecl *Protocol
4924     = cast_or_null<ObjCProtocolDecl>(
4925                                 getDerived().TransformDecl(E->getProtocol()));
4926   if (!Protocol)
4927     return SemaRef.ExprError();
4928
4929   if (!getDerived().AlwaysRebuild() &&
4930       Protocol == E->getProtocol())
4931     return SemaRef.Owned(E->Retain());
4932
4933   return getDerived().RebuildObjCProtocolExpr(Protocol,
4934                                               E->getAtLoc(),
4935                                               /*FIXME:*/E->getAtLoc(),
4936                                               /*FIXME:*/E->getAtLoc(),
4937                                               E->getRParenLoc());
4938
4939 }
4940
4941 template<typename Derived>
4942 Sema::OwningExprResult
4943 TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E,
4944                                                  bool isAddressOfOperand) {
4945   // FIXME: Implement this!
4946   assert(false && "Cannot transform Objective-C expressions yet");
4947   return SemaRef.Owned(E->Retain());
4948 }
4949
4950 template<typename Derived>
4951 Sema::OwningExprResult
4952 TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E,
4953                                                      bool isAddressOfOperand) {
4954   // FIXME: Implement this!
4955   assert(false && "Cannot transform Objective-C expressions yet");
4956   return SemaRef.Owned(E->Retain());
4957 }
4958
4959 template<typename Derived>
4960 Sema::OwningExprResult
4961 TreeTransform<Derived>::TransformObjCImplicitSetterGetterRefExpr(
4962                                           ObjCImplicitSetterGetterRefExpr *E,
4963                                                      bool isAddressOfOperand) {
4964   // FIXME: Implement this!
4965   assert(false && "Cannot transform Objective-C expressions yet");
4966   return SemaRef.Owned(E->Retain());
4967 }
4968
4969 template<typename Derived>
4970 Sema::OwningExprResult
4971 TreeTransform<Derived>::TransformObjCSuperExpr(ObjCSuperExpr *E,
4972                                                bool isAddressOfOperand) {
4973   // FIXME: Implement this!
4974   assert(false && "Cannot transform Objective-C expressions yet");
4975   return SemaRef.Owned(E->Retain());
4976 }
4977
4978 template<typename Derived>
4979 Sema::OwningExprResult
4980 TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E,
4981                                              bool isAddressOfOperand) {
4982   // FIXME: Implement this!
4983   assert(false && "Cannot transform Objective-C expressions yet");
4984   return SemaRef.Owned(E->Retain());
4985 }
4986
4987 template<typename Derived>
4988 Sema::OwningExprResult
4989 TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E,
4990                                                    bool isAddressOfOperand) {
4991   bool ArgumentChanged = false;
4992   ASTOwningVector<&ActionBase::DeleteExpr> SubExprs(SemaRef);
4993   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) {
4994     OwningExprResult SubExpr = getDerived().TransformExpr(E->getExpr(I));
4995     if (SubExpr.isInvalid())
4996       return SemaRef.ExprError();
4997
4998     ArgumentChanged = ArgumentChanged || SubExpr.get() != E->getExpr(I);
4999     SubExprs.push_back(SubExpr.takeAs<Expr>());
5000   }
5001
5002   if (!getDerived().AlwaysRebuild() &&
5003       !ArgumentChanged)
5004     return SemaRef.Owned(E->Retain());
5005
5006   return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(),
5007                                                move_arg(SubExprs),
5008                                                E->getRParenLoc());
5009 }
5010
5011 template<typename Derived>
5012 Sema::OwningExprResult
5013 TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E,
5014                                            bool isAddressOfOperand) {
5015   // FIXME: Implement this!
5016   assert(false && "Cannot transform block expressions yet");
5017   return SemaRef.Owned(E->Retain());
5018 }
5019
5020 template<typename Derived>
5021 Sema::OwningExprResult
5022 TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E,
5023                                                   bool isAddressOfOperand) {
5024   // FIXME: Implement this!
5025   assert(false && "Cannot transform block-related expressions yet");
5026   return SemaRef.Owned(E->Retain());
5027 }
5028
5029 //===----------------------------------------------------------------------===//
5030 // Type reconstruction
5031 //===----------------------------------------------------------------------===//
5032
5033 template<typename Derived>
5034 QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType,
5035                                                     SourceLocation Star) {
5036   return SemaRef.BuildPointerType(PointeeType, Qualifiers(), Star,
5037                                   getDerived().getBaseEntity());
5038 }
5039
5040 template<typename Derived>
5041 QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType,
5042                                                          SourceLocation Star) {
5043   return SemaRef.BuildBlockPointerType(PointeeType, Qualifiers(), Star,
5044                                        getDerived().getBaseEntity());
5045 }
5046
5047 template<typename Derived>
5048 QualType
5049 TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType,
5050                                              bool WrittenAsLValue,
5051                                              SourceLocation Sigil) {
5052   return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, Qualifiers(),
5053                                     Sigil, getDerived().getBaseEntity());
5054 }
5055
5056 template<typename Derived>
5057 QualType
5058 TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType,
5059                                                  QualType ClassType,
5060                                                  SourceLocation Sigil) {
5061   return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Qualifiers(),
5062                                         Sigil, getDerived().getBaseEntity());
5063 }
5064
5065 template<typename Derived>
5066 QualType
5067 TreeTransform<Derived>::RebuildObjCObjectPointerType(QualType PointeeType,
5068                                                      SourceLocation Sigil) {
5069   return SemaRef.BuildPointerType(PointeeType, Qualifiers(), Sigil,
5070                                   getDerived().getBaseEntity());
5071 }
5072
5073 template<typename Derived>
5074 QualType
5075 TreeTransform<Derived>::RebuildArrayType(QualType ElementType,
5076                                          ArrayType::ArraySizeModifier SizeMod,
5077                                          const llvm::APInt *Size,
5078                                          Expr *SizeExpr,
5079                                          unsigned IndexTypeQuals,
5080                                          SourceRange BracketsRange) {
5081   if (SizeExpr || !Size)
5082     return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr,
5083                                   IndexTypeQuals, BracketsRange,
5084                                   getDerived().getBaseEntity());
5085
5086   QualType Types[] = {
5087     SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy,
5088     SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy,
5089     SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty
5090   };
5091   const unsigned NumTypes = sizeof(Types) / sizeof(QualType);
5092   QualType SizeType;
5093   for (unsigned I = 0; I != NumTypes; ++I)
5094     if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) {
5095       SizeType = Types[I];
5096       break;
5097     }
5098
5099   if (SizeType.isNull())
5100     SizeType = SemaRef.Context.getFixedWidthIntType(Size->getBitWidth(), false);
5101
5102   IntegerLiteral ArraySize(*Size, SizeType, /*FIXME*/BracketsRange.getBegin());
5103   return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize,
5104                                 IndexTypeQuals, BracketsRange,
5105                                 getDerived().getBaseEntity());
5106 }
5107
5108 template<typename Derived>
5109 QualType
5110 TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType,
5111                                                  ArrayType::ArraySizeModifier SizeMod,
5112                                                  const llvm::APInt &Size,
5113                                                  unsigned IndexTypeQuals,
5114                                                  SourceRange BracketsRange) {
5115   return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0,
5116                                         IndexTypeQuals, BracketsRange);
5117 }
5118
5119 template<typename Derived>
5120 QualType
5121 TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType,
5122                                           ArrayType::ArraySizeModifier SizeMod,
5123                                                  unsigned IndexTypeQuals,
5124                                                    SourceRange BracketsRange) {
5125   return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0,
5126                                        IndexTypeQuals, BracketsRange);
5127 }
5128
5129 template<typename Derived>
5130 QualType
5131 TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType,
5132                                           ArrayType::ArraySizeModifier SizeMod,
5133                                                  ExprArg SizeExpr,
5134                                                  unsigned IndexTypeQuals,
5135                                                  SourceRange BracketsRange) {
5136   return getDerived().RebuildArrayType(ElementType, SizeMod, 0,
5137                                        SizeExpr.takeAs<Expr>(),
5138                                        IndexTypeQuals, BracketsRange);
5139 }
5140
5141 template<typename Derived>
5142 QualType
5143 TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType,
5144                                           ArrayType::ArraySizeModifier SizeMod,
5145                                                        ExprArg SizeExpr,
5146                                                        unsigned IndexTypeQuals,
5147                                                    SourceRange BracketsRange) {
5148   return getDerived().RebuildArrayType(ElementType, SizeMod, 0,
5149                                        SizeExpr.takeAs<Expr>(),
5150                                        IndexTypeQuals, BracketsRange);
5151 }
5152
5153 template<typename Derived>
5154 QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType,
5155                                                    unsigned NumElements) {
5156   // FIXME: semantic checking!
5157   return SemaRef.Context.getVectorType(ElementType, NumElements);
5158 }
5159
5160 template<typename Derived>
5161 QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType,
5162                                                       unsigned NumElements,
5163                                                  SourceLocation AttributeLoc) {
5164   llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
5165                           NumElements, true);
5166   IntegerLiteral *VectorSize
5167     = new (SemaRef.Context) IntegerLiteral(numElements, SemaRef.Context.IntTy,
5168                                            AttributeLoc);
5169   return SemaRef.BuildExtVectorType(ElementType, SemaRef.Owned(VectorSize),
5170                                     AttributeLoc);
5171 }
5172
5173 template<typename Derived>
5174 QualType
5175 TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType,
5176                                                            ExprArg SizeExpr,
5177                                                   SourceLocation AttributeLoc) {
5178   return SemaRef.BuildExtVectorType(ElementType, move(SizeExpr), AttributeLoc);
5179 }
5180
5181 template<typename Derived>
5182 QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T,
5183                                                           QualType *ParamTypes,
5184                                                         unsigned NumParamTypes,
5185                                                           bool Variadic,
5186                                                           unsigned Quals) {
5187   return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic,
5188                                    Quals,
5189                                    getDerived().getBaseLocation(),
5190                                    getDerived().getBaseEntity());
5191 }
5192
5193 template<typename Derived>
5194 QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) {
5195   return SemaRef.Context.getFunctionNoProtoType(T);
5196 }
5197
5198 template<typename Derived>
5199 QualType TreeTransform<Derived>::RebuildTypeOfExprType(ExprArg E) {
5200   return SemaRef.BuildTypeofExprType(E.takeAs<Expr>());
5201 }
5202
5203 template<typename Derived>
5204 QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) {
5205   return SemaRef.Context.getTypeOfType(Underlying);
5206 }
5207
5208 template<typename Derived>
5209 QualType TreeTransform<Derived>::RebuildDecltypeType(ExprArg E) {
5210   return SemaRef.BuildDecltypeType(E.takeAs<Expr>());
5211 }
5212
5213 template<typename Derived>
5214 QualType TreeTransform<Derived>::RebuildTemplateSpecializationType(
5215                                                       TemplateName Template,
5216                                              SourceLocation TemplateNameLoc,
5217                                                    SourceLocation LAngleLoc,
5218                                             const TemplateArgumentLoc *Args,
5219                                                            unsigned NumArgs,
5220                                                    SourceLocation RAngleLoc) {
5221   return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, LAngleLoc,
5222                                      Args, NumArgs, RAngleLoc);
5223 }
5224
5225 template<typename Derived>
5226 NestedNameSpecifier *
5227 TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
5228                                                    SourceRange Range,
5229                                                    IdentifierInfo &II,
5230                                                    QualType ObjectType,
5231                                              NamedDecl *FirstQualifierInScope) {
5232   CXXScopeSpec SS;
5233   // FIXME: The source location information is all wrong.
5234   SS.setRange(Range);
5235   SS.setScopeRep(Prefix);
5236   return static_cast<NestedNameSpecifier *>(
5237                     SemaRef.BuildCXXNestedNameSpecifier(0, SS, Range.getEnd(),
5238                                                         Range.getEnd(), II,
5239                                                         ObjectType,
5240                                                         FirstQualifierInScope,
5241                                                         false));
5242 }
5243
5244 template<typename Derived>
5245 NestedNameSpecifier *
5246 TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
5247                                                    SourceRange Range,
5248                                                    NamespaceDecl *NS) {
5249   return NestedNameSpecifier::Create(SemaRef.Context, Prefix, NS);
5250 }
5251
5252 template<typename Derived>
5253 NestedNameSpecifier *
5254 TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
5255                                                    SourceRange Range,
5256                                                    bool TemplateKW,
5257                                                    QualType T) {
5258   if (T->isDependentType() || T->isRecordType() ||
5259       (SemaRef.getLangOptions().CPlusPlus0x && T->isEnumeralType())) {
5260     assert(!T.hasQualifiers() && "Can't get cv-qualifiers here");
5261     return NestedNameSpecifier::Create(SemaRef.Context, Prefix, TemplateKW,
5262                                        T.getTypePtr());
5263   }
5264
5265   SemaRef.Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T;
5266   return 0;
5267 }
5268
5269 template<typename Derived>
5270 TemplateName
5271 TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier,
5272                                             bool TemplateKW,
5273                                             TemplateDecl *Template) {
5274   return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW,
5275                                                   Template);
5276 }
5277
5278 template<typename Derived>
5279 TemplateName
5280 TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier,
5281                                             bool TemplateKW,
5282                                             OverloadedFunctionDecl *Ovl) {
5283   return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, Ovl);
5284 }
5285
5286 template<typename Derived>
5287 TemplateName
5288 TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier,
5289                                             const IdentifierInfo &II,
5290                                             QualType ObjectType) {
5291   CXXScopeSpec SS;
5292   SS.setRange(SourceRange(getDerived().getBaseLocation()));
5293   SS.setScopeRep(Qualifier);
5294   UnqualifiedId Name;
5295   Name.setIdentifier(&II, /*FIXME:*/getDerived().getBaseLocation());
5296   return getSema().ActOnDependentTemplateName(
5297                                       /*FIXME:*/getDerived().getBaseLocation(),
5298                                               SS,
5299                                               Name,
5300                                               ObjectType.getAsOpaquePtr())
5301            .template getAsVal<TemplateName>();
5302 }
5303
5304 template<typename Derived>
5305 TemplateName
5306 TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier,
5307                                             OverloadedOperatorKind Operator,
5308                                             QualType ObjectType) {
5309   CXXScopeSpec SS;
5310   SS.setRange(SourceRange(getDerived().getBaseLocation()));
5311   SS.setScopeRep(Qualifier);
5312   UnqualifiedId Name;
5313   SourceLocation SymbolLocations[3]; // FIXME: Bogus location information.
5314   Name.setOperatorFunctionId(/*FIXME:*/getDerived().getBaseLocation(),
5315                              Operator, SymbolLocations);
5316   return getSema().ActOnDependentTemplateName(
5317                                        /*FIXME:*/getDerived().getBaseLocation(),
5318                                               SS,
5319                                               Name,
5320                                               ObjectType.getAsOpaquePtr())
5321            .template getAsVal<TemplateName>();
5322 }
5323
5324 template<typename Derived>
5325 Sema::OwningExprResult
5326 TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
5327                                                    SourceLocation OpLoc,
5328                                                    ExprArg Callee,
5329                                                    ExprArg First,
5330                                                    ExprArg Second) {
5331   Expr *FirstExpr = (Expr *)First.get();
5332   Expr *SecondExpr = (Expr *)Second.get();
5333   DeclRefExpr *DRE
5334     = cast<DeclRefExpr>(((Expr *)Callee.get())->IgnoreParenCasts());
5335   bool isPostIncDec = SecondExpr && (Op == OO_PlusPlus || Op == OO_MinusMinus);
5336
5337   // Determine whether this should be a builtin operation.
5338   if (Op == OO_Subscript) {
5339     if (!FirstExpr->getType()->isOverloadableType() &&
5340         !SecondExpr->getType()->isOverloadableType())
5341       return getSema().CreateBuiltinArraySubscriptExpr(move(First),
5342                                                        DRE->getLocStart(),
5343                                                        move(Second), OpLoc);
5344   } else if (SecondExpr == 0 || isPostIncDec) {
5345     if (!FirstExpr->getType()->isOverloadableType()) {
5346       // The argument is not of overloadable type, so try to create a
5347       // built-in unary operation.
5348       UnaryOperator::Opcode Opc
5349         = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
5350
5351       return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, move(First));
5352     }
5353   } else {
5354     if (!FirstExpr->getType()->isOverloadableType() &&
5355         !SecondExpr->getType()->isOverloadableType()) {
5356       // Neither of the arguments is an overloadable type, so try to
5357       // create a built-in binary operation.
5358       BinaryOperator::Opcode Opc = BinaryOperator::getOverloadedOpcode(Op);
5359       OwningExprResult Result
5360         = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, FirstExpr, SecondExpr);
5361       if (Result.isInvalid())
5362         return SemaRef.ExprError();
5363
5364       First.release();
5365       Second.release();
5366       return move(Result);
5367     }
5368   }
5369
5370   // Compute the transformed set of functions (and function templates) to be
5371   // used during overload resolution.
5372   Sema::FunctionSet Functions;
5373
5374   // FIXME: Do we have to check
5375   // IsAcceptableNonMemberOperatorCandidate for each of these?
5376   for (OverloadIterator F(DRE->getDecl()), FEnd; F != FEnd; ++F)
5377     Functions.insert(*F);
5378
5379   // Add any functions found via argument-dependent lookup.
5380   Expr *Args[2] = { FirstExpr, SecondExpr };
5381   unsigned NumArgs = 1 + (SecondExpr != 0);
5382   DeclarationName OpName
5383     = SemaRef.Context.DeclarationNames.getCXXOperatorName(Op);
5384   SemaRef.ArgumentDependentLookup(OpName, /*Operator*/true, Args, NumArgs,
5385                                   Functions);
5386
5387   // Create the overloaded operator invocation for unary operators.
5388   if (NumArgs == 1 || isPostIncDec) {
5389     UnaryOperator::Opcode Opc
5390       = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
5391     return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(First));
5392   }
5393
5394   if (Op == OO_Subscript)
5395     return SemaRef.CreateOverloadedArraySubscriptExpr(DRE->getLocStart(), OpLoc,
5396                                                       move(First),move(Second));
5397
5398   // Create the overloaded operator invocation for binary operators.
5399   BinaryOperator::Opcode Opc =
5400     BinaryOperator::getOverloadedOpcode(Op);
5401   OwningExprResult Result
5402     = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]);
5403   if (Result.isInvalid())
5404     return SemaRef.ExprError();
5405
5406   First.release();
5407   Second.release();
5408   return move(Result);
5409 }
5410
5411 } // end namespace clang
5412
5413 #endif // LLVM_CLANG_SEMA_TREETRANSFORM_H