Removed unused LParenLoc parameter to ActOnCXXForRangeStmt
[lldb.git] / clang / 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
14 #ifndef LLVM_CLANG_SEMA_TREETRANSFORM_H
15 #define LLVM_CLANG_SEMA_TREETRANSFORM_H
16
17 #include "clang/Sema/SemaInternal.h"
18 #include "clang/Sema/Lookup.h"
19 #include "clang/Sema/ParsedTemplate.h"
20 #include "clang/Sema/SemaDiagnostic.h"
21 #include "clang/Sema/ScopeInfo.h"
22 #include "clang/AST/Decl.h"
23 #include "clang/AST/DeclObjC.h"
24 #include "clang/AST/DeclTemplate.h"
25 #include "clang/AST/Expr.h"
26 #include "clang/AST/ExprCXX.h"
27 #include "clang/AST/ExprObjC.h"
28 #include "clang/AST/Stmt.h"
29 #include "clang/AST/StmtCXX.h"
30 #include "clang/AST/StmtObjC.h"
31 #include "clang/Sema/Ownership.h"
32 #include "clang/Sema/Designator.h"
33 #include "clang/Lex/Preprocessor.h"
34 #include "llvm/ADT/ArrayRef.h"
35 #include "llvm/Support/ErrorHandling.h"
36 #include "TypeLocBuilder.h"
37 #include <algorithm>
38
39 namespace clang {
40 using namespace sema;
41
42 /// \brief A semantic tree transformation that allows one to transform one
43 /// abstract syntax tree into another.
44 ///
45 /// A new tree transformation is defined by creating a new subclass \c X of
46 /// \c TreeTransform<X> and then overriding certain operations to provide
47 /// behavior specific to that transformation. For example, template
48 /// instantiation is implemented as a tree transformation where the
49 /// transformation of TemplateTypeParmType nodes involves substituting the
50 /// template arguments for their corresponding template parameters; a similar
51 /// transformation is performed for non-type template parameters and
52 /// template template parameters.
53 ///
54 /// This tree-transformation template uses static polymorphism to allow
55 /// subclasses to customize any of its operations. Thus, a subclass can
56 /// override any of the transformation or rebuild operators by providing an
57 /// operation with the same signature as the default implementation. The
58 /// overridding function should not be virtual.
59 ///
60 /// Semantic tree transformations are split into two stages, either of which
61 /// can be replaced by a subclass. The "transform" step transforms an AST node
62 /// or the parts of an AST node using the various transformation functions,
63 /// then passes the pieces on to the "rebuild" step, which constructs a new AST
64 /// node of the appropriate kind from the pieces. The default transformation
65 /// routines recursively transform the operands to composite AST nodes (e.g.,
66 /// the pointee type of a PointerType node) and, if any of those operand nodes
67 /// were changed by the transformation, invokes the rebuild operation to create
68 /// a new AST node.
69 ///
70 /// Subclasses can customize the transformation at various levels. The
71 /// most coarse-grained transformations involve replacing TransformType(),
72 /// TransformExpr(), TransformDecl(), TransformNestedNameSpecifierLoc(),
73 /// TransformTemplateName(), or TransformTemplateArgument() with entirely
74 /// new implementations.
75 ///
76 /// For more fine-grained transformations, subclasses can replace any of the
77 /// \c TransformXXX functions (where XXX is the name of an AST node, e.g.,
78 /// PointerType, StmtExpr) to alter the transformation. As mentioned previously,
79 /// replacing TransformTemplateTypeParmType() allows template instantiation
80 /// to substitute template arguments for their corresponding template
81 /// parameters. Additionally, subclasses can override the \c RebuildXXX
82 /// functions to control how AST nodes are rebuilt when their operands change.
83 /// By default, \c TreeTransform will invoke semantic analysis to rebuild
84 /// AST nodes. However, certain other tree transformations (e.g, cloning) may
85 /// be able to use more efficient rebuild steps.
86 ///
87 /// There are a handful of other functions that can be overridden, allowing one
88 /// to avoid traversing nodes that don't need any transformation
89 /// (\c AlreadyTransformed()), force rebuilding AST nodes even when their
90 /// operands have not changed (\c AlwaysRebuild()), and customize the
91 /// default locations and entity names used for type-checking
92 /// (\c getBaseLocation(), \c getBaseEntity()).
93 template<typename Derived>
94 class TreeTransform {
95   /// \brief Private RAII object that helps us forget and then re-remember
96   /// the template argument corresponding to a partially-substituted parameter
97   /// pack.
98   class ForgetPartiallySubstitutedPackRAII {
99     Derived &Self;
100     TemplateArgument Old;
101
102   public:
103     ForgetPartiallySubstitutedPackRAII(Derived &Self) : Self(Self) {
104       Old = Self.ForgetPartiallySubstitutedPack();
105     }
106
107     ~ForgetPartiallySubstitutedPackRAII() {
108       Self.RememberPartiallySubstitutedPack(Old);
109     }
110   };
111
112 protected:
113   Sema &SemaRef;
114
115   /// \brief The set of local declarations that have been transformed, for
116   /// cases where we are forced to build new declarations within the transformer
117   /// rather than in the subclass (e.g., lambda closure types).
118   llvm::DenseMap<Decl *, Decl *> TransformedLocalDecls;
119
120 public:
121   /// \brief Initializes a new tree transformer.
122   TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { }
123
124   /// \brief Retrieves a reference to the derived class.
125   Derived &getDerived() { return static_cast<Derived&>(*this); }
126
127   /// \brief Retrieves a reference to the derived class.
128   const Derived &getDerived() const {
129     return static_cast<const Derived&>(*this);
130   }
131
132   static inline ExprResult Owned(Expr *E) { return E; }
133   static inline StmtResult Owned(Stmt *S) { return S; }
134
135   /// \brief Retrieves a reference to the semantic analysis object used for
136   /// this tree transform.
137   Sema &getSema() const { return SemaRef; }
138
139   /// \brief Whether the transformation should always rebuild AST nodes, even
140   /// if none of the children have changed.
141   ///
142   /// Subclasses may override this function to specify when the transformation
143   /// should rebuild all AST nodes.
144   bool AlwaysRebuild() { return false; }
145
146   /// \brief Returns the location of the entity being transformed, if that
147   /// information was not available elsewhere in the AST.
148   ///
149   /// By default, returns no source-location information. Subclasses can
150   /// provide an alternative implementation that provides better location
151   /// information.
152   SourceLocation getBaseLocation() { return SourceLocation(); }
153
154   /// \brief Returns the name of the entity being transformed, if that
155   /// information was not available elsewhere in the AST.
156   ///
157   /// By default, returns an empty name. Subclasses can provide an alternative
158   /// implementation with a more precise name.
159   DeclarationName getBaseEntity() { return DeclarationName(); }
160
161   /// \brief Sets the "base" location and entity when that
162   /// information is known based on another transformation.
163   ///
164   /// By default, the source location and entity are ignored. Subclasses can
165   /// override this function to provide a customized implementation.
166   void setBase(SourceLocation Loc, DeclarationName Entity) { }
167
168   /// \brief RAII object that temporarily sets the base location and entity
169   /// used for reporting diagnostics in types.
170   class TemporaryBase {
171     TreeTransform &Self;
172     SourceLocation OldLocation;
173     DeclarationName OldEntity;
174
175   public:
176     TemporaryBase(TreeTransform &Self, SourceLocation Location,
177                   DeclarationName Entity) : Self(Self) {
178       OldLocation = Self.getDerived().getBaseLocation();
179       OldEntity = Self.getDerived().getBaseEntity();
180
181       if (Location.isValid())
182         Self.getDerived().setBase(Location, Entity);
183     }
184
185     ~TemporaryBase() {
186       Self.getDerived().setBase(OldLocation, OldEntity);
187     }
188   };
189
190   /// \brief Determine whether the given type \p T has already been
191   /// transformed.
192   ///
193   /// Subclasses can provide an alternative implementation of this routine
194   /// to short-circuit evaluation when it is known that a given type will
195   /// not change. For example, template instantiation need not traverse
196   /// non-dependent types.
197   bool AlreadyTransformed(QualType T) {
198     return T.isNull();
199   }
200
201   /// \brief Determine whether the given call argument should be dropped, e.g.,
202   /// because it is a default argument.
203   ///
204   /// Subclasses can provide an alternative implementation of this routine to
205   /// determine which kinds of call arguments get dropped. By default,
206   /// CXXDefaultArgument nodes are dropped (prior to transformation).
207   bool DropCallArgument(Expr *E) {
208     return E->isDefaultArgument();
209   }
210
211   /// \brief Determine whether we should expand a pack expansion with the
212   /// given set of parameter packs into separate arguments by repeatedly
213   /// transforming the pattern.
214   ///
215   /// By default, the transformer never tries to expand pack expansions.
216   /// Subclasses can override this routine to provide different behavior.
217   ///
218   /// \param EllipsisLoc The location of the ellipsis that identifies the
219   /// pack expansion.
220   ///
221   /// \param PatternRange The source range that covers the entire pattern of
222   /// the pack expansion.
223   ///
224   /// \param Unexpanded The set of unexpanded parameter packs within the
225   /// pattern.
226   ///
227   /// \param ShouldExpand Will be set to \c true if the transformer should
228   /// expand the corresponding pack expansions into separate arguments. When
229   /// set, \c NumExpansions must also be set.
230   ///
231   /// \param RetainExpansion Whether the caller should add an unexpanded
232   /// pack expansion after all of the expanded arguments. This is used
233   /// when extending explicitly-specified template argument packs per
234   /// C++0x [temp.arg.explicit]p9.
235   ///
236   /// \param NumExpansions The number of separate arguments that will be in
237   /// the expanded form of the corresponding pack expansion. This is both an
238   /// input and an output parameter, which can be set by the caller if the
239   /// number of expansions is known a priori (e.g., due to a prior substitution)
240   /// and will be set by the callee when the number of expansions is known.
241   /// The callee must set this value when \c ShouldExpand is \c true; it may
242   /// set this value in other cases.
243   ///
244   /// \returns true if an error occurred (e.g., because the parameter packs
245   /// are to be instantiated with arguments of different lengths), false
246   /// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions)
247   /// must be set.
248   bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
249                                SourceRange PatternRange,
250                              llvm::ArrayRef<UnexpandedParameterPack> Unexpanded,
251                                bool &ShouldExpand,
252                                bool &RetainExpansion,
253                                llvm::Optional<unsigned> &NumExpansions) {
254     ShouldExpand = false;
255     return false;
256   }
257
258   /// \brief "Forget" about the partially-substituted pack template argument,
259   /// when performing an instantiation that must preserve the parameter pack
260   /// use.
261   ///
262   /// This routine is meant to be overridden by the template instantiator.
263   TemplateArgument ForgetPartiallySubstitutedPack() {
264     return TemplateArgument();
265   }
266
267   /// \brief "Remember" the partially-substituted pack template argument
268   /// after performing an instantiation that must preserve the parameter pack
269   /// use.
270   ///
271   /// This routine is meant to be overridden by the template instantiator.
272   void RememberPartiallySubstitutedPack(TemplateArgument Arg) { }
273
274   /// \brief Note to the derived class when a function parameter pack is
275   /// being expanded.
276   void ExpandingFunctionParameterPack(ParmVarDecl *Pack) { }
277
278   /// \brief Transforms the given type into another type.
279   ///
280   /// By default, this routine transforms a type by creating a
281   /// TypeSourceInfo for it and delegating to the appropriate
282   /// function.  This is expensive, but we don't mind, because
283   /// this method is deprecated anyway;  all users should be
284   /// switched to storing TypeSourceInfos.
285   ///
286   /// \returns the transformed type.
287   QualType TransformType(QualType T);
288
289   /// \brief Transforms the given type-with-location into a new
290   /// type-with-location.
291   ///
292   /// By default, this routine transforms a type by delegating to the
293   /// appropriate TransformXXXType to build a new type.  Subclasses
294   /// may override this function (to take over all type
295   /// transformations) or some set of the TransformXXXType functions
296   /// to alter the transformation.
297   TypeSourceInfo *TransformType(TypeSourceInfo *DI);
298
299   /// \brief Transform the given type-with-location into a new
300   /// type, collecting location information in the given builder
301   /// as necessary.
302   ///
303   QualType TransformType(TypeLocBuilder &TLB, TypeLoc TL);
304
305   /// \brief Transform the given statement.
306   ///
307   /// By default, this routine transforms a statement by delegating to the
308   /// appropriate TransformXXXStmt function to transform a specific kind of
309   /// statement or the TransformExpr() function to transform an expression.
310   /// Subclasses may override this function to transform statements using some
311   /// other mechanism.
312   ///
313   /// \returns the transformed statement.
314   StmtResult TransformStmt(Stmt *S);
315
316   /// \brief Transform the given expression.
317   ///
318   /// By default, this routine transforms an expression by delegating to the
319   /// appropriate TransformXXXExpr function to build a new expression.
320   /// Subclasses may override this function to transform expressions using some
321   /// other mechanism.
322   ///
323   /// \returns the transformed expression.
324   ExprResult TransformExpr(Expr *E);
325
326   /// \brief Transform the given list of expressions.
327   ///
328   /// This routine transforms a list of expressions by invoking
329   /// \c TransformExpr() for each subexpression. However, it also provides
330   /// support for variadic templates by expanding any pack expansions (if the
331   /// derived class permits such expansion) along the way. When pack expansions
332   /// are present, the number of outputs may not equal the number of inputs.
333   ///
334   /// \param Inputs The set of expressions to be transformed.
335   ///
336   /// \param NumInputs The number of expressions in \c Inputs.
337   ///
338   /// \param IsCall If \c true, then this transform is being performed on
339   /// function-call arguments, and any arguments that should be dropped, will
340   /// be.
341   ///
342   /// \param Outputs The transformed input expressions will be added to this
343   /// vector.
344   ///
345   /// \param ArgChanged If non-NULL, will be set \c true if any argument changed
346   /// due to transformation.
347   ///
348   /// \returns true if an error occurred, false otherwise.
349   bool TransformExprs(Expr **Inputs, unsigned NumInputs, bool IsCall,
350                       SmallVectorImpl<Expr *> &Outputs,
351                       bool *ArgChanged = 0);
352
353   /// \brief Transform the given declaration, which is referenced from a type
354   /// or expression.
355   ///
356   /// By default, acts as the identity function on declarations, unless the
357   /// transformer has had to transform the declaration itself. Subclasses
358   /// may override this function to provide alternate behavior.
359   Decl *TransformDecl(SourceLocation Loc, Decl *D) {
360     llvm::DenseMap<Decl *, Decl *>::iterator Known
361       = TransformedLocalDecls.find(D);
362     if (Known != TransformedLocalDecls.end())
363       return Known->second;
364
365     return D;
366   }
367
368   /// \brief Transform the attributes associated with the given declaration and
369   /// place them on the new declaration.
370   ///
371   /// By default, this operation does nothing. Subclasses may override this
372   /// behavior to transform attributes.
373   void transformAttrs(Decl *Old, Decl *New) { }
374
375   /// \brief Note that a local declaration has been transformed by this
376   /// transformer.
377   ///
378   /// Local declarations are typically transformed via a call to
379   /// TransformDefinition. However, in some cases (e.g., lambda expressions),
380   /// the transformer itself has to transform the declarations. This routine
381   /// can be overridden by a subclass that keeps track of such mappings.
382   void transformedLocalDecl(Decl *Old, Decl *New) {
383     TransformedLocalDecls[Old] = New;
384   }
385
386   /// \brief Transform the definition of the given declaration.
387   ///
388   /// By default, invokes TransformDecl() to transform the declaration.
389   /// Subclasses may override this function to provide alternate behavior.
390   Decl *TransformDefinition(SourceLocation Loc, Decl *D) {
391     return getDerived().TransformDecl(Loc, D);
392   }
393
394   /// \brief Transform the given declaration, which was the first part of a
395   /// nested-name-specifier in a member access expression.
396   ///
397   /// This specific declaration transformation only applies to the first
398   /// identifier in a nested-name-specifier of a member access expression, e.g.,
399   /// the \c T in \c x->T::member
400   ///
401   /// By default, invokes TransformDecl() to transform the declaration.
402   /// Subclasses may override this function to provide alternate behavior.
403   NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc) {
404     return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D));
405   }
406
407   /// \brief Transform the given nested-name-specifier with source-location
408   /// information.
409   ///
410   /// By default, transforms all of the types and declarations within the
411   /// nested-name-specifier. Subclasses may override this function to provide
412   /// alternate behavior.
413   NestedNameSpecifierLoc TransformNestedNameSpecifierLoc(
414                                                     NestedNameSpecifierLoc NNS,
415                                           QualType ObjectType = QualType(),
416                                           NamedDecl *FirstQualifierInScope = 0);
417
418   /// \brief Transform the given declaration name.
419   ///
420   /// By default, transforms the types of conversion function, constructor,
421   /// and destructor names and then (if needed) rebuilds the declaration name.
422   /// Identifiers and selectors are returned unmodified. Sublcasses may
423   /// override this function to provide alternate behavior.
424   DeclarationNameInfo
425   TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo);
426
427   /// \brief Transform the given template name.
428   ///
429   /// \param SS The nested-name-specifier that qualifies the template
430   /// name. This nested-name-specifier must already have been transformed.
431   ///
432   /// \param Name The template name to transform.
433   ///
434   /// \param NameLoc The source location of the template name.
435   ///
436   /// \param ObjectType If we're translating a template name within a member
437   /// access expression, this is the type of the object whose member template
438   /// is being referenced.
439   ///
440   /// \param FirstQualifierInScope If the first part of a nested-name-specifier
441   /// also refers to a name within the current (lexical) scope, this is the
442   /// declaration it refers to.
443   ///
444   /// By default, transforms the template name by transforming the declarations
445   /// and nested-name-specifiers that occur within the template name.
446   /// Subclasses may override this function to provide alternate behavior.
447   TemplateName TransformTemplateName(CXXScopeSpec &SS,
448                                      TemplateName Name,
449                                      SourceLocation NameLoc,
450                                      QualType ObjectType = QualType(),
451                                      NamedDecl *FirstQualifierInScope = 0);
452
453   /// \brief Transform the given template argument.
454   ///
455   /// By default, this operation transforms the type, expression, or
456   /// declaration stored within the template argument and constructs a
457   /// new template argument from the transformed result. Subclasses may
458   /// override this function to provide alternate behavior.
459   ///
460   /// Returns true if there was an error.
461   bool TransformTemplateArgument(const TemplateArgumentLoc &Input,
462                                  TemplateArgumentLoc &Output);
463
464   /// \brief Transform the given set of template arguments.
465   ///
466   /// By default, this operation transforms all of the template arguments
467   /// in the input set using \c TransformTemplateArgument(), and appends
468   /// the transformed arguments to the output list.
469   ///
470   /// Note that this overload of \c TransformTemplateArguments() is merely
471   /// a convenience function. Subclasses that wish to override this behavior
472   /// should override the iterator-based member template version.
473   ///
474   /// \param Inputs The set of template arguments to be transformed.
475   ///
476   /// \param NumInputs The number of template arguments in \p Inputs.
477   ///
478   /// \param Outputs The set of transformed template arguments output by this
479   /// routine.
480   ///
481   /// Returns true if an error occurred.
482   bool TransformTemplateArguments(const TemplateArgumentLoc *Inputs,
483                                   unsigned NumInputs,
484                                   TemplateArgumentListInfo &Outputs) {
485     return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs);
486   }
487
488   /// \brief Transform the given set of template arguments.
489   ///
490   /// By default, this operation transforms all of the template arguments
491   /// in the input set using \c TransformTemplateArgument(), and appends
492   /// the transformed arguments to the output list.
493   ///
494   /// \param First An iterator to the first template argument.
495   ///
496   /// \param Last An iterator one step past the last template argument.
497   ///
498   /// \param Outputs The set of transformed template arguments output by this
499   /// routine.
500   ///
501   /// Returns true if an error occurred.
502   template<typename InputIterator>
503   bool TransformTemplateArguments(InputIterator First,
504                                   InputIterator Last,
505                                   TemplateArgumentListInfo &Outputs);
506
507   /// \brief Fakes up a TemplateArgumentLoc for a given TemplateArgument.
508   void InventTemplateArgumentLoc(const TemplateArgument &Arg,
509                                  TemplateArgumentLoc &ArgLoc);
510
511   /// \brief Fakes up a TypeSourceInfo for a type.
512   TypeSourceInfo *InventTypeSourceInfo(QualType T) {
513     return SemaRef.Context.getTrivialTypeSourceInfo(T,
514                        getDerived().getBaseLocation());
515   }
516
517 #define ABSTRACT_TYPELOC(CLASS, PARENT)
518 #define TYPELOC(CLASS, PARENT)                                   \
519   QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
520 #include "clang/AST/TypeLocNodes.def"
521
522   QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
523                                       FunctionProtoTypeLoc TL,
524                                       CXXRecordDecl *ThisContext,
525                                       unsigned ThisTypeQuals);
526
527   StmtResult
528   TransformSEHHandler(Stmt *Handler);
529
530   QualType
531   TransformTemplateSpecializationType(TypeLocBuilder &TLB,
532                                       TemplateSpecializationTypeLoc TL,
533                                       TemplateName Template);
534
535   QualType
536   TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
537                                       DependentTemplateSpecializationTypeLoc TL,
538                                                TemplateName Template,
539                                                CXXScopeSpec &SS);
540
541   QualType
542   TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
543                                                DependentTemplateSpecializationTypeLoc TL,
544                                          NestedNameSpecifierLoc QualifierLoc);
545
546   /// \brief Transforms the parameters of a function type into the
547   /// given vectors.
548   ///
549   /// The result vectors should be kept in sync; null entries in the
550   /// variables vector are acceptable.
551   ///
552   /// Return true on error.
553   bool TransformFunctionTypeParams(SourceLocation Loc,
554                                    ParmVarDecl **Params, unsigned NumParams,
555                                    const QualType *ParamTypes,
556                                    SmallVectorImpl<QualType> &PTypes,
557                                    SmallVectorImpl<ParmVarDecl*> *PVars);
558
559   /// \brief Transforms a single function-type parameter.  Return null
560   /// on error.
561   ///
562   /// \param indexAdjustment - A number to add to the parameter's
563   ///   scope index;  can be negative
564   ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
565                                           int indexAdjustment,
566                                         llvm::Optional<unsigned> NumExpansions,
567                                           bool ExpectParameterPack);
568
569   QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);
570
571   StmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr);
572   ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *E);
573
574   /// \brief Transform the captures and body of a lambda expression.
575   ExprResult TransformLambdaScope(LambdaExpr *E, CXXMethodDecl *CallOperator);
576
577 #define STMT(Node, Parent)                        \
578   StmtResult Transform##Node(Node *S);
579 #define EXPR(Node, Parent)                        \
580   ExprResult Transform##Node(Node *E);
581 #define ABSTRACT_STMT(Stmt)
582 #include "clang/AST/StmtNodes.inc"
583
584   /// \brief Build a new pointer type given its pointee type.
585   ///
586   /// By default, performs semantic analysis when building the pointer type.
587   /// Subclasses may override this routine to provide different behavior.
588   QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);
589
590   /// \brief Build a new block pointer type given its pointee type.
591   ///
592   /// By default, performs semantic analysis when building the block pointer
593   /// type. Subclasses may override this routine to provide different behavior.
594   QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);
595
596   /// \brief Build a new reference type given the type it references.
597   ///
598   /// By default, performs semantic analysis when building the
599   /// reference type. Subclasses may override this routine to provide
600   /// different behavior.
601   ///
602   /// \param LValue whether the type was written with an lvalue sigil
603   /// or an rvalue sigil.
604   QualType RebuildReferenceType(QualType ReferentType,
605                                 bool LValue,
606                                 SourceLocation Sigil);
607
608   /// \brief Build a new member pointer type given the pointee type and the
609   /// class type it refers into.
610   ///
611   /// By default, performs semantic analysis when building the member pointer
612   /// type. Subclasses may override this routine to provide different behavior.
613   QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
614                                     SourceLocation Sigil);
615
616   /// \brief Build a new array type given the element type, size
617   /// modifier, size of the array (if known), size expression, and index type
618   /// qualifiers.
619   ///
620   /// By default, performs semantic analysis when building the array type.
621   /// Subclasses may override this routine to provide different behavior.
622   /// Also by default, all of the other Rebuild*Array
623   QualType RebuildArrayType(QualType ElementType,
624                             ArrayType::ArraySizeModifier SizeMod,
625                             const llvm::APInt *Size,
626                             Expr *SizeExpr,
627                             unsigned IndexTypeQuals,
628                             SourceRange BracketsRange);
629
630   /// \brief Build a new constant array type given the element type, size
631   /// modifier, (known) size of the array, and index type qualifiers.
632   ///
633   /// By default, performs semantic analysis when building the array type.
634   /// Subclasses may override this routine to provide different behavior.
635   QualType RebuildConstantArrayType(QualType ElementType,
636                                     ArrayType::ArraySizeModifier SizeMod,
637                                     const llvm::APInt &Size,
638                                     unsigned IndexTypeQuals,
639                                     SourceRange BracketsRange);
640
641   /// \brief Build a new incomplete array type given the element type, size
642   /// modifier, and index type qualifiers.
643   ///
644   /// By default, performs semantic analysis when building the array type.
645   /// Subclasses may override this routine to provide different behavior.
646   QualType RebuildIncompleteArrayType(QualType ElementType,
647                                       ArrayType::ArraySizeModifier SizeMod,
648                                       unsigned IndexTypeQuals,
649                                       SourceRange BracketsRange);
650
651   /// \brief Build a new variable-length array type given the element type,
652   /// size modifier, size expression, and index type qualifiers.
653   ///
654   /// By default, performs semantic analysis when building the array type.
655   /// Subclasses may override this routine to provide different behavior.
656   QualType RebuildVariableArrayType(QualType ElementType,
657                                     ArrayType::ArraySizeModifier SizeMod,
658                                     Expr *SizeExpr,
659                                     unsigned IndexTypeQuals,
660                                     SourceRange BracketsRange);
661
662   /// \brief Build a new dependent-sized array type given the element type,
663   /// size modifier, size expression, and index type qualifiers.
664   ///
665   /// By default, performs semantic analysis when building the array type.
666   /// Subclasses may override this routine to provide different behavior.
667   QualType RebuildDependentSizedArrayType(QualType ElementType,
668                                           ArrayType::ArraySizeModifier SizeMod,
669                                           Expr *SizeExpr,
670                                           unsigned IndexTypeQuals,
671                                           SourceRange BracketsRange);
672
673   /// \brief Build a new vector type given the element type and
674   /// number of elements.
675   ///
676   /// By default, performs semantic analysis when building the vector type.
677   /// Subclasses may override this routine to provide different behavior.
678   QualType RebuildVectorType(QualType ElementType, unsigned NumElements,
679                              VectorType::VectorKind VecKind);
680
681   /// \brief Build a new extended vector type given the element type and
682   /// number of elements.
683   ///
684   /// By default, performs semantic analysis when building the vector type.
685   /// Subclasses may override this routine to provide different behavior.
686   QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements,
687                                 SourceLocation AttributeLoc);
688
689   /// \brief Build a new potentially dependently-sized extended vector type
690   /// given the element type and number of elements.
691   ///
692   /// By default, performs semantic analysis when building the vector type.
693   /// Subclasses may override this routine to provide different behavior.
694   QualType RebuildDependentSizedExtVectorType(QualType ElementType,
695                                               Expr *SizeExpr,
696                                               SourceLocation AttributeLoc);
697
698   /// \brief Build a new function type.
699   ///
700   /// By default, performs semantic analysis when building the function type.
701   /// Subclasses may override this routine to provide different behavior.
702   QualType RebuildFunctionProtoType(QualType T,
703                                     QualType *ParamTypes,
704                                     unsigned NumParamTypes,
705                                     bool Variadic, bool HasTrailingReturn,
706                                     unsigned Quals,
707                                     RefQualifierKind RefQualifier,
708                                     const FunctionType::ExtInfo &Info);
709
710   /// \brief Build a new unprototyped function type.
711   QualType RebuildFunctionNoProtoType(QualType ResultType);
712
713   /// \brief Rebuild an unresolved typename type, given the decl that
714   /// the UnresolvedUsingTypenameDecl was transformed to.
715   QualType RebuildUnresolvedUsingType(Decl *D);
716
717   /// \brief Build a new typedef type.
718   QualType RebuildTypedefType(TypedefNameDecl *Typedef) {
719     return SemaRef.Context.getTypeDeclType(Typedef);
720   }
721
722   /// \brief Build a new class/struct/union type.
723   QualType RebuildRecordType(RecordDecl *Record) {
724     return SemaRef.Context.getTypeDeclType(Record);
725   }
726
727   /// \brief Build a new Enum type.
728   QualType RebuildEnumType(EnumDecl *Enum) {
729     return SemaRef.Context.getTypeDeclType(Enum);
730   }
731
732   /// \brief Build a new typeof(expr) type.
733   ///
734   /// By default, performs semantic analysis when building the typeof type.
735   /// Subclasses may override this routine to provide different behavior.
736   QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc);
737
738   /// \brief Build a new typeof(type) type.
739   ///
740   /// By default, builds a new TypeOfType with the given underlying type.
741   QualType RebuildTypeOfType(QualType Underlying);
742
743   /// \brief Build a new unary transform type.
744   QualType RebuildUnaryTransformType(QualType BaseType,
745                                      UnaryTransformType::UTTKind UKind,
746                                      SourceLocation Loc);
747
748   /// \brief Build a new C++0x decltype type.
749   ///
750   /// By default, performs semantic analysis when building the decltype type.
751   /// Subclasses may override this routine to provide different behavior.
752   QualType RebuildDecltypeType(Expr *Underlying, SourceLocation Loc);
753
754   /// \brief Build a new C++0x auto type.
755   ///
756   /// By default, builds a new AutoType with the given deduced type.
757   QualType RebuildAutoType(QualType Deduced) {
758     return SemaRef.Context.getAutoType(Deduced);
759   }
760
761   /// \brief Build a new template specialization type.
762   ///
763   /// By default, performs semantic analysis when building the template
764   /// specialization type. Subclasses may override this routine to provide
765   /// different behavior.
766   QualType RebuildTemplateSpecializationType(TemplateName Template,
767                                              SourceLocation TemplateLoc,
768                                              TemplateArgumentListInfo &Args);
769
770   /// \brief Build a new parenthesized type.
771   ///
772   /// By default, builds a new ParenType type from the inner type.
773   /// Subclasses may override this routine to provide different behavior.
774   QualType RebuildParenType(QualType InnerType) {
775     return SemaRef.Context.getParenType(InnerType);
776   }
777
778   /// \brief Build a new qualified name type.
779   ///
780   /// By default, builds a new ElaboratedType type from the keyword,
781   /// the nested-name-specifier and the named type.
782   /// Subclasses may override this routine to provide different behavior.
783   QualType RebuildElaboratedType(SourceLocation KeywordLoc,
784                                  ElaboratedTypeKeyword Keyword,
785                                  NestedNameSpecifierLoc QualifierLoc,
786                                  QualType Named) {
787     return SemaRef.Context.getElaboratedType(Keyword,
788                                          QualifierLoc.getNestedNameSpecifier(),
789                                              Named);
790   }
791
792   /// \brief Build a new typename type that refers to a template-id.
793   ///
794   /// By default, builds a new DependentNameType type from the
795   /// nested-name-specifier and the given type. Subclasses may override
796   /// this routine to provide different behavior.
797   QualType RebuildDependentTemplateSpecializationType(
798                                           ElaboratedTypeKeyword Keyword,
799                                           NestedNameSpecifierLoc QualifierLoc,
800                                           const IdentifierInfo *Name,
801                                           SourceLocation NameLoc,
802                                           TemplateArgumentListInfo &Args) {
803     // Rebuild the template name.
804     // TODO: avoid TemplateName abstraction
805     CXXScopeSpec SS;
806     SS.Adopt(QualifierLoc);
807     TemplateName InstName
808       = getDerived().RebuildTemplateName(SS, *Name, NameLoc, QualType(), 0);
809
810     if (InstName.isNull())
811       return QualType();
812
813     // If it's still dependent, make a dependent specialization.
814     if (InstName.getAsDependentTemplateName())
815       return SemaRef.Context.getDependentTemplateSpecializationType(Keyword,
816                                           QualifierLoc.getNestedNameSpecifier(),
817                                                                     Name,
818                                                                     Args);
819
820     // Otherwise, make an elaborated type wrapping a non-dependent
821     // specialization.
822     QualType T =
823     getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
824     if (T.isNull()) return QualType();
825
826     if (Keyword == ETK_None && QualifierLoc.getNestedNameSpecifier() == 0)
827       return T;
828
829     return SemaRef.Context.getElaboratedType(Keyword,
830                                        QualifierLoc.getNestedNameSpecifier(),
831                                              T);
832   }
833
834   /// \brief Build a new typename type that refers to an identifier.
835   ///
836   /// By default, performs semantic analysis when building the typename type
837   /// (or elaborated type). Subclasses may override this routine to provide
838   /// different behavior.
839   QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword,
840                                     SourceLocation KeywordLoc,
841                                     NestedNameSpecifierLoc QualifierLoc,
842                                     const IdentifierInfo *Id,
843                                     SourceLocation IdLoc) {
844     CXXScopeSpec SS;
845     SS.Adopt(QualifierLoc);
846
847     if (QualifierLoc.getNestedNameSpecifier()->isDependent()) {
848       // If the name is still dependent, just build a new dependent name type.
849       if (!SemaRef.computeDeclContext(SS))
850         return SemaRef.Context.getDependentNameType(Keyword,
851                                           QualifierLoc.getNestedNameSpecifier(),
852                                                     Id);
853     }
854
855     if (Keyword == ETK_None || Keyword == ETK_Typename)
856       return SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc,
857                                        *Id, IdLoc);
858
859     TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
860
861     // We had a dependent elaborated-type-specifier that has been transformed
862     // into a non-dependent elaborated-type-specifier. Find the tag we're
863     // referring to.
864     LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
865     DeclContext *DC = SemaRef.computeDeclContext(SS, false);
866     if (!DC)
867       return QualType();
868
869     if (SemaRef.RequireCompleteDeclContext(SS, DC))
870       return QualType();
871
872     TagDecl *Tag = 0;
873     SemaRef.LookupQualifiedName(Result, DC);
874     switch (Result.getResultKind()) {
875       case LookupResult::NotFound:
876       case LookupResult::NotFoundInCurrentInstantiation:
877         break;
878
879       case LookupResult::Found:
880         Tag = Result.getAsSingle<TagDecl>();
881         break;
882
883       case LookupResult::FoundOverloaded:
884       case LookupResult::FoundUnresolvedValue:
885         llvm_unreachable("Tag lookup cannot find non-tags");
886
887       case LookupResult::Ambiguous:
888         // Let the LookupResult structure handle ambiguities.
889         return QualType();
890     }
891
892     if (!Tag) {
893       // Check where the name exists but isn't a tag type and use that to emit
894       // better diagnostics.
895       LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
896       SemaRef.LookupQualifiedName(Result, DC);
897       switch (Result.getResultKind()) {
898         case LookupResult::Found:
899         case LookupResult::FoundOverloaded:
900         case LookupResult::FoundUnresolvedValue: {
901           NamedDecl *SomeDecl = Result.getRepresentativeDecl();
902           unsigned Kind = 0;
903           if (isa<TypedefDecl>(SomeDecl)) Kind = 1;
904           else if (isa<TypeAliasDecl>(SomeDecl)) Kind = 2;
905           else if (isa<ClassTemplateDecl>(SomeDecl)) Kind = 3;
906           SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) << Kind;
907           SemaRef.Diag(SomeDecl->getLocation(), diag::note_declared_at);
908           break;
909         }
910         default:
911           // FIXME: Would be nice to highlight just the source range.
912           SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope)
913             << Kind << Id << DC;
914           break;
915       }
916       return QualType();
917     }
918
919     if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind, /*isDefinition*/false,
920                                               IdLoc, *Id)) {
921       SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id;
922       SemaRef.Diag(Tag->getLocation(), diag::note_previous_use);
923       return QualType();
924     }
925
926     // Build the elaborated-type-specifier type.
927     QualType T = SemaRef.Context.getTypeDeclType(Tag);
928     return SemaRef.Context.getElaboratedType(Keyword,
929                                          QualifierLoc.getNestedNameSpecifier(),
930                                              T);
931   }
932
933   /// \brief Build a new pack expansion type.
934   ///
935   /// By default, builds a new PackExpansionType type from the given pattern.
936   /// Subclasses may override this routine to provide different behavior.
937   QualType RebuildPackExpansionType(QualType Pattern,
938                                     SourceRange PatternRange,
939                                     SourceLocation EllipsisLoc,
940                                     llvm::Optional<unsigned> NumExpansions) {
941     return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc,
942                                         NumExpansions);
943   }
944
945   /// \brief Build a new atomic type given its value type.
946   ///
947   /// By default, performs semantic analysis when building the atomic type.
948   /// Subclasses may override this routine to provide different behavior.
949   QualType RebuildAtomicType(QualType ValueType, SourceLocation KWLoc);
950
951   /// \brief Build a new template name given a nested name specifier, a flag
952   /// indicating whether the "template" keyword was provided, and the template
953   /// that the template name refers to.
954   ///
955   /// By default, builds the new template name directly. Subclasses may override
956   /// this routine to provide different behavior.
957   TemplateName RebuildTemplateName(CXXScopeSpec &SS,
958                                    bool TemplateKW,
959                                    TemplateDecl *Template);
960
961   /// \brief Build a new template name given a nested name specifier and the
962   /// name that is referred to as a template.
963   ///
964   /// By default, performs semantic analysis to determine whether the name can
965   /// be resolved to a specific template, then builds the appropriate kind of
966   /// template name. Subclasses may override this routine to provide different
967   /// behavior.
968   TemplateName RebuildTemplateName(CXXScopeSpec &SS,
969                                    const IdentifierInfo &Name,
970                                    SourceLocation NameLoc,
971                                    QualType ObjectType,
972                                    NamedDecl *FirstQualifierInScope);
973
974   /// \brief Build a new template name given a nested name specifier and the
975   /// overloaded operator name that is referred to as a template.
976   ///
977   /// By default, performs semantic analysis to determine whether the name can
978   /// be resolved to a specific template, then builds the appropriate kind of
979   /// template name. Subclasses may override this routine to provide different
980   /// behavior.
981   TemplateName RebuildTemplateName(CXXScopeSpec &SS,
982                                    OverloadedOperatorKind Operator,
983                                    SourceLocation NameLoc,
984                                    QualType ObjectType);
985
986   /// \brief Build a new template name given a template template parameter pack
987   /// and the
988   ///
989   /// By default, performs semantic analysis to determine whether the name can
990   /// be resolved to a specific template, then builds the appropriate kind of
991   /// template name. Subclasses may override this routine to provide different
992   /// behavior.
993   TemplateName RebuildTemplateName(TemplateTemplateParmDecl *Param,
994                                    const TemplateArgument &ArgPack) {
995     return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
996   }
997
998   /// \brief Build a new compound statement.
999   ///
1000   /// By default, performs semantic analysis to build the new statement.
1001   /// Subclasses may override this routine to provide different behavior.
1002   StmtResult RebuildCompoundStmt(SourceLocation LBraceLoc,
1003                                        MultiStmtArg Statements,
1004                                        SourceLocation RBraceLoc,
1005                                        bool IsStmtExpr) {
1006     return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements,
1007                                        IsStmtExpr);
1008   }
1009
1010   /// \brief Build a new case statement.
1011   ///
1012   /// By default, performs semantic analysis to build the new statement.
1013   /// Subclasses may override this routine to provide different behavior.
1014   StmtResult RebuildCaseStmt(SourceLocation CaseLoc,
1015                                    Expr *LHS,
1016                                    SourceLocation EllipsisLoc,
1017                                    Expr *RHS,
1018                                    SourceLocation ColonLoc) {
1019     return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS,
1020                                    ColonLoc);
1021   }
1022
1023   /// \brief Attach the body to a new case statement.
1024   ///
1025   /// By default, performs semantic analysis to build the new statement.
1026   /// Subclasses may override this routine to provide different behavior.
1027   StmtResult RebuildCaseStmtBody(Stmt *S, Stmt *Body) {
1028     getSema().ActOnCaseStmtBody(S, Body);
1029     return S;
1030   }
1031
1032   /// \brief Build a new default statement.
1033   ///
1034   /// By default, performs semantic analysis to build the new statement.
1035   /// Subclasses may override this routine to provide different behavior.
1036   StmtResult RebuildDefaultStmt(SourceLocation DefaultLoc,
1037                                       SourceLocation ColonLoc,
1038                                       Stmt *SubStmt) {
1039     return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt,
1040                                       /*CurScope=*/0);
1041   }
1042
1043   /// \brief Build a new label statement.
1044   ///
1045   /// By default, performs semantic analysis to build the new statement.
1046   /// Subclasses may override this routine to provide different behavior.
1047   StmtResult RebuildLabelStmt(SourceLocation IdentLoc, LabelDecl *L,
1048                               SourceLocation ColonLoc, Stmt *SubStmt) {
1049     return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt);
1050   }
1051
1052   /// \brief Build a new label statement.
1053   ///
1054   /// By default, performs semantic analysis to build the new statement.
1055   /// Subclasses may override this routine to provide different behavior.
1056   StmtResult RebuildAttributedStmt(SourceLocation AttrLoc,
1057                                    ArrayRef<const Attr*> Attrs,
1058                                    Stmt *SubStmt) {
1059     return SemaRef.ActOnAttributedStmt(AttrLoc, Attrs, SubStmt);
1060   }
1061
1062   /// \brief Build a new "if" statement.
1063   ///
1064   /// By default, performs semantic analysis to build the new statement.
1065   /// Subclasses may override this routine to provide different behavior.
1066   StmtResult RebuildIfStmt(SourceLocation IfLoc, Sema::FullExprArg Cond,
1067                            VarDecl *CondVar, Stmt *Then,
1068                            SourceLocation ElseLoc, Stmt *Else) {
1069     return getSema().ActOnIfStmt(IfLoc, Cond, CondVar, Then, ElseLoc, Else);
1070   }
1071
1072   /// \brief Start building a new switch statement.
1073   ///
1074   /// By default, performs semantic analysis to build the new statement.
1075   /// Subclasses may override this routine to provide different behavior.
1076   StmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc,
1077                                     Expr *Cond, VarDecl *CondVar) {
1078     return getSema().ActOnStartOfSwitchStmt(SwitchLoc, Cond,
1079                                             CondVar);
1080   }
1081
1082   /// \brief Attach the body to the switch statement.
1083   ///
1084   /// By default, performs semantic analysis to build the new statement.
1085   /// Subclasses may override this routine to provide different behavior.
1086   StmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc,
1087                                    Stmt *Switch, Stmt *Body) {
1088     return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body);
1089   }
1090
1091   /// \brief Build a new while statement.
1092   ///
1093   /// By default, performs semantic analysis to build the new statement.
1094   /// Subclasses may override this routine to provide different behavior.
1095   StmtResult RebuildWhileStmt(SourceLocation WhileLoc, Sema::FullExprArg Cond,
1096                               VarDecl *CondVar, Stmt *Body) {
1097     return getSema().ActOnWhileStmt(WhileLoc, Cond, CondVar, Body);
1098   }
1099
1100   /// \brief Build a new do-while statement.
1101   ///
1102   /// By default, performs semantic analysis to build the new statement.
1103   /// Subclasses may override this routine to provide different behavior.
1104   StmtResult RebuildDoStmt(SourceLocation DoLoc, Stmt *Body,
1105                            SourceLocation WhileLoc, SourceLocation LParenLoc,
1106                            Expr *Cond, SourceLocation RParenLoc) {
1107     return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
1108                                  Cond, RParenLoc);
1109   }
1110
1111   /// \brief Build a new for statement.
1112   ///
1113   /// By default, performs semantic analysis to build the new statement.
1114   /// Subclasses may override this routine to provide different behavior.
1115   StmtResult RebuildForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1116                             Stmt *Init, Sema::FullExprArg Cond,
1117                             VarDecl *CondVar, Sema::FullExprArg Inc,
1118                             SourceLocation RParenLoc, Stmt *Body) {
1119     return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
1120                                   CondVar, Inc, RParenLoc, Body);
1121   }
1122
1123   /// \brief Build a new goto statement.
1124   ///
1125   /// By default, performs semantic analysis to build the new statement.
1126   /// Subclasses may override this routine to provide different behavior.
1127   StmtResult RebuildGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc,
1128                              LabelDecl *Label) {
1129     return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label);
1130   }
1131
1132   /// \brief Build a new indirect goto statement.
1133   ///
1134   /// By default, performs semantic analysis to build the new statement.
1135   /// Subclasses may override this routine to provide different behavior.
1136   StmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc,
1137                                      SourceLocation StarLoc,
1138                                      Expr *Target) {
1139     return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target);
1140   }
1141
1142   /// \brief Build a new return statement.
1143   ///
1144   /// By default, performs semantic analysis to build the new statement.
1145   /// Subclasses may override this routine to provide different behavior.
1146   StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, Expr *Result) {
1147     return getSema().ActOnReturnStmt(ReturnLoc, Result);
1148   }
1149
1150   /// \brief Build a new declaration statement.
1151   ///
1152   /// By default, performs semantic analysis to build the new statement.
1153   /// Subclasses may override this routine to provide different behavior.
1154   StmtResult RebuildDeclStmt(Decl **Decls, unsigned NumDecls,
1155                                    SourceLocation StartLoc,
1156                                    SourceLocation EndLoc) {
1157     Sema::DeclGroupPtrTy DG = getSema().BuildDeclaratorGroup(Decls, NumDecls);
1158     return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc);
1159   }
1160
1161   /// \brief Build a new inline asm statement.
1162   ///
1163   /// By default, performs semantic analysis to build the new statement.
1164   /// Subclasses may override this routine to provide different behavior.
1165   StmtResult RebuildAsmStmt(SourceLocation AsmLoc,
1166                                   bool IsSimple,
1167                                   bool IsVolatile,
1168                                   unsigned NumOutputs,
1169                                   unsigned NumInputs,
1170                                   IdentifierInfo **Names,
1171                                   MultiExprArg Constraints,
1172                                   MultiExprArg Exprs,
1173                                   Expr *AsmString,
1174                                   MultiExprArg Clobbers,
1175                                   SourceLocation RParenLoc,
1176                                   bool MSAsm) {
1177     return getSema().ActOnAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
1178                                   NumInputs, Names, move(Constraints),
1179                                   Exprs, AsmString, Clobbers,
1180                                   RParenLoc, MSAsm);
1181   }
1182
1183   /// \brief Build a new MS style inline asm statement.
1184   ///
1185   /// By default, performs semantic analysis to build the new statement.
1186   /// Subclasses may override this routine to provide different behavior.
1187   StmtResult RebuildMSAsmStmt(SourceLocation AsmLoc,
1188                               SourceLocation LBraceLoc,
1189                               ArrayRef<Token> AsmToks,
1190                               SourceLocation EndLoc) {
1191     return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, EndLoc);
1192   }
1193
1194   /// \brief Build a new Objective-C \@try statement.
1195   ///
1196   /// By default, performs semantic analysis to build the new statement.
1197   /// Subclasses may override this routine to provide different behavior.
1198   StmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc,
1199                                         Stmt *TryBody,
1200                                         MultiStmtArg CatchStmts,
1201                                         Stmt *Finally) {
1202     return getSema().ActOnObjCAtTryStmt(AtLoc, TryBody, move(CatchStmts),
1203                                         Finally);
1204   }
1205
1206   /// \brief Rebuild an Objective-C exception declaration.
1207   ///
1208   /// By default, performs semantic analysis to build the new declaration.
1209   /// Subclasses may override this routine to provide different behavior.
1210   VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
1211                                     TypeSourceInfo *TInfo, QualType T) {
1212     return getSema().BuildObjCExceptionDecl(TInfo, T,
1213                                             ExceptionDecl->getInnerLocStart(),
1214                                             ExceptionDecl->getLocation(),
1215                                             ExceptionDecl->getIdentifier());
1216   }
1217
1218   /// \brief Build a new Objective-C \@catch statement.
1219   ///
1220   /// By default, performs semantic analysis to build the new statement.
1221   /// Subclasses may override this routine to provide different behavior.
1222   StmtResult RebuildObjCAtCatchStmt(SourceLocation AtLoc,
1223                                           SourceLocation RParenLoc,
1224                                           VarDecl *Var,
1225                                           Stmt *Body) {
1226     return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
1227                                           Var, Body);
1228   }
1229
1230   /// \brief Build a new Objective-C \@finally statement.
1231   ///
1232   /// By default, performs semantic analysis to build the new statement.
1233   /// Subclasses may override this routine to provide different behavior.
1234   StmtResult RebuildObjCAtFinallyStmt(SourceLocation AtLoc,
1235                                             Stmt *Body) {
1236     return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body);
1237   }
1238
1239   /// \brief Build a new Objective-C \@throw statement.
1240   ///
1241   /// By default, performs semantic analysis to build the new statement.
1242   /// Subclasses may override this routine to provide different behavior.
1243   StmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc,
1244                                           Expr *Operand) {
1245     return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
1246   }
1247
1248   /// \brief Rebuild the operand to an Objective-C \@synchronized statement.
1249   ///
1250   /// By default, performs semantic analysis to build the new statement.
1251   /// Subclasses may override this routine to provide different behavior.
1252   ExprResult RebuildObjCAtSynchronizedOperand(SourceLocation atLoc,
1253                                               Expr *object) {
1254     return getSema().ActOnObjCAtSynchronizedOperand(atLoc, object);
1255   }
1256
1257   /// \brief Build a new Objective-C \@synchronized statement.
1258   ///
1259   /// By default, performs semantic analysis to build the new statement.
1260   /// Subclasses may override this routine to provide different behavior.
1261   StmtResult RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc,
1262                                            Expr *Object, Stmt *Body) {
1263     return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body);
1264   }
1265
1266   /// \brief Build a new Objective-C \@autoreleasepool statement.
1267   ///
1268   /// By default, performs semantic analysis to build the new statement.
1269   /// Subclasses may override this routine to provide different behavior.
1270   StmtResult RebuildObjCAutoreleasePoolStmt(SourceLocation AtLoc,
1271                                             Stmt *Body) {
1272     return getSema().ActOnObjCAutoreleasePoolStmt(AtLoc, Body);
1273   }
1274
1275   /// \brief Build a new Objective-C fast enumeration statement.
1276   ///
1277   /// By default, performs semantic analysis to build the new statement.
1278   /// Subclasses may override this routine to provide different behavior.
1279   StmtResult RebuildObjCForCollectionStmt(SourceLocation ForLoc,
1280                                           Stmt *Element,
1281                                           Expr *Collection,
1282                                           SourceLocation RParenLoc,
1283                                           Stmt *Body) {
1284     StmtResult ForEachStmt = getSema().ActOnObjCForCollectionStmt(ForLoc,
1285                                                 Element,
1286                                                 Collection,
1287                                                 RParenLoc);
1288     if (ForEachStmt.isInvalid())
1289       return StmtError();
1290
1291     return getSema().FinishObjCForCollectionStmt(ForEachStmt.take(), Body);
1292   }
1293
1294   /// \brief Build a new C++ exception declaration.
1295   ///
1296   /// By default, performs semantic analysis to build the new decaration.
1297   /// Subclasses may override this routine to provide different behavior.
1298   VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
1299                                 TypeSourceInfo *Declarator,
1300                                 SourceLocation StartLoc,
1301                                 SourceLocation IdLoc,
1302                                 IdentifierInfo *Id) {
1303     VarDecl *Var = getSema().BuildExceptionDeclaration(0, Declarator,
1304                                                        StartLoc, IdLoc, Id);
1305     if (Var)
1306       getSema().CurContext->addDecl(Var);
1307     return Var;
1308   }
1309
1310   /// \brief Build a new C++ catch statement.
1311   ///
1312   /// By default, performs semantic analysis to build the new statement.
1313   /// Subclasses may override this routine to provide different behavior.
1314   StmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc,
1315                                  VarDecl *ExceptionDecl,
1316                                  Stmt *Handler) {
1317     return Owned(new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl,
1318                                                       Handler));
1319   }
1320
1321   /// \brief Build a new C++ try statement.
1322   ///
1323   /// By default, performs semantic analysis to build the new statement.
1324   /// Subclasses may override this routine to provide different behavior.
1325   StmtResult RebuildCXXTryStmt(SourceLocation TryLoc,
1326                                Stmt *TryBlock,
1327                                MultiStmtArg Handlers) {
1328     return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, move(Handlers));
1329   }
1330
1331   /// \brief Build a new C++0x range-based for statement.
1332   ///
1333   /// By default, performs semantic analysis to build the new statement.
1334   /// Subclasses may override this routine to provide different behavior.
1335   StmtResult RebuildCXXForRangeStmt(SourceLocation ForLoc,
1336                                     SourceLocation ColonLoc,
1337                                     Stmt *Range, Stmt *BeginEnd,
1338                                     Expr *Cond, Expr *Inc,
1339                                     Stmt *LoopVar,
1340                                     SourceLocation RParenLoc) {
1341     return getSema().BuildCXXForRangeStmt(ForLoc, ColonLoc, Range, BeginEnd,
1342                                           Cond, Inc, LoopVar, RParenLoc);
1343   }
1344
1345   /// \brief Build a new C++0x range-based for statement.
1346   ///
1347   /// By default, performs semantic analysis to build the new statement.
1348   /// Subclasses may override this routine to provide different behavior.
1349   StmtResult RebuildMSDependentExistsStmt(SourceLocation KeywordLoc,
1350                                           bool IsIfExists,
1351                                           NestedNameSpecifierLoc QualifierLoc,
1352                                           DeclarationNameInfo NameInfo,
1353                                           Stmt *Nested) {
1354     return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
1355                                                 QualifierLoc, NameInfo, Nested);
1356   }
1357
1358   /// \brief Attach body to a C++0x range-based for statement.
1359   ///
1360   /// By default, performs semantic analysis to finish the new statement.
1361   /// Subclasses may override this routine to provide different behavior.
1362   StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body) {
1363     return getSema().FinishCXXForRangeStmt(ForRange, Body);
1364   }
1365
1366   StmtResult RebuildSEHTryStmt(bool IsCXXTry,
1367                                SourceLocation TryLoc,
1368                                Stmt *TryBlock,
1369                                Stmt *Handler) {
1370     return getSema().ActOnSEHTryBlock(IsCXXTry,TryLoc,TryBlock,Handler);
1371   }
1372
1373   StmtResult RebuildSEHExceptStmt(SourceLocation Loc,
1374                                   Expr *FilterExpr,
1375                                   Stmt *Block) {
1376     return getSema().ActOnSEHExceptBlock(Loc,FilterExpr,Block);
1377   }
1378
1379   StmtResult RebuildSEHFinallyStmt(SourceLocation Loc,
1380                                    Stmt *Block) {
1381     return getSema().ActOnSEHFinallyBlock(Loc,Block);
1382   }
1383
1384   /// \brief Build a new expression that references a declaration.
1385   ///
1386   /// By default, performs semantic analysis to build the new expression.
1387   /// Subclasses may override this routine to provide different behavior.
1388   ExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS,
1389                                         LookupResult &R,
1390                                         bool RequiresADL) {
1391     return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
1392   }
1393
1394
1395   /// \brief Build a new expression that references a declaration.
1396   ///
1397   /// By default, performs semantic analysis to build the new expression.
1398   /// Subclasses may override this routine to provide different behavior.
1399   ExprResult RebuildDeclRefExpr(NestedNameSpecifierLoc QualifierLoc,
1400                                 ValueDecl *VD,
1401                                 const DeclarationNameInfo &NameInfo,
1402                                 TemplateArgumentListInfo *TemplateArgs) {
1403     CXXScopeSpec SS;
1404     SS.Adopt(QualifierLoc);
1405
1406     // FIXME: loses template args.
1407
1408     return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD);
1409   }
1410
1411   /// \brief Build a new expression in parentheses.
1412   ///
1413   /// By default, performs semantic analysis to build the new expression.
1414   /// Subclasses may override this routine to provide different behavior.
1415   ExprResult RebuildParenExpr(Expr *SubExpr, SourceLocation LParen,
1416                                     SourceLocation RParen) {
1417     return getSema().ActOnParenExpr(LParen, RParen, SubExpr);
1418   }
1419
1420   /// \brief Build a new pseudo-destructor expression.
1421   ///
1422   /// By default, performs semantic analysis to build the new expression.
1423   /// Subclasses may override this routine to provide different behavior.
1424   ExprResult RebuildCXXPseudoDestructorExpr(Expr *Base,
1425                                             SourceLocation OperatorLoc,
1426                                             bool isArrow,
1427                                             CXXScopeSpec &SS,
1428                                             TypeSourceInfo *ScopeType,
1429                                             SourceLocation CCLoc,
1430                                             SourceLocation TildeLoc,
1431                                         PseudoDestructorTypeStorage Destroyed);
1432
1433   /// \brief Build a new unary operator expression.
1434   ///
1435   /// By default, performs semantic analysis to build the new expression.
1436   /// Subclasses may override this routine to provide different behavior.
1437   ExprResult RebuildUnaryOperator(SourceLocation OpLoc,
1438                                         UnaryOperatorKind Opc,
1439                                         Expr *SubExpr) {
1440     return getSema().BuildUnaryOp(/*Scope=*/0, OpLoc, Opc, SubExpr);
1441   }
1442
1443   /// \brief Build a new builtin offsetof expression.
1444   ///
1445   /// By default, performs semantic analysis to build the new expression.
1446   /// Subclasses may override this routine to provide different behavior.
1447   ExprResult RebuildOffsetOfExpr(SourceLocation OperatorLoc,
1448                                        TypeSourceInfo *Type,
1449                                        Sema::OffsetOfComponent *Components,
1450                                        unsigned NumComponents,
1451                                        SourceLocation RParenLoc) {
1452     return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
1453                                           NumComponents, RParenLoc);
1454   }
1455
1456   /// \brief Build a new sizeof, alignof or vec_step expression with a
1457   /// type argument.
1458   ///
1459   /// By default, performs semantic analysis to build the new expression.
1460   /// Subclasses may override this routine to provide different behavior.
1461   ExprResult RebuildUnaryExprOrTypeTrait(TypeSourceInfo *TInfo,
1462                                          SourceLocation OpLoc,
1463                                          UnaryExprOrTypeTrait ExprKind,
1464                                          SourceRange R) {
1465     return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R);
1466   }
1467
1468   /// \brief Build a new sizeof, alignof or vec step expression with an
1469   /// expression argument.
1470   ///
1471   /// By default, performs semantic analysis to build the new expression.
1472   /// Subclasses may override this routine to provide different behavior.
1473   ExprResult RebuildUnaryExprOrTypeTrait(Expr *SubExpr, SourceLocation OpLoc,
1474                                          UnaryExprOrTypeTrait ExprKind,
1475                                          SourceRange R) {
1476     ExprResult Result
1477       = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind);
1478     if (Result.isInvalid())
1479       return ExprError();
1480
1481     return move(Result);
1482   }
1483
1484   /// \brief Build a new array subscript expression.
1485   ///
1486   /// By default, performs semantic analysis to build the new expression.
1487   /// Subclasses may override this routine to provide different behavior.
1488   ExprResult RebuildArraySubscriptExpr(Expr *LHS,
1489                                              SourceLocation LBracketLoc,
1490                                              Expr *RHS,
1491                                              SourceLocation RBracketLoc) {
1492     return getSema().ActOnArraySubscriptExpr(/*Scope=*/0, LHS,
1493                                              LBracketLoc, RHS,
1494                                              RBracketLoc);
1495   }
1496
1497   /// \brief Build a new call expression.
1498   ///
1499   /// By default, performs semantic analysis to build the new expression.
1500   /// Subclasses may override this routine to provide different behavior.
1501   ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc,
1502                                    MultiExprArg Args,
1503                                    SourceLocation RParenLoc,
1504                                    Expr *ExecConfig = 0) {
1505     return getSema().ActOnCallExpr(/*Scope=*/0, Callee, LParenLoc,
1506                                    move(Args), RParenLoc, ExecConfig);
1507   }
1508
1509   /// \brief Build a new member access expression.
1510   ///
1511   /// By default, performs semantic analysis to build the new expression.
1512   /// Subclasses may override this routine to provide different behavior.
1513   ExprResult RebuildMemberExpr(Expr *Base, SourceLocation OpLoc,
1514                                bool isArrow,
1515                                NestedNameSpecifierLoc QualifierLoc,
1516                                SourceLocation TemplateKWLoc,
1517                                const DeclarationNameInfo &MemberNameInfo,
1518                                ValueDecl *Member,
1519                                NamedDecl *FoundDecl,
1520                         const TemplateArgumentListInfo *ExplicitTemplateArgs,
1521                                NamedDecl *FirstQualifierInScope) {
1522     ExprResult BaseResult = getSema().PerformMemberExprBaseConversion(Base,
1523                                                                       isArrow);
1524     if (!Member->getDeclName()) {
1525       // We have a reference to an unnamed field.  This is always the
1526       // base of an anonymous struct/union member access, i.e. the
1527       // field is always of record type.
1528       assert(!QualifierLoc && "Can't have an unnamed field with a qualifier!");
1529       assert(Member->getType()->isRecordType() &&
1530              "unnamed member not of record type?");
1531
1532       BaseResult =
1533         getSema().PerformObjectMemberConversion(BaseResult.take(),
1534                                                 QualifierLoc.getNestedNameSpecifier(),
1535                                                 FoundDecl, Member);
1536       if (BaseResult.isInvalid())
1537         return ExprError();
1538       Base = BaseResult.take();
1539       ExprValueKind VK = isArrow ? VK_LValue : Base->getValueKind();
1540       MemberExpr *ME =
1541         new (getSema().Context) MemberExpr(Base, isArrow,
1542                                            Member, MemberNameInfo,
1543                                            cast<FieldDecl>(Member)->getType(),
1544                                            VK, OK_Ordinary);
1545       return getSema().Owned(ME);
1546     }
1547
1548     CXXScopeSpec SS;
1549     SS.Adopt(QualifierLoc);
1550
1551     Base = BaseResult.take();
1552     QualType BaseType = Base->getType();
1553
1554     // FIXME: this involves duplicating earlier analysis in a lot of
1555     // cases; we should avoid this when possible.
1556     LookupResult R(getSema(), MemberNameInfo, Sema::LookupMemberName);
1557     R.addDecl(FoundDecl);
1558     R.resolveKind();
1559
1560     return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow,
1561                                               SS, TemplateKWLoc,
1562                                               FirstQualifierInScope,
1563                                               R, ExplicitTemplateArgs);
1564   }
1565
1566   /// \brief Build a new binary operator expression.
1567   ///
1568   /// By default, performs semantic analysis to build the new expression.
1569   /// Subclasses may override this routine to provide different behavior.
1570   ExprResult RebuildBinaryOperator(SourceLocation OpLoc,
1571                                          BinaryOperatorKind Opc,
1572                                          Expr *LHS, Expr *RHS) {
1573     return getSema().BuildBinOp(/*Scope=*/0, OpLoc, Opc, LHS, RHS);
1574   }
1575
1576   /// \brief Build a new conditional operator expression.
1577   ///
1578   /// By default, performs semantic analysis to build the new expression.
1579   /// Subclasses may override this routine to provide different behavior.
1580   ExprResult RebuildConditionalOperator(Expr *Cond,
1581                                         SourceLocation QuestionLoc,
1582                                         Expr *LHS,
1583                                         SourceLocation ColonLoc,
1584                                         Expr *RHS) {
1585     return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond,
1586                                         LHS, RHS);
1587   }
1588
1589   /// \brief Build a new C-style cast expression.
1590   ///
1591   /// By default, performs semantic analysis to build the new expression.
1592   /// Subclasses may override this routine to provide different behavior.
1593   ExprResult RebuildCStyleCastExpr(SourceLocation LParenLoc,
1594                                          TypeSourceInfo *TInfo,
1595                                          SourceLocation RParenLoc,
1596                                          Expr *SubExpr) {
1597     return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
1598                                          SubExpr);
1599   }
1600
1601   /// \brief Build a new compound literal expression.
1602   ///
1603   /// By default, performs semantic analysis to build the new expression.
1604   /// Subclasses may override this routine to provide different behavior.
1605   ExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc,
1606                                               TypeSourceInfo *TInfo,
1607                                               SourceLocation RParenLoc,
1608                                               Expr *Init) {
1609     return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
1610                                               Init);
1611   }
1612
1613   /// \brief Build a new extended vector element access expression.
1614   ///
1615   /// By default, performs semantic analysis to build the new expression.
1616   /// Subclasses may override this routine to provide different behavior.
1617   ExprResult RebuildExtVectorElementExpr(Expr *Base,
1618                                                SourceLocation OpLoc,
1619                                                SourceLocation AccessorLoc,
1620                                                IdentifierInfo &Accessor) {
1621
1622     CXXScopeSpec SS;
1623     DeclarationNameInfo NameInfo(&Accessor, AccessorLoc);
1624     return getSema().BuildMemberReferenceExpr(Base, Base->getType(),
1625                                               OpLoc, /*IsArrow*/ false,
1626                                               SS, SourceLocation(),
1627                                               /*FirstQualifierInScope*/ 0,
1628                                               NameInfo,
1629                                               /* TemplateArgs */ 0);
1630   }
1631
1632   /// \brief Build a new initializer list expression.
1633   ///
1634   /// By default, performs semantic analysis to build the new expression.
1635   /// Subclasses may override this routine to provide different behavior.
1636   ExprResult RebuildInitList(SourceLocation LBraceLoc,
1637                              MultiExprArg Inits,
1638                              SourceLocation RBraceLoc,
1639                              QualType ResultTy) {
1640     ExprResult Result
1641       = SemaRef.ActOnInitList(LBraceLoc, move(Inits), RBraceLoc);
1642     if (Result.isInvalid() || ResultTy->isDependentType())
1643       return move(Result);
1644
1645     // Patch in the result type we were given, which may have been computed
1646     // when the initial InitListExpr was built.
1647     InitListExpr *ILE = cast<InitListExpr>((Expr *)Result.get());
1648     ILE->setType(ResultTy);
1649     return move(Result);
1650   }
1651
1652   /// \brief Build a new designated initializer expression.
1653   ///
1654   /// By default, performs semantic analysis to build the new expression.
1655   /// Subclasses may override this routine to provide different behavior.
1656   ExprResult RebuildDesignatedInitExpr(Designation &Desig,
1657                                              MultiExprArg ArrayExprs,
1658                                              SourceLocation EqualOrColonLoc,
1659                                              bool GNUSyntax,
1660                                              Expr *Init) {
1661     ExprResult Result
1662       = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
1663                                            Init);
1664     if (Result.isInvalid())
1665       return ExprError();
1666
1667     ArrayExprs.release();
1668     return move(Result);
1669   }
1670
1671   /// \brief Build a new value-initialized expression.
1672   ///
1673   /// By default, builds the implicit value initialization without performing
1674   /// any semantic analysis. Subclasses may override this routine to provide
1675   /// different behavior.
1676   ExprResult RebuildImplicitValueInitExpr(QualType T) {
1677     return SemaRef.Owned(new (SemaRef.Context) ImplicitValueInitExpr(T));
1678   }
1679
1680   /// \brief Build a new \c va_arg expression.
1681   ///
1682   /// By default, performs semantic analysis to build the new expression.
1683   /// Subclasses may override this routine to provide different behavior.
1684   ExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc,
1685                                     Expr *SubExpr, TypeSourceInfo *TInfo,
1686                                     SourceLocation RParenLoc) {
1687     return getSema().BuildVAArgExpr(BuiltinLoc,
1688                                     SubExpr, TInfo,
1689                                     RParenLoc);
1690   }
1691
1692   /// \brief Build a new expression list in parentheses.
1693   ///
1694   /// By default, performs semantic analysis to build the new expression.
1695   /// Subclasses may override this routine to provide different behavior.
1696   ExprResult RebuildParenListExpr(SourceLocation LParenLoc,
1697                                   MultiExprArg SubExprs,
1698                                   SourceLocation RParenLoc) {
1699     return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, move(SubExprs));
1700   }
1701
1702   /// \brief Build a new address-of-label expression.
1703   ///
1704   /// By default, performs semantic analysis, using the name of the label
1705   /// rather than attempting to map the label statement itself.
1706   /// Subclasses may override this routine to provide different behavior.
1707   ExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc,
1708                                   SourceLocation LabelLoc, LabelDecl *Label) {
1709     return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label);
1710   }
1711
1712   /// \brief Build a new GNU statement expression.
1713   ///
1714   /// By default, performs semantic analysis to build the new expression.
1715   /// Subclasses may override this routine to provide different behavior.
1716   ExprResult RebuildStmtExpr(SourceLocation LParenLoc,
1717                                    Stmt *SubStmt,
1718                                    SourceLocation RParenLoc) {
1719     return getSema().ActOnStmtExpr(LParenLoc, SubStmt, RParenLoc);
1720   }
1721
1722   /// \brief Build a new __builtin_choose_expr expression.
1723   ///
1724   /// By default, performs semantic analysis to build the new expression.
1725   /// Subclasses may override this routine to provide different behavior.
1726   ExprResult RebuildChooseExpr(SourceLocation BuiltinLoc,
1727                                      Expr *Cond, Expr *LHS, Expr *RHS,
1728                                      SourceLocation RParenLoc) {
1729     return SemaRef.ActOnChooseExpr(BuiltinLoc,
1730                                    Cond, LHS, RHS,
1731                                    RParenLoc);
1732   }
1733
1734   /// \brief Build a new generic selection expression.
1735   ///
1736   /// By default, performs semantic analysis to build the new expression.
1737   /// Subclasses may override this routine to provide different behavior.
1738   ExprResult RebuildGenericSelectionExpr(SourceLocation KeyLoc,
1739                                          SourceLocation DefaultLoc,
1740                                          SourceLocation RParenLoc,
1741                                          Expr *ControllingExpr,
1742                                          TypeSourceInfo **Types,
1743                                          Expr **Exprs,
1744                                          unsigned NumAssocs) {
1745     return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
1746                                                 ControllingExpr, Types, Exprs,
1747                                                 NumAssocs);
1748   }
1749
1750   /// \brief Build a new overloaded operator call expression.
1751   ///
1752   /// By default, performs semantic analysis to build the new expression.
1753   /// The semantic analysis provides the behavior of template instantiation,
1754   /// copying with transformations that turn what looks like an overloaded
1755   /// operator call into a use of a builtin operator, performing
1756   /// argument-dependent lookup, etc. Subclasses may override this routine to
1757   /// provide different behavior.
1758   ExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
1759                                               SourceLocation OpLoc,
1760                                               Expr *Callee,
1761                                               Expr *First,
1762                                               Expr *Second);
1763
1764   /// \brief Build a new C++ "named" cast expression, such as static_cast or
1765   /// reinterpret_cast.
1766   ///
1767   /// By default, this routine dispatches to one of the more-specific routines
1768   /// for a particular named case, e.g., RebuildCXXStaticCastExpr().
1769   /// Subclasses may override this routine to provide different behavior.
1770   ExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc,
1771                                            Stmt::StmtClass Class,
1772                                            SourceLocation LAngleLoc,
1773                                            TypeSourceInfo *TInfo,
1774                                            SourceLocation RAngleLoc,
1775                                            SourceLocation LParenLoc,
1776                                            Expr *SubExpr,
1777                                            SourceLocation RParenLoc) {
1778     switch (Class) {
1779     case Stmt::CXXStaticCastExprClass:
1780       return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
1781                                                    RAngleLoc, LParenLoc,
1782                                                    SubExpr, RParenLoc);
1783
1784     case Stmt::CXXDynamicCastExprClass:
1785       return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
1786                                                     RAngleLoc, LParenLoc,
1787                                                     SubExpr, RParenLoc);
1788
1789     case Stmt::CXXReinterpretCastExprClass:
1790       return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
1791                                                         RAngleLoc, LParenLoc,
1792                                                         SubExpr,
1793                                                         RParenLoc);
1794
1795     case Stmt::CXXConstCastExprClass:
1796       return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
1797                                                    RAngleLoc, LParenLoc,
1798                                                    SubExpr, RParenLoc);
1799
1800     default:
1801       llvm_unreachable("Invalid C++ named cast");
1802     }
1803   }
1804
1805   /// \brief Build a new C++ static_cast expression.
1806   ///
1807   /// By default, performs semantic analysis to build the new expression.
1808   /// Subclasses may override this routine to provide different behavior.
1809   ExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc,
1810                                             SourceLocation LAngleLoc,
1811                                             TypeSourceInfo *TInfo,
1812                                             SourceLocation RAngleLoc,
1813                                             SourceLocation LParenLoc,
1814                                             Expr *SubExpr,
1815                                             SourceLocation RParenLoc) {
1816     return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
1817                                        TInfo, SubExpr,
1818                                        SourceRange(LAngleLoc, RAngleLoc),
1819                                        SourceRange(LParenLoc, RParenLoc));
1820   }
1821
1822   /// \brief Build a new C++ dynamic_cast expression.
1823   ///
1824   /// By default, performs semantic analysis to build the new expression.
1825   /// Subclasses may override this routine to provide different behavior.
1826   ExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc,
1827                                              SourceLocation LAngleLoc,
1828                                              TypeSourceInfo *TInfo,
1829                                              SourceLocation RAngleLoc,
1830                                              SourceLocation LParenLoc,
1831                                              Expr *SubExpr,
1832                                              SourceLocation RParenLoc) {
1833     return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
1834                                        TInfo, SubExpr,
1835                                        SourceRange(LAngleLoc, RAngleLoc),
1836                                        SourceRange(LParenLoc, RParenLoc));
1837   }
1838
1839   /// \brief Build a new C++ reinterpret_cast expression.
1840   ///
1841   /// By default, performs semantic analysis to build the new expression.
1842   /// Subclasses may override this routine to provide different behavior.
1843   ExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc,
1844                                                  SourceLocation LAngleLoc,
1845                                                  TypeSourceInfo *TInfo,
1846                                                  SourceLocation RAngleLoc,
1847                                                  SourceLocation LParenLoc,
1848                                                  Expr *SubExpr,
1849                                                  SourceLocation RParenLoc) {
1850     return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
1851                                        TInfo, SubExpr,
1852                                        SourceRange(LAngleLoc, RAngleLoc),
1853                                        SourceRange(LParenLoc, RParenLoc));
1854   }
1855
1856   /// \brief Build a new C++ const_cast expression.
1857   ///
1858   /// By default, performs semantic analysis to build the new expression.
1859   /// Subclasses may override this routine to provide different behavior.
1860   ExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc,
1861                                            SourceLocation LAngleLoc,
1862                                            TypeSourceInfo *TInfo,
1863                                            SourceLocation RAngleLoc,
1864                                            SourceLocation LParenLoc,
1865                                            Expr *SubExpr,
1866                                            SourceLocation RParenLoc) {
1867     return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
1868                                        TInfo, SubExpr,
1869                                        SourceRange(LAngleLoc, RAngleLoc),
1870                                        SourceRange(LParenLoc, RParenLoc));
1871   }
1872
1873   /// \brief Build a new C++ functional-style cast expression.
1874   ///
1875   /// By default, performs semantic analysis to build the new expression.
1876   /// Subclasses may override this routine to provide different behavior.
1877   ExprResult RebuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo,
1878                                           SourceLocation LParenLoc,
1879                                           Expr *Sub,
1880                                           SourceLocation RParenLoc) {
1881     return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc,
1882                                                MultiExprArg(&Sub, 1),
1883                                                RParenLoc);
1884   }
1885
1886   /// \brief Build a new C++ typeid(type) expression.
1887   ///
1888   /// By default, performs semantic analysis to build the new expression.
1889   /// Subclasses may override this routine to provide different behavior.
1890   ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
1891                                         SourceLocation TypeidLoc,
1892                                         TypeSourceInfo *Operand,
1893                                         SourceLocation RParenLoc) {
1894     return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
1895                                     RParenLoc);
1896   }
1897
1898
1899   /// \brief Build a new C++ typeid(expr) expression.
1900   ///
1901   /// By default, performs semantic analysis to build the new expression.
1902   /// Subclasses may override this routine to provide different behavior.
1903   ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
1904                                         SourceLocation TypeidLoc,
1905                                         Expr *Operand,
1906                                         SourceLocation RParenLoc) {
1907     return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
1908                                     RParenLoc);
1909   }
1910
1911   /// \brief Build a new C++ __uuidof(type) expression.
1912   ///
1913   /// By default, performs semantic analysis to build the new expression.
1914   /// Subclasses may override this routine to provide different behavior.
1915   ExprResult RebuildCXXUuidofExpr(QualType TypeInfoType,
1916                                         SourceLocation TypeidLoc,
1917                                         TypeSourceInfo *Operand,
1918                                         SourceLocation RParenLoc) {
1919     return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
1920                                     RParenLoc);
1921   }
1922
1923   /// \brief Build a new C++ __uuidof(expr) expression.
1924   ///
1925   /// By default, performs semantic analysis to build the new expression.
1926   /// Subclasses may override this routine to provide different behavior.
1927   ExprResult RebuildCXXUuidofExpr(QualType TypeInfoType,
1928                                         SourceLocation TypeidLoc,
1929                                         Expr *Operand,
1930                                         SourceLocation RParenLoc) {
1931     return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
1932                                     RParenLoc);
1933   }
1934
1935   /// \brief Build a new C++ "this" expression.
1936   ///
1937   /// By default, builds a new "this" expression without performing any
1938   /// semantic analysis. Subclasses may override this routine to provide
1939   /// different behavior.
1940   ExprResult RebuildCXXThisExpr(SourceLocation ThisLoc,
1941                                 QualType ThisType,
1942                                 bool isImplicit) {
1943     getSema().CheckCXXThisCapture(ThisLoc);
1944     return getSema().Owned(
1945                       new (getSema().Context) CXXThisExpr(ThisLoc, ThisType,
1946                                                           isImplicit));
1947   }
1948
1949   /// \brief Build a new C++ throw expression.
1950   ///
1951   /// By default, performs semantic analysis to build the new expression.
1952   /// Subclasses may override this routine to provide different behavior.
1953   ExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, Expr *Sub,
1954                                  bool IsThrownVariableInScope) {
1955     return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope);
1956   }
1957
1958   /// \brief Build a new C++ default-argument expression.
1959   ///
1960   /// By default, builds a new default-argument expression, which does not
1961   /// require any semantic analysis. Subclasses may override this routine to
1962   /// provide different behavior.
1963   ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc,
1964                                             ParmVarDecl *Param) {
1965     return getSema().Owned(CXXDefaultArgExpr::Create(getSema().Context, Loc,
1966                                                      Param));
1967   }
1968
1969   /// \brief Build a new C++ zero-initialization expression.
1970   ///
1971   /// By default, performs semantic analysis to build the new expression.
1972   /// Subclasses may override this routine to provide different behavior.
1973   ExprResult RebuildCXXScalarValueInitExpr(TypeSourceInfo *TSInfo,
1974                                            SourceLocation LParenLoc,
1975                                            SourceLocation RParenLoc) {
1976     return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc,
1977                                                MultiExprArg(getSema(), 0, 0),
1978                                                RParenLoc);
1979   }
1980
1981   /// \brief Build a new C++ "new" expression.
1982   ///
1983   /// By default, performs semantic analysis to build the new expression.
1984   /// Subclasses may override this routine to provide different behavior.
1985   ExprResult RebuildCXXNewExpr(SourceLocation StartLoc,
1986                                bool UseGlobal,
1987                                SourceLocation PlacementLParen,
1988                                MultiExprArg PlacementArgs,
1989                                SourceLocation PlacementRParen,
1990                                SourceRange TypeIdParens,
1991                                QualType AllocatedType,
1992                                TypeSourceInfo *AllocatedTypeInfo,
1993                                Expr *ArraySize,
1994                                SourceRange DirectInitRange,
1995                                Expr *Initializer) {
1996     return getSema().BuildCXXNew(StartLoc, UseGlobal,
1997                                  PlacementLParen,
1998                                  move(PlacementArgs),
1999                                  PlacementRParen,
2000                                  TypeIdParens,
2001                                  AllocatedType,
2002                                  AllocatedTypeInfo,
2003                                  ArraySize,
2004                                  DirectInitRange,
2005                                  Initializer);
2006   }
2007
2008   /// \brief Build a new C++ "delete" expression.
2009   ///
2010   /// By default, performs semantic analysis to build the new expression.
2011   /// Subclasses may override this routine to provide different behavior.
2012   ExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc,
2013                                         bool IsGlobalDelete,
2014                                         bool IsArrayForm,
2015                                         Expr *Operand) {
2016     return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
2017                                     Operand);
2018   }
2019
2020   /// \brief Build a new unary type trait expression.
2021   ///
2022   /// By default, performs semantic analysis to build the new expression.
2023   /// Subclasses may override this routine to provide different behavior.
2024   ExprResult RebuildUnaryTypeTrait(UnaryTypeTrait Trait,
2025                                    SourceLocation StartLoc,
2026                                    TypeSourceInfo *T,
2027                                    SourceLocation RParenLoc) {
2028     return getSema().BuildUnaryTypeTrait(Trait, StartLoc, T, RParenLoc);
2029   }
2030
2031   /// \brief Build a new binary type trait expression.
2032   ///
2033   /// By default, performs semantic analysis to build the new expression.
2034   /// Subclasses may override this routine to provide different behavior.
2035   ExprResult RebuildBinaryTypeTrait(BinaryTypeTrait Trait,
2036                                     SourceLocation StartLoc,
2037                                     TypeSourceInfo *LhsT,
2038                                     TypeSourceInfo *RhsT,
2039                                     SourceLocation RParenLoc) {
2040     return getSema().BuildBinaryTypeTrait(Trait, StartLoc, LhsT, RhsT, RParenLoc);
2041   }
2042
2043   /// \brief Build a new type trait expression.
2044   ///
2045   /// By default, performs semantic analysis to build the new expression.
2046   /// Subclasses may override this routine to provide different behavior.
2047   ExprResult RebuildTypeTrait(TypeTrait Trait,
2048                               SourceLocation StartLoc,
2049                               ArrayRef<TypeSourceInfo *> Args,
2050                               SourceLocation RParenLoc) {
2051     return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc);
2052   }
2053
2054   /// \brief Build a new array type trait expression.
2055   ///
2056   /// By default, performs semantic analysis to build the new expression.
2057   /// Subclasses may override this routine to provide different behavior.
2058   ExprResult RebuildArrayTypeTrait(ArrayTypeTrait Trait,
2059                                    SourceLocation StartLoc,
2060                                    TypeSourceInfo *TSInfo,
2061                                    Expr *DimExpr,
2062                                    SourceLocation RParenLoc) {
2063     return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc);
2064   }
2065
2066   /// \brief Build a new expression trait expression.
2067   ///
2068   /// By default, performs semantic analysis to build the new expression.
2069   /// Subclasses may override this routine to provide different behavior.
2070   ExprResult RebuildExpressionTrait(ExpressionTrait Trait,
2071                                    SourceLocation StartLoc,
2072                                    Expr *Queried,
2073                                    SourceLocation RParenLoc) {
2074     return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc);
2075   }
2076
2077   /// \brief Build a new (previously unresolved) declaration reference
2078   /// expression.
2079   ///
2080   /// By default, performs semantic analysis to build the new expression.
2081   /// Subclasses may override this routine to provide different behavior.
2082   ExprResult RebuildDependentScopeDeclRefExpr(
2083                                           NestedNameSpecifierLoc QualifierLoc,
2084                                           SourceLocation TemplateKWLoc,
2085                                        const DeclarationNameInfo &NameInfo,
2086                               const TemplateArgumentListInfo *TemplateArgs) {
2087     CXXScopeSpec SS;
2088     SS.Adopt(QualifierLoc);
2089
2090     if (TemplateArgs || TemplateKWLoc.isValid())
2091       return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc,
2092                                                     NameInfo, TemplateArgs);
2093
2094     return getSema().BuildQualifiedDeclarationNameExpr(SS, NameInfo);
2095   }
2096
2097   /// \brief Build a new template-id expression.
2098   ///
2099   /// By default, performs semantic analysis to build the new expression.
2100   /// Subclasses may override this routine to provide different behavior.
2101   ExprResult RebuildTemplateIdExpr(const CXXScopeSpec &SS,
2102                                    SourceLocation TemplateKWLoc,
2103                                    LookupResult &R,
2104                                    bool RequiresADL,
2105                               const TemplateArgumentListInfo *TemplateArgs) {
2106     return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL,
2107                                          TemplateArgs);
2108   }
2109
2110   /// \brief Build a new object-construction expression.
2111   ///
2112   /// By default, performs semantic analysis to build the new expression.
2113   /// Subclasses may override this routine to provide different behavior.
2114   ExprResult RebuildCXXConstructExpr(QualType T,
2115                                      SourceLocation Loc,
2116                                      CXXConstructorDecl *Constructor,
2117                                      bool IsElidable,
2118                                      MultiExprArg Args,
2119                                      bool HadMultipleCandidates,
2120                                      bool RequiresZeroInit,
2121                              CXXConstructExpr::ConstructionKind ConstructKind,
2122                                      SourceRange ParenRange) {
2123     ASTOwningVector<Expr*> ConvertedArgs(SemaRef);
2124     if (getSema().CompleteConstructorCall(Constructor, move(Args), Loc,
2125                                           ConvertedArgs))
2126       return ExprError();
2127
2128     return getSema().BuildCXXConstructExpr(Loc, T, Constructor, IsElidable,
2129                                            move_arg(ConvertedArgs),
2130                                            HadMultipleCandidates,
2131                                            RequiresZeroInit, ConstructKind,
2132                                            ParenRange);
2133   }
2134
2135   /// \brief Build a new object-construction expression.
2136   ///
2137   /// By default, performs semantic analysis to build the new expression.
2138   /// Subclasses may override this routine to provide different behavior.
2139   ExprResult RebuildCXXTemporaryObjectExpr(TypeSourceInfo *TSInfo,
2140                                            SourceLocation LParenLoc,
2141                                            MultiExprArg Args,
2142                                            SourceLocation RParenLoc) {
2143     return getSema().BuildCXXTypeConstructExpr(TSInfo,
2144                                                LParenLoc,
2145                                                move(Args),
2146                                                RParenLoc);
2147   }
2148
2149   /// \brief Build a new object-construction expression.
2150   ///
2151   /// By default, performs semantic analysis to build the new expression.
2152   /// Subclasses may override this routine to provide different behavior.
2153   ExprResult RebuildCXXUnresolvedConstructExpr(TypeSourceInfo *TSInfo,
2154                                                SourceLocation LParenLoc,
2155                                                MultiExprArg Args,
2156                                                SourceLocation RParenLoc) {
2157     return getSema().BuildCXXTypeConstructExpr(TSInfo,
2158                                                LParenLoc,
2159                                                move(Args),
2160                                                RParenLoc);
2161   }
2162
2163   /// \brief Build a new member reference expression.
2164   ///
2165   /// By default, performs semantic analysis to build the new expression.
2166   /// Subclasses may override this routine to provide different behavior.
2167   ExprResult RebuildCXXDependentScopeMemberExpr(Expr *BaseE,
2168                                                 QualType BaseType,
2169                                                 bool IsArrow,
2170                                                 SourceLocation OperatorLoc,
2171                                           NestedNameSpecifierLoc QualifierLoc,
2172                                                 SourceLocation TemplateKWLoc,
2173                                             NamedDecl *FirstQualifierInScope,
2174                                    const DeclarationNameInfo &MemberNameInfo,
2175                               const TemplateArgumentListInfo *TemplateArgs) {
2176     CXXScopeSpec SS;
2177     SS.Adopt(QualifierLoc);
2178
2179     return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
2180                                             OperatorLoc, IsArrow,
2181                                             SS, TemplateKWLoc,
2182                                             FirstQualifierInScope,
2183                                             MemberNameInfo,
2184                                             TemplateArgs);
2185   }
2186
2187   /// \brief Build a new member reference expression.
2188   ///
2189   /// By default, performs semantic analysis to build the new expression.
2190   /// Subclasses may override this routine to provide different behavior.
2191   ExprResult RebuildUnresolvedMemberExpr(Expr *BaseE, QualType BaseType,
2192                                          SourceLocation OperatorLoc,
2193                                          bool IsArrow,
2194                                          NestedNameSpecifierLoc QualifierLoc,
2195                                          SourceLocation TemplateKWLoc,
2196                                          NamedDecl *FirstQualifierInScope,
2197                                          LookupResult &R,
2198                                 const TemplateArgumentListInfo *TemplateArgs) {
2199     CXXScopeSpec SS;
2200     SS.Adopt(QualifierLoc);
2201
2202     return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
2203                                             OperatorLoc, IsArrow,
2204                                             SS, TemplateKWLoc,
2205                                             FirstQualifierInScope,
2206                                             R, TemplateArgs);
2207   }
2208
2209   /// \brief Build a new noexcept expression.
2210   ///
2211   /// By default, performs semantic analysis to build the new expression.
2212   /// Subclasses may override this routine to provide different behavior.
2213   ExprResult RebuildCXXNoexceptExpr(SourceRange Range, Expr *Arg) {
2214     return SemaRef.BuildCXXNoexceptExpr(Range.getBegin(), Arg, Range.getEnd());
2215   }
2216
2217   /// \brief Build a new expression to compute the length of a parameter pack.
2218   ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc, NamedDecl *Pack,
2219                                    SourceLocation PackLoc,
2220                                    SourceLocation RParenLoc,
2221                                    llvm::Optional<unsigned> Length) {
2222     if (Length)
2223       return new (SemaRef.Context) SizeOfPackExpr(SemaRef.Context.getSizeType(),
2224                                                   OperatorLoc, Pack, PackLoc,
2225                                                   RParenLoc, *Length);
2226
2227     return new (SemaRef.Context) SizeOfPackExpr(SemaRef.Context.getSizeType(),
2228                                                 OperatorLoc, Pack, PackLoc,
2229                                                 RParenLoc);
2230   }
2231
2232   /// \brief Build a new Objective-C boxed expression.
2233   ///
2234   /// By default, performs semantic analysis to build the new expression.
2235   /// Subclasses may override this routine to provide different behavior.
2236   ExprResult RebuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) {
2237     return getSema().BuildObjCBoxedExpr(SR, ValueExpr);
2238   }
2239
2240   /// \brief Build a new Objective-C array literal.
2241   ///
2242   /// By default, performs semantic analysis to build the new expression.
2243   /// Subclasses may override this routine to provide different behavior.
2244   ExprResult RebuildObjCArrayLiteral(SourceRange Range,
2245                                      Expr **Elements, unsigned NumElements) {
2246     return getSema().BuildObjCArrayLiteral(Range,
2247                                            MultiExprArg(Elements, NumElements));
2248   }
2249
2250   ExprResult RebuildObjCSubscriptRefExpr(SourceLocation RB,
2251                                          Expr *Base, Expr *Key,
2252                                          ObjCMethodDecl *getterMethod,
2253                                          ObjCMethodDecl *setterMethod) {
2254     return  getSema().BuildObjCSubscriptExpression(RB, Base, Key,
2255                                                    getterMethod, setterMethod);
2256   }
2257
2258   /// \brief Build a new Objective-C dictionary literal.
2259   ///
2260   /// By default, performs semantic analysis to build the new expression.
2261   /// Subclasses may override this routine to provide different behavior.
2262   ExprResult RebuildObjCDictionaryLiteral(SourceRange Range,
2263                                           ObjCDictionaryElement *Elements,
2264                                           unsigned NumElements) {
2265     return getSema().BuildObjCDictionaryLiteral(Range, Elements, NumElements);
2266   }
2267
2268   /// \brief Build a new Objective-C \@encode expression.
2269   ///
2270   /// By default, performs semantic analysis to build the new expression.
2271   /// Subclasses may override this routine to provide different behavior.
2272   ExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc,
2273                                          TypeSourceInfo *EncodeTypeInfo,
2274                                          SourceLocation RParenLoc) {
2275     return SemaRef.Owned(SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo,
2276                                                            RParenLoc));
2277   }
2278
2279   /// \brief Build a new Objective-C class message.
2280   ExprResult RebuildObjCMessageExpr(TypeSourceInfo *ReceiverTypeInfo,
2281                                           Selector Sel,
2282                                           ArrayRef<SourceLocation> SelectorLocs,
2283                                           ObjCMethodDecl *Method,
2284                                           SourceLocation LBracLoc,
2285                                           MultiExprArg Args,
2286                                           SourceLocation RBracLoc) {
2287     return SemaRef.BuildClassMessage(ReceiverTypeInfo,
2288                                      ReceiverTypeInfo->getType(),
2289                                      /*SuperLoc=*/SourceLocation(),
2290                                      Sel, Method, LBracLoc, SelectorLocs,
2291                                      RBracLoc, move(Args));
2292   }
2293
2294   /// \brief Build a new Objective-C instance message.
2295   ExprResult RebuildObjCMessageExpr(Expr *Receiver,
2296                                           Selector Sel,
2297                                           ArrayRef<SourceLocation> SelectorLocs,
2298                                           ObjCMethodDecl *Method,
2299                                           SourceLocation LBracLoc,
2300                                           MultiExprArg Args,
2301                                           SourceLocation RBracLoc) {
2302     return SemaRef.BuildInstanceMessage(Receiver,
2303                                         Receiver->getType(),
2304                                         /*SuperLoc=*/SourceLocation(),
2305                                         Sel, Method, LBracLoc, SelectorLocs,
2306                                         RBracLoc, move(Args));
2307   }
2308
2309   /// \brief Build a new Objective-C ivar reference expression.
2310   ///
2311   /// By default, performs semantic analysis to build the new expression.
2312   /// Subclasses may override this routine to provide different behavior.
2313   ExprResult RebuildObjCIvarRefExpr(Expr *BaseArg, ObjCIvarDecl *Ivar,
2314                                           SourceLocation IvarLoc,
2315                                           bool IsArrow, bool IsFreeIvar) {
2316     // FIXME: We lose track of the IsFreeIvar bit.
2317     CXXScopeSpec SS;
2318     ExprResult Base = getSema().Owned(BaseArg);
2319     LookupResult R(getSema(), Ivar->getDeclName(), IvarLoc,
2320                    Sema::LookupMemberName);
2321     ExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow,
2322                                                          /*FIME:*/IvarLoc,
2323                                                          SS, 0,
2324                                                          false);
2325     if (Result.isInvalid() || Base.isInvalid())
2326       return ExprError();
2327
2328     if (Result.get())
2329       return move(Result);
2330
2331     return getSema().BuildMemberReferenceExpr(Base.get(), Base.get()->getType(),
2332                                               /*FIXME:*/IvarLoc, IsArrow,
2333                                               SS, SourceLocation(),
2334                                               /*FirstQualifierInScope=*/0,
2335                                               R,
2336                                               /*TemplateArgs=*/0);
2337   }
2338
2339   /// \brief Build a new Objective-C property reference expression.
2340   ///
2341   /// By default, performs semantic analysis to build the new expression.
2342   /// Subclasses may override this routine to provide different behavior.
2343   ExprResult RebuildObjCPropertyRefExpr(Expr *BaseArg,
2344                                         ObjCPropertyDecl *Property,
2345                                         SourceLocation PropertyLoc) {
2346     CXXScopeSpec SS;
2347     ExprResult Base = getSema().Owned(BaseArg);
2348     LookupResult R(getSema(), Property->getDeclName(), PropertyLoc,
2349                    Sema::LookupMemberName);
2350     bool IsArrow = false;
2351     ExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow,
2352                                                          /*FIME:*/PropertyLoc,
2353                                                          SS, 0, false);
2354     if (Result.isInvalid() || Base.isInvalid())
2355       return ExprError();
2356
2357     if (Result.get())
2358       return move(Result);
2359
2360     return getSema().BuildMemberReferenceExpr(Base.get(), Base.get()->getType(),
2361                                               /*FIXME:*/PropertyLoc, IsArrow,
2362                                               SS, SourceLocation(),
2363                                               /*FirstQualifierInScope=*/0,
2364                                               R,
2365                                               /*TemplateArgs=*/0);
2366   }
2367
2368   /// \brief Build a new Objective-C property reference expression.
2369   ///
2370   /// By default, performs semantic analysis to build the new expression.
2371   /// Subclasses may override this routine to provide different behavior.
2372   ExprResult RebuildObjCPropertyRefExpr(Expr *Base, QualType T,
2373                                         ObjCMethodDecl *Getter,
2374                                         ObjCMethodDecl *Setter,
2375                                         SourceLocation PropertyLoc) {
2376     // Since these expressions can only be value-dependent, we do not
2377     // need to perform semantic analysis again.
2378     return Owned(
2379       new (getSema().Context) ObjCPropertyRefExpr(Getter, Setter, T,
2380                                                   VK_LValue, OK_ObjCProperty,
2381                                                   PropertyLoc, Base));
2382   }
2383
2384   /// \brief Build a new Objective-C "isa" expression.
2385   ///
2386   /// By default, performs semantic analysis to build the new expression.
2387   /// Subclasses may override this routine to provide different behavior.
2388   ExprResult RebuildObjCIsaExpr(Expr *BaseArg, SourceLocation IsaLoc,
2389                                       bool IsArrow) {
2390     CXXScopeSpec SS;
2391     ExprResult Base = getSema().Owned(BaseArg);
2392     LookupResult R(getSema(), &getSema().Context.Idents.get("isa"), IsaLoc,
2393                    Sema::LookupMemberName);
2394     ExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow,
2395                                                          /*FIME:*/IsaLoc,
2396                                                          SS, 0, false);
2397     if (Result.isInvalid() || Base.isInvalid())
2398       return ExprError();
2399
2400     if (Result.get())
2401       return move(Result);
2402
2403     return getSema().BuildMemberReferenceExpr(Base.get(), Base.get()->getType(),
2404                                               /*FIXME:*/IsaLoc, IsArrow,
2405                                               SS, SourceLocation(),
2406                                               /*FirstQualifierInScope=*/0,
2407                                               R,
2408                                               /*TemplateArgs=*/0);
2409   }
2410
2411   /// \brief Build a new shuffle vector expression.
2412   ///
2413   /// By default, performs semantic analysis to build the new expression.
2414   /// Subclasses may override this routine to provide different behavior.
2415   ExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc,
2416                                       MultiExprArg SubExprs,
2417                                       SourceLocation RParenLoc) {
2418     // Find the declaration for __builtin_shufflevector
2419     const IdentifierInfo &Name
2420       = SemaRef.Context.Idents.get("__builtin_shufflevector");
2421     TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl();
2422     DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name));
2423     assert(Lookup.first != Lookup.second && "No __builtin_shufflevector?");
2424
2425     // Build a reference to the __builtin_shufflevector builtin
2426     FunctionDecl *Builtin = cast<FunctionDecl>(*Lookup.first);
2427     ExprResult Callee
2428       = SemaRef.Owned(new (SemaRef.Context) DeclRefExpr(Builtin, false,
2429                                                         Builtin->getType(),
2430                                                         VK_LValue, BuiltinLoc));
2431     Callee = SemaRef.UsualUnaryConversions(Callee.take());
2432     if (Callee.isInvalid())
2433       return ExprError();
2434
2435     // Build the CallExpr
2436     unsigned NumSubExprs = SubExprs.size();
2437     Expr **Subs = (Expr **)SubExprs.release();
2438     ExprResult TheCall = SemaRef.Owned(
2439       new (SemaRef.Context) CallExpr(SemaRef.Context, Callee.take(),
2440                                                        Subs, NumSubExprs,
2441                                                    Builtin->getCallResultType(),
2442                             Expr::getValueKindForType(Builtin->getResultType()),
2443                                      RParenLoc));
2444
2445     // Type-check the __builtin_shufflevector expression.
2446     return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.take()));
2447   }
2448
2449   /// \brief Build a new template argument pack expansion.
2450   ///
2451   /// By default, performs semantic analysis to build a new pack expansion
2452   /// for a template argument. Subclasses may override this routine to provide
2453   /// different behavior.
2454   TemplateArgumentLoc RebuildPackExpansion(TemplateArgumentLoc Pattern,
2455                                            SourceLocation EllipsisLoc,
2456                                        llvm::Optional<unsigned> NumExpansions) {
2457     switch (Pattern.getArgument().getKind()) {
2458     case TemplateArgument::Expression: {
2459       ExprResult Result
2460         = getSema().CheckPackExpansion(Pattern.getSourceExpression(),
2461                                        EllipsisLoc, NumExpansions);
2462       if (Result.isInvalid())
2463         return TemplateArgumentLoc();
2464
2465       return TemplateArgumentLoc(Result.get(), Result.get());
2466     }
2467
2468     case TemplateArgument::Template:
2469       return TemplateArgumentLoc(TemplateArgument(
2470                                           Pattern.getArgument().getAsTemplate(),
2471                                                   NumExpansions),
2472                                  Pattern.getTemplateQualifierLoc(),
2473                                  Pattern.getTemplateNameLoc(),
2474                                  EllipsisLoc);
2475
2476     case TemplateArgument::Null:
2477     case TemplateArgument::Integral:
2478     case TemplateArgument::Declaration:
2479     case TemplateArgument::Pack:
2480     case TemplateArgument::TemplateExpansion:
2481       llvm_unreachable("Pack expansion pattern has no parameter packs");
2482
2483     case TemplateArgument::Type:
2484       if (TypeSourceInfo *Expansion
2485             = getSema().CheckPackExpansion(Pattern.getTypeSourceInfo(),
2486                                            EllipsisLoc,
2487                                            NumExpansions))
2488         return TemplateArgumentLoc(TemplateArgument(Expansion->getType()),
2489                                    Expansion);
2490       break;
2491     }
2492
2493     return TemplateArgumentLoc();
2494   }
2495
2496   /// \brief Build a new expression pack expansion.
2497   ///
2498   /// By default, performs semantic analysis to build a new pack expansion
2499   /// for an expression. Subclasses may override this routine to provide
2500   /// different behavior.
2501   ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
2502                                   llvm::Optional<unsigned> NumExpansions) {
2503     return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions);
2504   }
2505
2506   /// \brief Build a new atomic operation expression.
2507   ///
2508   /// By default, performs semantic analysis to build the new expression.
2509   /// Subclasses may override this routine to provide different behavior.
2510   ExprResult RebuildAtomicExpr(SourceLocation BuiltinLoc,
2511                                MultiExprArg SubExprs,
2512                                QualType RetTy,
2513                                AtomicExpr::AtomicOp Op,
2514                                SourceLocation RParenLoc) {
2515     // Just create the expression; there is not any interesting semantic
2516     // analysis here because we can't actually build an AtomicExpr until
2517     // we are sure it is semantically sound.
2518     unsigned NumSubExprs = SubExprs.size();
2519     Expr **Subs = (Expr **)SubExprs.release();
2520     return new (SemaRef.Context) AtomicExpr(BuiltinLoc, Subs,
2521                                             NumSubExprs, RetTy, Op,
2522                                             RParenLoc);
2523   }
2524
2525 private:
2526   TypeLoc TransformTypeInObjectScope(TypeLoc TL,
2527                                      QualType ObjectType,
2528                                      NamedDecl *FirstQualifierInScope,
2529                                      CXXScopeSpec &SS);
2530
2531   TypeSourceInfo *TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
2532                                              QualType ObjectType,
2533                                              NamedDecl *FirstQualifierInScope,
2534                                              CXXScopeSpec &SS);
2535 };
2536
2537 template<typename Derived>
2538 StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) {
2539   if (!S)
2540     return SemaRef.Owned(S);
2541
2542   switch (S->getStmtClass()) {
2543   case Stmt::NoStmtClass: break;
2544
2545   // Transform individual statement nodes
2546 #define STMT(Node, Parent)                                              \
2547   case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
2548 #define ABSTRACT_STMT(Node)
2549 #define EXPR(Node, Parent)
2550 #include "clang/AST/StmtNodes.inc"
2551
2552   // Transform expressions by calling TransformExpr.
2553 #define STMT(Node, Parent)
2554 #define ABSTRACT_STMT(Stmt)
2555 #define EXPR(Node, Parent) case Stmt::Node##Class:
2556 #include "clang/AST/StmtNodes.inc"
2557     {
2558       ExprResult E = getDerived().TransformExpr(cast<Expr>(S));
2559       if (E.isInvalid())
2560         return StmtError();
2561
2562       return getSema().ActOnExprStmt(getSema().MakeFullExpr(E.take()));
2563     }
2564   }
2565
2566   return SemaRef.Owned(S);
2567 }
2568
2569
2570 template<typename Derived>
2571 ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) {
2572   if (!E)
2573     return SemaRef.Owned(E);
2574
2575   switch (E->getStmtClass()) {
2576     case Stmt::NoStmtClass: break;
2577 #define STMT(Node, Parent) case Stmt::Node##Class: break;
2578 #define ABSTRACT_STMT(Stmt)
2579 #define EXPR(Node, Parent)                                              \
2580     case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
2581 #include "clang/AST/StmtNodes.inc"
2582   }
2583
2584   return SemaRef.Owned(E);
2585 }
2586
2587 template<typename Derived>
2588 bool TreeTransform<Derived>::TransformExprs(Expr **Inputs,
2589                                             unsigned NumInputs,
2590                                             bool IsCall,
2591                                       SmallVectorImpl<Expr *> &Outputs,
2592                                             bool *ArgChanged) {
2593   for (unsigned I = 0; I != NumInputs; ++I) {
2594     // If requested, drop call arguments that need to be dropped.
2595     if (IsCall && getDerived().DropCallArgument(Inputs[I])) {
2596       if (ArgChanged)
2597         *ArgChanged = true;
2598
2599       break;
2600     }
2601
2602     if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(Inputs[I])) {
2603       Expr *Pattern = Expansion->getPattern();
2604
2605       SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2606       getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
2607       assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
2608
2609       // Determine whether the set of unexpanded parameter packs can and should
2610       // be expanded.
2611       bool Expand = true;
2612       bool RetainExpansion = false;
2613       llvm::Optional<unsigned> OrigNumExpansions
2614         = Expansion->getNumExpansions();
2615       llvm::Optional<unsigned> NumExpansions = OrigNumExpansions;
2616       if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
2617                                                Pattern->getSourceRange(),
2618                                                Unexpanded,
2619                                                Expand, RetainExpansion,
2620                                                NumExpansions))
2621         return true;
2622
2623       if (!Expand) {
2624         // The transform has determined that we should perform a simple
2625         // transformation on the pack expansion, producing another pack
2626         // expansion.
2627         Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
2628         ExprResult OutPattern = getDerived().TransformExpr(Pattern);
2629         if (OutPattern.isInvalid())
2630           return true;
2631
2632         ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(),
2633                                                 Expansion->getEllipsisLoc(),
2634                                                            NumExpansions);
2635         if (Out.isInvalid())
2636           return true;
2637
2638         if (ArgChanged)
2639           *ArgChanged = true;
2640         Outputs.push_back(Out.get());
2641         continue;
2642       }
2643
2644       // Record right away that the argument was changed.  This needs
2645       // to happen even if the array expands to nothing.
2646       if (ArgChanged) *ArgChanged = true;
2647
2648       // The transform has determined that we should perform an elementwise
2649       // expansion of the pattern. Do so.
2650       for (unsigned I = 0; I != *NumExpansions; ++I) {
2651         Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
2652         ExprResult Out = getDerived().TransformExpr(Pattern);
2653         if (Out.isInvalid())
2654           return true;
2655
2656         if (Out.get()->containsUnexpandedParameterPack()) {
2657           Out = RebuildPackExpansion(Out.get(), Expansion->getEllipsisLoc(),
2658                                      OrigNumExpansions);
2659           if (Out.isInvalid())
2660             return true;
2661         }
2662
2663         Outputs.push_back(Out.get());
2664       }
2665
2666       continue;
2667     }
2668
2669     ExprResult Result = getDerived().TransformExpr(Inputs[I]);
2670     if (Result.isInvalid())
2671       return true;
2672
2673     if (Result.get() != Inputs[I] && ArgChanged)
2674       *ArgChanged = true;
2675
2676     Outputs.push_back(Result.get());
2677   }
2678
2679   return false;
2680 }
2681
2682 template<typename Derived>
2683 NestedNameSpecifierLoc
2684 TreeTransform<Derived>::TransformNestedNameSpecifierLoc(
2685                                                     NestedNameSpecifierLoc NNS,
2686                                                      QualType ObjectType,
2687                                              NamedDecl *FirstQualifierInScope) {
2688   SmallVector<NestedNameSpecifierLoc, 4> Qualifiers;
2689   for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier;
2690        Qualifier = Qualifier.getPrefix())
2691     Qualifiers.push_back(Qualifier);
2692
2693   CXXScopeSpec SS;
2694   while (!Qualifiers.empty()) {
2695     NestedNameSpecifierLoc Q = Qualifiers.pop_back_val();
2696     NestedNameSpecifier *QNNS = Q.getNestedNameSpecifier();
2697
2698     switch (QNNS->getKind()) {
2699     case NestedNameSpecifier::Identifier:
2700       if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/0,
2701                                               *QNNS->getAsIdentifier(),
2702                                               Q.getLocalBeginLoc(),
2703                                               Q.getLocalEndLoc(),
2704                                               ObjectType, false, SS,
2705                                               FirstQualifierInScope, false))
2706         return NestedNameSpecifierLoc();
2707
2708       break;
2709
2710     case NestedNameSpecifier::Namespace: {
2711       NamespaceDecl *NS
2712         = cast_or_null<NamespaceDecl>(
2713                                     getDerived().TransformDecl(
2714                                                           Q.getLocalBeginLoc(),
2715                                                        QNNS->getAsNamespace()));
2716       SS.Extend(SemaRef.Context, NS, Q.getLocalBeginLoc(), Q.getLocalEndLoc());
2717       break;
2718     }
2719
2720     case NestedNameSpecifier::NamespaceAlias: {
2721       NamespaceAliasDecl *Alias
2722         = cast_or_null<NamespaceAliasDecl>(
2723                       getDerived().TransformDecl(Q.getLocalBeginLoc(),
2724                                                  QNNS->getAsNamespaceAlias()));
2725       SS.Extend(SemaRef.Context, Alias, Q.getLocalBeginLoc(),
2726                 Q.getLocalEndLoc());
2727       break;
2728     }
2729
2730     case NestedNameSpecifier::Global:
2731       // There is no meaningful transformation that one could perform on the
2732       // global scope.
2733       SS.MakeGlobal(SemaRef.Context, Q.getBeginLoc());
2734       break;
2735
2736     case NestedNameSpecifier::TypeSpecWithTemplate:
2737     case NestedNameSpecifier::TypeSpec: {
2738       TypeLoc TL = TransformTypeInObjectScope(Q.getTypeLoc(), ObjectType,
2739                                               FirstQualifierInScope, SS);
2740
2741       if (!TL)
2742         return NestedNameSpecifierLoc();
2743
2744       if (TL.getType()->isDependentType() || TL.getType()->isRecordType() ||
2745           (SemaRef.getLangOpts().CPlusPlus0x &&
2746            TL.getType()->isEnumeralType())) {
2747         assert(!TL.getType().hasLocalQualifiers() &&
2748                "Can't get cv-qualifiers here");
2749         if (TL.getType()->isEnumeralType())
2750           SemaRef.Diag(TL.getBeginLoc(),
2751                        diag::warn_cxx98_compat_enum_nested_name_spec);
2752         SS.Extend(SemaRef.Context, /*FIXME:*/SourceLocation(), TL,
2753                   Q.getLocalEndLoc());
2754         break;
2755       }
2756       // If the nested-name-specifier is an invalid type def, don't emit an
2757       // error because a previous error should have already been emitted.
2758       TypedefTypeLoc* TTL = dyn_cast<TypedefTypeLoc>(&TL);
2759       if (!TTL || !TTL->getTypedefNameDecl()->isInvalidDecl()) {
2760         SemaRef.Diag(TL.getBeginLoc(), diag::err_nested_name_spec_non_tag)
2761           << TL.getType() << SS.getRange();
2762       }
2763       return NestedNameSpecifierLoc();
2764     }
2765     }
2766
2767     // The qualifier-in-scope and object type only apply to the leftmost entity.
2768     FirstQualifierInScope = 0;
2769     ObjectType = QualType();
2770   }
2771
2772   // Don't rebuild the nested-name-specifier if we don't have to.
2773   if (SS.getScopeRep() == NNS.getNestedNameSpecifier() &&
2774       !getDerived().AlwaysRebuild())
2775     return NNS;
2776
2777   // If we can re-use the source-location data from the original
2778   // nested-name-specifier, do so.
2779   if (SS.location_size() == NNS.getDataLength() &&
2780       memcmp(SS.location_data(), NNS.getOpaqueData(), SS.location_size()) == 0)
2781     return NestedNameSpecifierLoc(SS.getScopeRep(), NNS.getOpaqueData());
2782
2783   // Allocate new nested-name-specifier location information.
2784   return SS.getWithLocInContext(SemaRef.Context);
2785 }
2786
2787 template<typename Derived>
2788 DeclarationNameInfo
2789 TreeTransform<Derived>
2790 ::TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo) {
2791   DeclarationName Name = NameInfo.getName();
2792   if (!Name)
2793     return DeclarationNameInfo();
2794
2795   switch (Name.getNameKind()) {
2796   case DeclarationName::Identifier:
2797   case DeclarationName::ObjCZeroArgSelector:
2798   case DeclarationName::ObjCOneArgSelector:
2799   case DeclarationName::ObjCMultiArgSelector:
2800   case DeclarationName::CXXOperatorName:
2801   case DeclarationName::CXXLiteralOperatorName:
2802   case DeclarationName::CXXUsingDirective:
2803     return NameInfo;
2804
2805   case DeclarationName::CXXConstructorName:
2806   case DeclarationName::CXXDestructorName:
2807   case DeclarationName::CXXConversionFunctionName: {
2808     TypeSourceInfo *NewTInfo;
2809     CanQualType NewCanTy;
2810     if (TypeSourceInfo *OldTInfo = NameInfo.getNamedTypeInfo()) {
2811       NewTInfo = getDerived().TransformType(OldTInfo);
2812       if (!NewTInfo)
2813         return DeclarationNameInfo();
2814       NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->getType());
2815     }
2816     else {
2817       NewTInfo = 0;
2818       TemporaryBase Rebase(*this, NameInfo.getLoc(), Name);
2819       QualType NewT = getDerived().TransformType(Name.getCXXNameType());
2820       if (NewT.isNull())
2821         return DeclarationNameInfo();
2822       NewCanTy = SemaRef.Context.getCanonicalType(NewT);
2823     }
2824
2825     DeclarationName NewName
2826       = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.getNameKind(),
2827                                                            NewCanTy);
2828     DeclarationNameInfo NewNameInfo(NameInfo);
2829     NewNameInfo.setName(NewName);
2830     NewNameInfo.setNamedTypeInfo(NewTInfo);
2831     return NewNameInfo;
2832   }
2833   }
2834
2835   llvm_unreachable("Unknown name kind.");
2836 }
2837
2838 template<typename Derived>
2839 TemplateName
2840 TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS,
2841                                               TemplateName Name,
2842                                               SourceLocation NameLoc,
2843                                               QualType ObjectType,
2844                                               NamedDecl *FirstQualifierInScope) {
2845   if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) {
2846     TemplateDecl *Template = QTN->getTemplateDecl();
2847     assert(Template && "qualified template name must refer to a template");
2848
2849     TemplateDecl *TransTemplate
2850       = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
2851                                                               Template));
2852     if (!TransTemplate)
2853       return TemplateName();
2854
2855     if (!getDerived().AlwaysRebuild() &&
2856         SS.getScopeRep() == QTN->getQualifier() &&
2857         TransTemplate == Template)
2858       return Name;
2859
2860     return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
2861                                             TransTemplate);
2862   }
2863
2864   if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) {
2865     if (SS.getScopeRep()) {
2866       // These apply to the scope specifier, not the template.
2867       ObjectType = QualType();
2868       FirstQualifierInScope = 0;
2869     }
2870
2871     if (!getDerived().AlwaysRebuild() &&
2872         SS.getScopeRep() == DTN->getQualifier() &&
2873         ObjectType.isNull())
2874       return Name;
2875
2876     if (DTN->isIdentifier()) {
2877       return getDerived().RebuildTemplateName(SS,
2878                                               *DTN->getIdentifier(),
2879                                               NameLoc,
2880                                               ObjectType,
2881                                               FirstQualifierInScope);
2882     }
2883
2884     return getDerived().RebuildTemplateName(SS, DTN->getOperator(), NameLoc,
2885                                             ObjectType);
2886   }
2887
2888   if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
2889     TemplateDecl *TransTemplate
2890       = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
2891                                                               Template));
2892     if (!TransTemplate)
2893       return TemplateName();
2894
2895     if (!getDerived().AlwaysRebuild() &&
2896         TransTemplate == Template)
2897       return Name;
2898
2899     return TemplateName(TransTemplate);
2900   }
2901
2902   if (SubstTemplateTemplateParmPackStorage *SubstPack
2903       = Name.getAsSubstTemplateTemplateParmPack()) {
2904     TemplateTemplateParmDecl *TransParam
2905     = cast_or_null<TemplateTemplateParmDecl>(
2906             getDerived().TransformDecl(NameLoc, SubstPack->getParameterPack()));
2907     if (!TransParam)
2908       return TemplateName();
2909
2910     if (!getDerived().AlwaysRebuild() &&
2911         TransParam == SubstPack->getParameterPack())
2912       return Name;
2913
2914     return getDerived().RebuildTemplateName(TransParam,
2915                                             SubstPack->getArgumentPack());
2916   }
2917
2918   // These should be getting filtered out before they reach the AST.
2919   llvm_unreachable("overloaded function decl survived to here");
2920 }
2921
2922 template<typename Derived>
2923 void TreeTransform<Derived>::InventTemplateArgumentLoc(
2924                                          const TemplateArgument &Arg,
2925                                          TemplateArgumentLoc &Output) {
2926   SourceLocation Loc = getDerived().getBaseLocation();
2927   switch (Arg.getKind()) {
2928   case TemplateArgument::Null:
2929     llvm_unreachable("null template argument in TreeTransform");
2930     break;
2931
2932   case TemplateArgument::Type:
2933     Output = TemplateArgumentLoc(Arg,
2934                SemaRef.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc));
2935
2936     break;
2937
2938   case TemplateArgument::Template:
2939   case TemplateArgument::TemplateExpansion: {
2940     NestedNameSpecifierLocBuilder Builder;
2941     TemplateName Template = Arg.getAsTemplate();
2942     if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
2943       Builder.MakeTrivial(SemaRef.Context, DTN->getQualifier(), Loc);
2944     else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
2945       Builder.MakeTrivial(SemaRef.Context, QTN->getQualifier(), Loc);
2946
2947     if (Arg.getKind() == TemplateArgument::Template)
2948       Output = TemplateArgumentLoc(Arg,
2949                                    Builder.getWithLocInContext(SemaRef.Context),
2950                                    Loc);
2951     else
2952       Output = TemplateArgumentLoc(Arg,
2953                                    Builder.getWithLocInContext(SemaRef.Context),
2954                                    Loc, Loc);
2955
2956     break;
2957   }
2958
2959   case TemplateArgument::Expression:
2960     Output = TemplateArgumentLoc(Arg, Arg.getAsExpr());
2961     break;
2962
2963   case TemplateArgument::Declaration:
2964   case TemplateArgument::Integral:
2965   case TemplateArgument::Pack:
2966     Output = TemplateArgumentLoc(Arg, TemplateArgumentLocInfo());
2967     break;
2968   }
2969 }
2970
2971 template<typename Derived>
2972 bool TreeTransform<Derived>::TransformTemplateArgument(
2973                                          const TemplateArgumentLoc &Input,
2974                                          TemplateArgumentLoc &Output) {
2975   const TemplateArgument &Arg = Input.getArgument();
2976   switch (Arg.getKind()) {
2977   case TemplateArgument::Null:
2978   case TemplateArgument::Integral:
2979     Output = Input;
2980     return false;
2981
2982   case TemplateArgument::Type: {
2983     TypeSourceInfo *DI = Input.getTypeSourceInfo();
2984     if (DI == NULL)
2985       DI = InventTypeSourceInfo(Input.getArgument().getAsType());
2986
2987     DI = getDerived().TransformType(DI);
2988     if (!DI) return true;
2989
2990     Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
2991     return false;
2992   }
2993
2994   case TemplateArgument::Declaration: {
2995     // FIXME: we should never have to transform one of these.
2996     DeclarationName Name;
2997     if (NamedDecl *ND = dyn_cast<NamedDecl>(Arg.getAsDecl()))
2998       Name = ND->getDeclName();
2999     TemporaryBase Rebase(*this, Input.getLocation(), Name);
3000     Decl *D = getDerived().TransformDecl(Input.getLocation(), Arg.getAsDecl());
3001     if (!D) return true;
3002
3003     Expr *SourceExpr = Input.getSourceDeclExpression();
3004     if (SourceExpr) {
3005       EnterExpressionEvaluationContext Unevaluated(getSema(),
3006                                                    Sema::ConstantEvaluated);
3007       ExprResult E = getDerived().TransformExpr(SourceExpr);
3008       E = SemaRef.ActOnConstantExpression(E);
3009       SourceExpr = (E.isInvalid() ? 0 : E.take());
3010     }
3011
3012     Output = TemplateArgumentLoc(TemplateArgument(D), SourceExpr);
3013     return false;
3014   }
3015
3016   case TemplateArgument::Template: {
3017     NestedNameSpecifierLoc QualifierLoc = Input.getTemplateQualifierLoc();
3018     if (QualifierLoc) {
3019       QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
3020       if (!QualifierLoc)
3021         return true;
3022     }
3023
3024     CXXScopeSpec SS;
3025     SS.Adopt(QualifierLoc);
3026     TemplateName Template
3027       = getDerived().TransformTemplateName(SS, Arg.getAsTemplate(),
3028                                            Input.getTemplateNameLoc());
3029     if (Template.isNull())
3030       return true;
3031
3032     Output = TemplateArgumentLoc(TemplateArgument(Template), QualifierLoc,
3033                                  Input.getTemplateNameLoc());
3034     return false;
3035   }
3036
3037   case TemplateArgument::TemplateExpansion:
3038     llvm_unreachable("Caller should expand pack expansions");
3039
3040   case TemplateArgument::Expression: {
3041     // Template argument expressions are constant expressions.
3042     EnterExpressionEvaluationContext Unevaluated(getSema(),
3043                                                  Sema::ConstantEvaluated);
3044
3045     Expr *InputExpr = Input.getSourceExpression();
3046     if (!InputExpr) InputExpr = Input.getArgument().getAsExpr();
3047
3048     ExprResult E = getDerived().TransformExpr(InputExpr);
3049     E = SemaRef.ActOnConstantExpression(E);
3050     if (E.isInvalid()) return true;
3051     Output = TemplateArgumentLoc(TemplateArgument(E.take()), E.take());
3052     return false;
3053   }
3054
3055   case TemplateArgument::Pack: {
3056     SmallVector<TemplateArgument, 4> TransformedArgs;
3057     TransformedArgs.reserve(Arg.pack_size());
3058     for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
3059                                       AEnd = Arg.pack_end();
3060          A != AEnd; ++A) {
3061
3062       // FIXME: preserve source information here when we start
3063       // caring about parameter packs.
3064
3065       TemplateArgumentLoc InputArg;
3066       TemplateArgumentLoc OutputArg;
3067       getDerived().InventTemplateArgumentLoc(*A, InputArg);
3068       if (getDerived().TransformTemplateArgument(InputArg, OutputArg))
3069         return true;
3070
3071       TransformedArgs.push_back(OutputArg.getArgument());
3072     }
3073
3074     TemplateArgument *TransformedArgsPtr
3075       = new (getSema().Context) TemplateArgument[TransformedArgs.size()];
3076     std::copy(TransformedArgs.begin(), TransformedArgs.end(),
3077               TransformedArgsPtr);
3078     Output = TemplateArgumentLoc(TemplateArgument(TransformedArgsPtr,
3079                                                   TransformedArgs.size()),
3080                                  Input.getLocInfo());
3081     return false;
3082   }
3083   }
3084
3085   // Work around bogus GCC warning
3086   return true;
3087 }
3088
3089 /// \brief Iterator adaptor that invents template argument location information
3090 /// for each of the template arguments in its underlying iterator.
3091 template<typename Derived, typename InputIterator>
3092 class TemplateArgumentLocInventIterator {
3093   TreeTransform<Derived> &Self;
3094   InputIterator Iter;
3095
3096 public:
3097   typedef TemplateArgumentLoc value_type;
3098   typedef TemplateArgumentLoc reference;
3099   typedef typename std::iterator_traits<InputIterator>::difference_type
3100     difference_type;
3101   typedef std::input_iterator_tag iterator_category;
3102
3103   class pointer {
3104     TemplateArgumentLoc Arg;
3105
3106   public:
3107     explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }
3108
3109     const TemplateArgumentLoc *operator->() const { return &Arg; }
3110   };
3111
3112   TemplateArgumentLocInventIterator() { }
3113
3114   explicit TemplateArgumentLocInventIterator(TreeTransform<Derived> &Self,
3115                                              InputIterator Iter)
3116     : Self(Self), Iter(Iter) { }
3117
3118   TemplateArgumentLocInventIterator &operator++() {
3119     ++Iter;
3120     return *this;
3121   }
3122
3123   TemplateArgumentLocInventIterator operator++(int) {
3124     TemplateArgumentLocInventIterator Old(*this);
3125     ++(*this);
3126     return Old;
3127   }
3128
3129   reference operator*() const {
3130     TemplateArgumentLoc Result;
3131     Self.InventTemplateArgumentLoc(*Iter, Result);
3132     return Result;
3133   }
3134
3135   pointer operator->() const { return pointer(**this); }
3136
3137   friend bool operator==(const TemplateArgumentLocInventIterator &X,
3138                          const TemplateArgumentLocInventIterator &Y) {
3139     return X.Iter == Y.Iter;
3140   }
3141
3142   friend bool operator!=(const TemplateArgumentLocInventIterator &X,
3143                          const TemplateArgumentLocInventIterator &Y) {
3144     return X.Iter != Y.Iter;
3145   }
3146 };
3147
3148 template<typename Derived>
3149 template<typename InputIterator>
3150 bool TreeTransform<Derived>::TransformTemplateArguments(InputIterator First,
3151                                                         InputIterator Last,
3152                                             TemplateArgumentListInfo &Outputs) {
3153   for (; First != Last; ++First) {
3154     TemplateArgumentLoc Out;
3155     TemplateArgumentLoc In = *First;
3156
3157     if (In.getArgument().getKind() == TemplateArgument::Pack) {
3158       // Unpack argument packs, which we translate them into separate
3159       // arguments.
3160       // FIXME: We could do much better if we could guarantee that the
3161       // TemplateArgumentLocInfo for the pack expansion would be usable for
3162       // all of the template arguments in the argument pack.
3163       typedef TemplateArgumentLocInventIterator<Derived,
3164                                                 TemplateArgument::pack_iterator>
3165         PackLocIterator;
3166       if (TransformTemplateArguments(PackLocIterator(*this,
3167                                                  In.getArgument().pack_begin()),
3168                                      PackLocIterator(*this,
3169                                                    In.getArgument().pack_end()),
3170                                      Outputs))
3171         return true;
3172
3173       continue;
3174     }
3175
3176     if (In.getArgument().isPackExpansion()) {
3177       // We have a pack expansion, for which we will be substituting into
3178       // the pattern.
3179       SourceLocation Ellipsis;
3180       llvm::Optional<unsigned> OrigNumExpansions;
3181       TemplateArgumentLoc Pattern
3182         = In.getPackExpansionPattern(Ellipsis, OrigNumExpansions,
3183                                      getSema().Context);
3184
3185       SmallVector<UnexpandedParameterPack, 2> Unexpanded;
3186       getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
3187       assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
3188
3189       // Determine whether the set of unexpanded parameter packs can and should
3190       // be expanded.
3191       bool Expand = true;
3192       bool RetainExpansion = false;
3193       llvm::Optional<unsigned> NumExpansions = OrigNumExpansions;
3194       if (getDerived().TryExpandParameterPacks(Ellipsis,
3195                                                Pattern.getSourceRange(),
3196                                                Unexpanded,
3197                                                Expand,
3198                                                RetainExpansion,
3199                                                NumExpansions))
3200         return true;
3201
3202       if (!Expand) {
3203         // The transform has determined that we should perform a simple
3204         // transformation on the pack expansion, producing another pack