1 //===------- TreeTransform.h - Semantic Tree Transformation -----*- C++ -*-===/
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //===----------------------------------------------------------------------===/
9 // This file implements a semantic tree transformation that takes a given
10 // AST and rebuilds it, possibly transforming some nodes in the process.
12 //===----------------------------------------------------------------------===/
13 #ifndef LLVM_CLANG_SEMA_TREETRANSFORM_H
14 #define LLVM_CLANG_SEMA_TREETRANSFORM_H
16 #include "clang/Sema/SemaInternal.h"
17 #include "clang/Sema/Lookup.h"
18 #include "clang/Sema/ParsedTemplate.h"
19 #include "clang/Sema/SemaDiagnostic.h"
20 #include "clang/Sema/ScopeInfo.h"
21 #include "clang/AST/Decl.h"
22 #include "clang/AST/DeclObjC.h"
23 #include "clang/AST/Expr.h"
24 #include "clang/AST/ExprCXX.h"
25 #include "clang/AST/ExprObjC.h"
26 #include "clang/AST/Stmt.h"
27 #include "clang/AST/StmtCXX.h"
28 #include "clang/AST/StmtObjC.h"
29 #include "clang/Sema/Ownership.h"
30 #include "clang/Sema/Designator.h"
31 #include "clang/Lex/Preprocessor.h"
32 #include "llvm/Support/ErrorHandling.h"
33 #include "TypeLocBuilder.h"
39 /// \brief A semantic tree transformation that allows one to transform one
40 /// abstract syntax tree into another.
42 /// A new tree transformation is defined by creating a new subclass \c X of
43 /// \c TreeTransform<X> and then overriding certain operations to provide
44 /// behavior specific to that transformation. For example, template
45 /// instantiation is implemented as a tree transformation where the
46 /// transformation of TemplateTypeParmType nodes involves substituting the
47 /// template arguments for their corresponding template parameters; a similar
48 /// transformation is performed for non-type template parameters and
49 /// template template parameters.
51 /// This tree-transformation template uses static polymorphism to allow
52 /// subclasses to customize any of its operations. Thus, a subclass can
53 /// override any of the transformation or rebuild operators by providing an
54 /// operation with the same signature as the default implementation. The
55 /// overridding function should not be virtual.
57 /// Semantic tree transformations are split into two stages, either of which
58 /// can be replaced by a subclass. The "transform" step transforms an AST node
59 /// or the parts of an AST node using the various transformation functions,
60 /// then passes the pieces on to the "rebuild" step, which constructs a new AST
61 /// node of the appropriate kind from the pieces. The default transformation
62 /// routines recursively transform the operands to composite AST nodes (e.g.,
63 /// the pointee type of a PointerType node) and, if any of those operand nodes
64 /// were changed by the transformation, invokes the rebuild operation to create
67 /// Subclasses can customize the transformation at various levels. The
68 /// most coarse-grained transformations involve replacing TransformType(),
69 /// TransformExpr(), TransformDecl(), TransformNestedNameSpecifier(),
70 /// TransformTemplateName(), or TransformTemplateArgument() with entirely
71 /// new implementations.
73 /// For more fine-grained transformations, subclasses can replace any of the
74 /// \c TransformXXX functions (where XXX is the name of an AST node, e.g.,
75 /// PointerType, StmtExpr) to alter the transformation. As mentioned previously,
76 /// replacing TransformTemplateTypeParmType() allows template instantiation
77 /// to substitute template arguments for their corresponding template
78 /// parameters. Additionally, subclasses can override the \c RebuildXXX
79 /// functions to control how AST nodes are rebuilt when their operands change.
80 /// By default, \c TreeTransform will invoke semantic analysis to rebuild
81 /// AST nodes. However, certain other tree transformations (e.g, cloning) may
82 /// be able to use more efficient rebuild steps.
84 /// There are a handful of other functions that can be overridden, allowing one
85 /// to avoid traversing nodes that don't need any transformation
86 /// (\c AlreadyTransformed()), force rebuilding AST nodes even when their
87 /// operands have not changed (\c AlwaysRebuild()), and customize the
88 /// default locations and entity names used for type-checking
89 /// (\c getBaseLocation(), \c getBaseEntity()).
90 template<typename Derived
>
92 /// \brief Private RAII object that helps us forget and then re-remember
93 /// the template argument corresponding to a partially-substituted parameter
95 class ForgetPartiallySubstitutedPackRAII
{
100 ForgetPartiallySubstitutedPackRAII(Derived
&Self
) : Self(Self
) {
101 Old
= Self
.ForgetPartiallySubstitutedPack();
104 ~ForgetPartiallySubstitutedPackRAII() {
105 Self
.RememberPartiallySubstitutedPack(Old
);
113 /// \brief Initializes a new tree transformer.
114 TreeTransform(Sema
&SemaRef
) : SemaRef(SemaRef
) { }
116 /// \brief Retrieves a reference to the derived class.
117 Derived
&getDerived() { return static_cast<Derived
&>(*this); }
119 /// \brief Retrieves a reference to the derived class.
120 const Derived
&getDerived() const {
121 return static_cast<const Derived
&>(*this);
124 static inline ExprResult
Owned(Expr
*E
) { return E
; }
125 static inline StmtResult
Owned(Stmt
*S
) { return S
; }
127 /// \brief Retrieves a reference to the semantic analysis object used for
128 /// this tree transform.
129 Sema
&getSema() const { return SemaRef
; }
131 /// \brief Whether the transformation should always rebuild AST nodes, even
132 /// if none of the children have changed.
134 /// Subclasses may override this function to specify when the transformation
135 /// should rebuild all AST nodes.
136 bool AlwaysRebuild() { return false; }
138 /// \brief Returns the location of the entity being transformed, if that
139 /// information was not available elsewhere in the AST.
141 /// By default, returns no source-location information. Subclasses can
142 /// provide an alternative implementation that provides better location
144 SourceLocation
getBaseLocation() { return SourceLocation(); }
146 /// \brief Returns the name of the entity being transformed, if that
147 /// information was not available elsewhere in the AST.
149 /// By default, returns an empty name. Subclasses can provide an alternative
150 /// implementation with a more precise name.
151 DeclarationName
getBaseEntity() { return DeclarationName(); }
153 /// \brief Sets the "base" location and entity when that
154 /// information is known based on another transformation.
156 /// By default, the source location and entity are ignored. Subclasses can
157 /// override this function to provide a customized implementation.
158 void setBase(SourceLocation Loc
, DeclarationName Entity
) { }
160 /// \brief RAII object that temporarily sets the base location and entity
161 /// used for reporting diagnostics in types.
162 class TemporaryBase
{
164 SourceLocation OldLocation
;
165 DeclarationName OldEntity
;
168 TemporaryBase(TreeTransform
&Self
, SourceLocation Location
,
169 DeclarationName Entity
) : Self(Self
) {
170 OldLocation
= Self
.getDerived().getBaseLocation();
171 OldEntity
= Self
.getDerived().getBaseEntity();
172 Self
.getDerived().setBase(Location
, Entity
);
176 Self
.getDerived().setBase(OldLocation
, OldEntity
);
180 /// \brief Determine whether the given type \p T has already been
183 /// Subclasses can provide an alternative implementation of this routine
184 /// to short-circuit evaluation when it is known that a given type will
185 /// not change. For example, template instantiation need not traverse
186 /// non-dependent types.
187 bool AlreadyTransformed(QualType T
) {
191 /// \brief Determine whether the given call argument should be dropped, e.g.,
192 /// because it is a default argument.
194 /// Subclasses can provide an alternative implementation of this routine to
195 /// determine which kinds of call arguments get dropped. By default,
196 /// CXXDefaultArgument nodes are dropped (prior to transformation).
197 bool DropCallArgument(Expr
*E
) {
198 return E
->isDefaultArgument();
201 /// \brief Determine whether we should expand a pack expansion with the
202 /// given set of parameter packs into separate arguments by repeatedly
203 /// transforming the pattern.
205 /// By default, the transformer never tries to expand pack expansions.
206 /// Subclasses can override this routine to provide different behavior.
208 /// \param EllipsisLoc The location of the ellipsis that identifies the
211 /// \param PatternRange The source range that covers the entire pattern of
212 /// the pack expansion.
214 /// \param Unexpanded The set of unexpanded parameter packs within the
217 /// \param NumUnexpanded The number of unexpanded parameter packs in
220 /// \param ShouldExpand Will be set to \c true if the transformer should
221 /// expand the corresponding pack expansions into separate arguments. When
222 /// set, \c NumExpansions must also be set.
224 /// \param RetainExpansion Whether the caller should add an unexpanded
225 /// pack expansion after all of the expanded arguments. This is used
226 /// when extending explicitly-specified template argument packs per
227 /// C++0x [temp.arg.explicit]p9.
229 /// \param NumExpansions The number of separate arguments that will be in
230 /// the expanded form of the corresponding pack expansion. Must be set when
231 /// \c ShouldExpand is \c true.
233 /// \returns true if an error occurred (e.g., because the parameter packs
234 /// are to be instantiated with arguments of different lengths), false
235 /// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions)
237 bool TryExpandParameterPacks(SourceLocation EllipsisLoc
,
238 SourceRange PatternRange
,
239 const UnexpandedParameterPack
*Unexpanded
,
240 unsigned NumUnexpanded
,
242 bool &RetainExpansion
,
243 unsigned &NumExpansions
) {
244 ShouldExpand
= false;
248 /// \brief "Forget" about the partially-substituted pack template argument,
249 /// when performing an instantiation that must preserve the parameter pack
252 /// This routine is meant to be overridden by the template instantiator.
253 TemplateArgument
ForgetPartiallySubstitutedPack() {
254 return TemplateArgument();
257 /// \brief "Remember" the partially-substituted pack template argument
258 /// after performing an instantiation that must preserve the parameter pack
261 /// This routine is meant to be overridden by the template instantiator.
262 void RememberPartiallySubstitutedPack(TemplateArgument Arg
) { }
264 /// \brief Note to the derived class when a function parameter pack is
266 void ExpandingFunctionParameterPack(ParmVarDecl
*Pack
) { }
268 /// \brief Transforms the given type into another type.
270 /// By default, this routine transforms a type by creating a
271 /// TypeSourceInfo for it and delegating to the appropriate
272 /// function. This is expensive, but we don't mind, because
273 /// this method is deprecated anyway; all users should be
274 /// switched to storing TypeSourceInfos.
276 /// \returns the transformed type.
277 QualType
TransformType(QualType T
);
279 /// \brief Transforms the given type-with-location into a new
280 /// type-with-location.
282 /// By default, this routine transforms a type by delegating to the
283 /// appropriate TransformXXXType to build a new type. Subclasses
284 /// may override this function (to take over all type
285 /// transformations) or some set of the TransformXXXType functions
286 /// to alter the transformation.
287 TypeSourceInfo
*TransformType(TypeSourceInfo
*DI
);
289 /// \brief Transform the given type-with-location into a new
290 /// type, collecting location information in the given builder
293 QualType
TransformType(TypeLocBuilder
&TLB
, TypeLoc TL
);
295 /// \brief Transform the given statement.
297 /// By default, this routine transforms a statement by delegating to the
298 /// appropriate TransformXXXStmt function to transform a specific kind of
299 /// statement or the TransformExpr() function to transform an expression.
300 /// Subclasses may override this function to transform statements using some
303 /// \returns the transformed statement.
304 StmtResult
TransformStmt(Stmt
*S
);
306 /// \brief Transform the given expression.
308 /// By default, this routine transforms an expression by delegating to the
309 /// appropriate TransformXXXExpr function to build a new expression.
310 /// Subclasses may override this function to transform expressions using some
313 /// \returns the transformed expression.
314 ExprResult
TransformExpr(Expr
*E
);
316 /// \brief Transform the given list of expressions.
318 /// This routine transforms a list of expressions by invoking
319 /// \c TransformExpr() for each subexpression. However, it also provides
320 /// support for variadic templates by expanding any pack expansions (if the
321 /// derived class permits such expansion) along the way. When pack expansions
322 /// are present, the number of outputs may not equal the number of inputs.
324 /// \param Inputs The set of expressions to be transformed.
326 /// \param NumInputs The number of expressions in \c Inputs.
328 /// \param IsCall If \c true, then this transform is being performed on
329 /// function-call arguments, and any arguments that should be dropped, will
332 /// \param Outputs The transformed input expressions will be added to this
335 /// \param ArgChanged If non-NULL, will be set \c true if any argument changed
336 /// due to transformation.
338 /// \returns true if an error occurred, false otherwise.
339 bool TransformExprs(Expr
**Inputs
, unsigned NumInputs
, bool IsCall
,
340 llvm::SmallVectorImpl
<Expr
*> &Outputs
,
341 bool *ArgChanged
= 0);
343 /// \brief Transform the given declaration, which is referenced from a type
346 /// By default, acts as the identity function on declarations. Subclasses
347 /// may override this function to provide alternate behavior.
348 Decl
*TransformDecl(SourceLocation Loc
, Decl
*D
) { return D
; }
350 /// \brief Transform the definition of the given declaration.
352 /// By default, invokes TransformDecl() to transform the declaration.
353 /// Subclasses may override this function to provide alternate behavior.
354 Decl
*TransformDefinition(SourceLocation Loc
, Decl
*D
) {
355 return getDerived().TransformDecl(Loc
, D
);
358 /// \brief Transform the given declaration, which was the first part of a
359 /// nested-name-specifier in a member access expression.
361 /// This specific declaration transformation only applies to the first
362 /// identifier in a nested-name-specifier of a member access expression, e.g.,
363 /// the \c T in \c x->T::member
365 /// By default, invokes TransformDecl() to transform the declaration.
366 /// Subclasses may override this function to provide alternate behavior.
367 NamedDecl
*TransformFirstQualifierInScope(NamedDecl
*D
, SourceLocation Loc
) {
368 return cast_or_null
<NamedDecl
>(getDerived().TransformDecl(Loc
, D
));
371 /// \brief Transform the given nested-name-specifier.
373 /// By default, transforms all of the types and declarations within the
374 /// nested-name-specifier. Subclasses may override this function to provide
375 /// alternate behavior.
376 NestedNameSpecifier
*TransformNestedNameSpecifier(NestedNameSpecifier
*NNS
,
378 QualType ObjectType
= QualType(),
379 NamedDecl
*FirstQualifierInScope
= 0);
381 /// \brief Transform the given declaration name.
383 /// By default, transforms the types of conversion function, constructor,
384 /// and destructor names and then (if needed) rebuilds the declaration name.
385 /// Identifiers and selectors are returned unmodified. Sublcasses may
386 /// override this function to provide alternate behavior.
388 TransformDeclarationNameInfo(const DeclarationNameInfo
&NameInfo
);
390 /// \brief Transform the given template name.
392 /// By default, transforms the template name by transforming the declarations
393 /// and nested-name-specifiers that occur within the template name.
394 /// Subclasses may override this function to provide alternate behavior.
395 TemplateName
TransformTemplateName(TemplateName Name
,
396 QualType ObjectType
= QualType(),
397 NamedDecl
*FirstQualifierInScope
= 0);
399 /// \brief Transform the given template argument.
401 /// By default, this operation transforms the type, expression, or
402 /// declaration stored within the template argument and constructs a
403 /// new template argument from the transformed result. Subclasses may
404 /// override this function to provide alternate behavior.
406 /// Returns true if there was an error.
407 bool TransformTemplateArgument(const TemplateArgumentLoc
&Input
,
408 TemplateArgumentLoc
&Output
);
410 /// \brief Transform the given set of template arguments.
412 /// By default, this operation transforms all of the template arguments
413 /// in the input set using \c TransformTemplateArgument(), and appends
414 /// the transformed arguments to the output list.
416 /// Note that this overload of \c TransformTemplateArguments() is merely
417 /// a convenience function. Subclasses that wish to override this behavior
418 /// should override the iterator-based member template version.
420 /// \param Inputs The set of template arguments to be transformed.
422 /// \param NumInputs The number of template arguments in \p Inputs.
424 /// \param Outputs The set of transformed template arguments output by this
427 /// Returns true if an error occurred.
428 bool TransformTemplateArguments(const TemplateArgumentLoc
*Inputs
,
430 TemplateArgumentListInfo
&Outputs
) {
431 return TransformTemplateArguments(Inputs
, Inputs
+ NumInputs
, Outputs
);
434 /// \brief Transform the given set of template arguments.
436 /// By default, this operation transforms all of the template arguments
437 /// in the input set using \c TransformTemplateArgument(), and appends
438 /// the transformed arguments to the output list.
440 /// \param First An iterator to the first template argument.
442 /// \param Last An iterator one step past the last template argument.
444 /// \param Outputs The set of transformed template arguments output by this
447 /// Returns true if an error occurred.
448 template<typename InputIterator
>
449 bool TransformTemplateArguments(InputIterator First
,
451 TemplateArgumentListInfo
&Outputs
);
453 /// \brief Fakes up a TemplateArgumentLoc for a given TemplateArgument.
454 void InventTemplateArgumentLoc(const TemplateArgument
&Arg
,
455 TemplateArgumentLoc
&ArgLoc
);
457 /// \brief Fakes up a TypeSourceInfo for a type.
458 TypeSourceInfo
*InventTypeSourceInfo(QualType T
) {
459 return SemaRef
.Context
.getTrivialTypeSourceInfo(T
,
460 getDerived().getBaseLocation());
463 #define ABSTRACT_TYPELOC(CLASS, PARENT)
464 #define TYPELOC(CLASS, PARENT) \
465 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
466 #include "clang/AST/TypeLocNodes.def"
469 TransformTemplateSpecializationType(TypeLocBuilder
&TLB
,
470 TemplateSpecializationTypeLoc TL
,
471 TemplateName Template
);
474 TransformDependentTemplateSpecializationType(TypeLocBuilder
&TLB
,
475 DependentTemplateSpecializationTypeLoc TL
,
476 NestedNameSpecifier
*Prefix
);
478 /// \brief Transforms the parameters of a function type into the
481 /// The result vectors should be kept in sync; null entries in the
482 /// variables vector are acceptable.
484 /// Return true on error.
485 bool TransformFunctionTypeParams(SourceLocation Loc
,
486 ParmVarDecl
**Params
, unsigned NumParams
,
487 const QualType
*ParamTypes
,
488 llvm::SmallVectorImpl
<QualType
> &PTypes
,
489 llvm::SmallVectorImpl
<ParmVarDecl
*> *PVars
);
491 /// \brief Transforms a single function-type parameter. Return null
493 ParmVarDecl
*TransformFunctionTypeParam(ParmVarDecl
*OldParm
);
495 QualType
TransformReferenceType(TypeLocBuilder
&TLB
, ReferenceTypeLoc TL
);
497 StmtResult
TransformCompoundStmt(CompoundStmt
*S
, bool IsStmtExpr
);
498 ExprResult
TransformCXXNamedCastExpr(CXXNamedCastExpr
*E
);
500 #define STMT(Node, Parent) \
501 StmtResult Transform##Node(Node *S);
502 #define EXPR(Node, Parent) \
503 ExprResult Transform##Node(Node *E);
504 #define ABSTRACT_STMT(Stmt)
505 #include "clang/AST/StmtNodes.inc"
507 /// \brief Build a new pointer type given its pointee type.
509 /// By default, performs semantic analysis when building the pointer type.
510 /// Subclasses may override this routine to provide different behavior.
511 QualType
RebuildPointerType(QualType PointeeType
, SourceLocation Sigil
);
513 /// \brief Build a new block pointer type given its pointee type.
515 /// By default, performs semantic analysis when building the block pointer
516 /// type. Subclasses may override this routine to provide different behavior.
517 QualType
RebuildBlockPointerType(QualType PointeeType
, SourceLocation Sigil
);
519 /// \brief Build a new reference type given the type it references.
521 /// By default, performs semantic analysis when building the
522 /// reference type. Subclasses may override this routine to provide
523 /// different behavior.
525 /// \param LValue whether the type was written with an lvalue sigil
526 /// or an rvalue sigil.
527 QualType
RebuildReferenceType(QualType ReferentType
,
529 SourceLocation Sigil
);
531 /// \brief Build a new member pointer type given the pointee type and the
532 /// class type it refers into.
534 /// By default, performs semantic analysis when building the member pointer
535 /// type. Subclasses may override this routine to provide different behavior.
536 QualType
RebuildMemberPointerType(QualType PointeeType
, QualType ClassType
,
537 SourceLocation Sigil
);
539 /// \brief Build a new array type given the element type, size
540 /// modifier, size of the array (if known), size expression, and index type
543 /// By default, performs semantic analysis when building the array type.
544 /// Subclasses may override this routine to provide different behavior.
545 /// Also by default, all of the other Rebuild*Array
546 QualType
RebuildArrayType(QualType ElementType
,
547 ArrayType::ArraySizeModifier SizeMod
,
548 const llvm::APInt
*Size
,
550 unsigned IndexTypeQuals
,
551 SourceRange BracketsRange
);
553 /// \brief Build a new constant array type given the element type, size
554 /// modifier, (known) size of the array, and index type qualifiers.
556 /// By default, performs semantic analysis when building the array type.
557 /// Subclasses may override this routine to provide different behavior.
558 QualType
RebuildConstantArrayType(QualType ElementType
,
559 ArrayType::ArraySizeModifier SizeMod
,
560 const llvm::APInt
&Size
,
561 unsigned IndexTypeQuals
,
562 SourceRange BracketsRange
);
564 /// \brief Build a new incomplete array type given the element type, size
565 /// modifier, and index type qualifiers.
567 /// By default, performs semantic analysis when building the array type.
568 /// Subclasses may override this routine to provide different behavior.
569 QualType
RebuildIncompleteArrayType(QualType ElementType
,
570 ArrayType::ArraySizeModifier SizeMod
,
571 unsigned IndexTypeQuals
,
572 SourceRange BracketsRange
);
574 /// \brief Build a new variable-length array type given the element type,
575 /// size modifier, size expression, and index type qualifiers.
577 /// By default, performs semantic analysis when building the array type.
578 /// Subclasses may override this routine to provide different behavior.
579 QualType
RebuildVariableArrayType(QualType ElementType
,
580 ArrayType::ArraySizeModifier SizeMod
,
582 unsigned IndexTypeQuals
,
583 SourceRange BracketsRange
);
585 /// \brief Build a new dependent-sized array type given the element type,
586 /// size modifier, size expression, and index type qualifiers.
588 /// By default, performs semantic analysis when building the array type.
589 /// Subclasses may override this routine to provide different behavior.
590 QualType
RebuildDependentSizedArrayType(QualType ElementType
,
591 ArrayType::ArraySizeModifier SizeMod
,
593 unsigned IndexTypeQuals
,
594 SourceRange BracketsRange
);
596 /// \brief Build a new vector type given the element type and
597 /// number of elements.
599 /// By default, performs semantic analysis when building the vector type.
600 /// Subclasses may override this routine to provide different behavior.
601 QualType
RebuildVectorType(QualType ElementType
, unsigned NumElements
,
602 VectorType::VectorKind VecKind
);
604 /// \brief Build a new extended vector type given the element type and
605 /// number of elements.
607 /// By default, performs semantic analysis when building the vector type.
608 /// Subclasses may override this routine to provide different behavior.
609 QualType
RebuildExtVectorType(QualType ElementType
, unsigned NumElements
,
610 SourceLocation AttributeLoc
);
612 /// \brief Build a new potentially dependently-sized extended vector type
613 /// given the element type and number of elements.
615 /// By default, performs semantic analysis when building the vector type.
616 /// Subclasses may override this routine to provide different behavior.
617 QualType
RebuildDependentSizedExtVectorType(QualType ElementType
,
619 SourceLocation AttributeLoc
);
621 /// \brief Build a new function type.
623 /// By default, performs semantic analysis when building the function type.
624 /// Subclasses may override this routine to provide different behavior.
625 QualType
RebuildFunctionProtoType(QualType T
,
626 QualType
*ParamTypes
,
627 unsigned NumParamTypes
,
628 bool Variadic
, unsigned Quals
,
629 const FunctionType::ExtInfo
&Info
);
631 /// \brief Build a new unprototyped function type.
632 QualType
RebuildFunctionNoProtoType(QualType ResultType
);
634 /// \brief Rebuild an unresolved typename type, given the decl that
635 /// the UnresolvedUsingTypenameDecl was transformed to.
636 QualType
RebuildUnresolvedUsingType(Decl
*D
);
638 /// \brief Build a new typedef type.
639 QualType
RebuildTypedefType(TypedefDecl
*Typedef
) {
640 return SemaRef
.Context
.getTypeDeclType(Typedef
);
643 /// \brief Build a new class/struct/union type.
644 QualType
RebuildRecordType(RecordDecl
*Record
) {
645 return SemaRef
.Context
.getTypeDeclType(Record
);
648 /// \brief Build a new Enum type.
649 QualType
RebuildEnumType(EnumDecl
*Enum
) {
650 return SemaRef
.Context
.getTypeDeclType(Enum
);
653 /// \brief Build a new typeof(expr) type.
655 /// By default, performs semantic analysis when building the typeof type.
656 /// Subclasses may override this routine to provide different behavior.
657 QualType
RebuildTypeOfExprType(Expr
*Underlying
, SourceLocation Loc
);
659 /// \brief Build a new typeof(type) type.
661 /// By default, builds a new TypeOfType with the given underlying type.
662 QualType
RebuildTypeOfType(QualType Underlying
);
664 /// \brief Build a new C++0x decltype type.
666 /// By default, performs semantic analysis when building the decltype type.
667 /// Subclasses may override this routine to provide different behavior.
668 QualType
RebuildDecltypeType(Expr
*Underlying
, SourceLocation Loc
);
670 /// \brief Build a new template specialization type.
672 /// By default, performs semantic analysis when building the template
673 /// specialization type. Subclasses may override this routine to provide
674 /// different behavior.
675 QualType
RebuildTemplateSpecializationType(TemplateName Template
,
676 SourceLocation TemplateLoc
,
677 const TemplateArgumentListInfo
&Args
);
679 /// \brief Build a new parenthesized type.
681 /// By default, builds a new ParenType type from the inner type.
682 /// Subclasses may override this routine to provide different behavior.
683 QualType
RebuildParenType(QualType InnerType
) {
684 return SemaRef
.Context
.getParenType(InnerType
);
687 /// \brief Build a new qualified name type.
689 /// By default, builds a new ElaboratedType type from the keyword,
690 /// the nested-name-specifier and the named type.
691 /// Subclasses may override this routine to provide different behavior.
692 QualType
RebuildElaboratedType(SourceLocation KeywordLoc
,
693 ElaboratedTypeKeyword Keyword
,
694 NestedNameSpecifier
*NNS
, QualType Named
) {
695 return SemaRef
.Context
.getElaboratedType(Keyword
, NNS
, Named
);
698 /// \brief Build a new typename type that refers to a template-id.
700 /// By default, builds a new DependentNameType type from the
701 /// nested-name-specifier and the given type. Subclasses may override
702 /// this routine to provide different behavior.
703 QualType
RebuildDependentTemplateSpecializationType(
704 ElaboratedTypeKeyword Keyword
,
705 NestedNameSpecifier
*Qualifier
,
706 SourceRange QualifierRange
,
707 const IdentifierInfo
*Name
,
708 SourceLocation NameLoc
,
709 const TemplateArgumentListInfo
&Args
) {
710 // Rebuild the template name.
711 // TODO: avoid TemplateName abstraction
712 TemplateName InstName
=
713 getDerived().RebuildTemplateName(Qualifier
, QualifierRange
, *Name
,
716 if (InstName
.isNull())
719 // If it's still dependent, make a dependent specialization.
720 if (InstName
.getAsDependentTemplateName())
721 return SemaRef
.Context
.getDependentTemplateSpecializationType(
722 Keyword
, Qualifier
, Name
, Args
);
724 // Otherwise, make an elaborated type wrapping a non-dependent
727 getDerived().RebuildTemplateSpecializationType(InstName
, NameLoc
, Args
);
728 if (T
.isNull()) return QualType();
730 // NOTE: NNS is already recorded in template specialization type T.
731 return SemaRef
.Context
.getElaboratedType(Keyword
, /*NNS=*/0, T
);
734 /// \brief Build a new typename type that refers to an identifier.
736 /// By default, performs semantic analysis when building the typename type
737 /// (or elaborated type). Subclasses may override this routine to provide
738 /// different behavior.
739 QualType
RebuildDependentNameType(ElaboratedTypeKeyword Keyword
,
740 NestedNameSpecifier
*NNS
,
741 const IdentifierInfo
*Id
,
742 SourceLocation KeywordLoc
,
743 SourceRange NNSRange
,
744 SourceLocation IdLoc
) {
747 SS
.setRange(NNSRange
);
749 if (NNS
->isDependent()) {
750 // If the name is still dependent, just build a new dependent name type.
751 if (!SemaRef
.computeDeclContext(SS
))
752 return SemaRef
.Context
.getDependentNameType(Keyword
, NNS
, Id
);
755 if (Keyword
== ETK_None
|| Keyword
== ETK_Typename
)
756 return SemaRef
.CheckTypenameType(Keyword
, NNS
, *Id
,
757 KeywordLoc
, NNSRange
, IdLoc
);
759 TagTypeKind Kind
= TypeWithKeyword::getTagTypeKindForKeyword(Keyword
);
761 // We had a dependent elaborated-type-specifier that has been transformed
762 // into a non-dependent elaborated-type-specifier. Find the tag we're
764 LookupResult
Result(SemaRef
, Id
, IdLoc
, Sema::LookupTagName
);
765 DeclContext
*DC
= SemaRef
.computeDeclContext(SS
, false);
769 if (SemaRef
.RequireCompleteDeclContext(SS
, DC
))
773 SemaRef
.LookupQualifiedName(Result
, DC
);
774 switch (Result
.getResultKind()) {
775 case LookupResult::NotFound
:
776 case LookupResult::NotFoundInCurrentInstantiation
:
779 case LookupResult::Found
:
780 Tag
= Result
.getAsSingle
<TagDecl
>();
783 case LookupResult::FoundOverloaded
:
784 case LookupResult::FoundUnresolvedValue
:
785 llvm_unreachable("Tag lookup cannot find non-tags");
788 case LookupResult::Ambiguous
:
789 // Let the LookupResult structure handle ambiguities.
794 // FIXME: Would be nice to highlight just the source range.
795 SemaRef
.Diag(IdLoc
, diag::err_not_tag_in_scope
)
800 if (!SemaRef
.isAcceptableTagRedeclaration(Tag
, Kind
, IdLoc
, *Id
)) {
801 SemaRef
.Diag(KeywordLoc
, diag::err_use_with_wrong_tag
) << Id
;
802 SemaRef
.Diag(Tag
->getLocation(), diag::note_previous_use
);
806 // Build the elaborated-type-specifier type.
807 QualType T
= SemaRef
.Context
.getTypeDeclType(Tag
);
808 return SemaRef
.Context
.getElaboratedType(Keyword
, NNS
, T
);
811 /// \brief Build a new nested-name-specifier given the prefix and an
812 /// identifier that names the next step in the nested-name-specifier.
814 /// By default, performs semantic analysis when building the new
815 /// nested-name-specifier. Subclasses may override this routine to provide
816 /// different behavior.
817 NestedNameSpecifier
*RebuildNestedNameSpecifier(NestedNameSpecifier
*Prefix
,
821 NamedDecl
*FirstQualifierInScope
);
823 /// \brief Build a new nested-name-specifier given the prefix and the
824 /// namespace named in the next step in the nested-name-specifier.
826 /// By default, performs semantic analysis when building the new
827 /// nested-name-specifier. Subclasses may override this routine to provide
828 /// different behavior.
829 NestedNameSpecifier
*RebuildNestedNameSpecifier(NestedNameSpecifier
*Prefix
,
833 /// \brief Build a new nested-name-specifier given the prefix and the
834 /// type named in the next step in the nested-name-specifier.
836 /// By default, performs semantic analysis when building the new
837 /// nested-name-specifier. Subclasses may override this routine to provide
838 /// different behavior.
839 NestedNameSpecifier
*RebuildNestedNameSpecifier(NestedNameSpecifier
*Prefix
,
844 /// \brief Build a new template name given a nested name specifier, a flag
845 /// indicating whether the "template" keyword was provided, and the template
846 /// that the template name refers to.
848 /// By default, builds the new template name directly. Subclasses may override
849 /// this routine to provide different behavior.
850 TemplateName
RebuildTemplateName(NestedNameSpecifier
*Qualifier
,
852 TemplateDecl
*Template
);
854 /// \brief Build a new template name given a nested name specifier and the
855 /// name that is referred to as a template.
857 /// By default, performs semantic analysis to determine whether the name can
858 /// be resolved to a specific template, then builds the appropriate kind of
859 /// template name. Subclasses may override this routine to provide different
861 TemplateName
RebuildTemplateName(NestedNameSpecifier
*Qualifier
,
862 SourceRange QualifierRange
,
863 const IdentifierInfo
&II
,
865 NamedDecl
*FirstQualifierInScope
);
867 /// \brief Build a new template name given a nested name specifier and the
868 /// overloaded operator name that is referred to as a template.
870 /// By default, performs semantic analysis to determine whether the name can
871 /// be resolved to a specific template, then builds the appropriate kind of
872 /// template name. Subclasses may override this routine to provide different
874 TemplateName
RebuildTemplateName(NestedNameSpecifier
*Qualifier
,
875 OverloadedOperatorKind Operator
,
876 QualType ObjectType
);
878 /// \brief Build a new compound statement.
880 /// By default, performs semantic analysis to build the new statement.
881 /// Subclasses may override this routine to provide different behavior.
882 StmtResult
RebuildCompoundStmt(SourceLocation LBraceLoc
,
883 MultiStmtArg Statements
,
884 SourceLocation RBraceLoc
,
886 return getSema().ActOnCompoundStmt(LBraceLoc
, RBraceLoc
, Statements
,
890 /// \brief Build a new case statement.
892 /// By default, performs semantic analysis to build the new statement.
893 /// Subclasses may override this routine to provide different behavior.
894 StmtResult
RebuildCaseStmt(SourceLocation CaseLoc
,
896 SourceLocation EllipsisLoc
,
898 SourceLocation ColonLoc
) {
899 return getSema().ActOnCaseStmt(CaseLoc
, LHS
, EllipsisLoc
, RHS
,
903 /// \brief Attach the body to a new case statement.
905 /// By default, performs semantic analysis to build the new statement.
906 /// Subclasses may override this routine to provide different behavior.
907 StmtResult
RebuildCaseStmtBody(Stmt
*S
, Stmt
*Body
) {
908 getSema().ActOnCaseStmtBody(S
, Body
);
912 /// \brief Build a new default statement.
914 /// By default, performs semantic analysis to build the new statement.
915 /// Subclasses may override this routine to provide different behavior.
916 StmtResult
RebuildDefaultStmt(SourceLocation DefaultLoc
,
917 SourceLocation ColonLoc
,
919 return getSema().ActOnDefaultStmt(DefaultLoc
, ColonLoc
, SubStmt
,
923 /// \brief Build a new label statement.
925 /// By default, performs semantic analysis to build the new statement.
926 /// Subclasses may override this routine to provide different behavior.
927 StmtResult
RebuildLabelStmt(SourceLocation IdentLoc
,
929 SourceLocation ColonLoc
,
930 Stmt
*SubStmt
, bool HasUnusedAttr
) {
931 return SemaRef
.ActOnLabelStmt(IdentLoc
, Id
, ColonLoc
, SubStmt
,
935 /// \brief Build a new "if" statement.
937 /// By default, performs semantic analysis to build the new statement.
938 /// Subclasses may override this routine to provide different behavior.
939 StmtResult
RebuildIfStmt(SourceLocation IfLoc
, Sema::FullExprArg Cond
,
940 VarDecl
*CondVar
, Stmt
*Then
,
941 SourceLocation ElseLoc
, Stmt
*Else
) {
942 return getSema().ActOnIfStmt(IfLoc
, Cond
, CondVar
, Then
, ElseLoc
, Else
);
945 /// \brief Start building a new switch statement.
947 /// By default, performs semantic analysis to build the new statement.
948 /// Subclasses may override this routine to provide different behavior.
949 StmtResult
RebuildSwitchStmtStart(SourceLocation SwitchLoc
,
950 Expr
*Cond
, VarDecl
*CondVar
) {
951 return getSema().ActOnStartOfSwitchStmt(SwitchLoc
, Cond
,
955 /// \brief Attach the body to the switch statement.
957 /// By default, performs semantic analysis to build the new statement.
958 /// Subclasses may override this routine to provide different behavior.
959 StmtResult
RebuildSwitchStmtBody(SourceLocation SwitchLoc
,
960 Stmt
*Switch
, Stmt
*Body
) {
961 return getSema().ActOnFinishSwitchStmt(SwitchLoc
, Switch
, Body
);
964 /// \brief Build a new while statement.
966 /// By default, performs semantic analysis to build the new statement.
967 /// Subclasses may override this routine to provide different behavior.
968 StmtResult
RebuildWhileStmt(SourceLocation WhileLoc
,
969 Sema::FullExprArg Cond
,
972 return getSema().ActOnWhileStmt(WhileLoc
, Cond
, CondVar
, Body
);
975 /// \brief Build a new do-while statement.
977 /// By default, performs semantic analysis to build the new statement.
978 /// Subclasses may override this routine to provide different behavior.
979 StmtResult
RebuildDoStmt(SourceLocation DoLoc
, Stmt
*Body
,
980 SourceLocation WhileLoc
,
981 SourceLocation LParenLoc
,
983 SourceLocation RParenLoc
) {
984 return getSema().ActOnDoStmt(DoLoc
, Body
, WhileLoc
, LParenLoc
,
988 /// \brief Build a new for statement.
990 /// By default, performs semantic analysis to build the new statement.
991 /// Subclasses may override this routine to provide different behavior.
992 StmtResult
RebuildForStmt(SourceLocation ForLoc
,
993 SourceLocation LParenLoc
,
994 Stmt
*Init
, Sema::FullExprArg Cond
,
995 VarDecl
*CondVar
, Sema::FullExprArg Inc
,
996 SourceLocation RParenLoc
, Stmt
*Body
) {
997 return getSema().ActOnForStmt(ForLoc
, LParenLoc
, Init
, Cond
,
999 Inc
, RParenLoc
, Body
);
1002 /// \brief Build a new goto statement.
1004 /// By default, performs semantic analysis to build the new statement.
1005 /// Subclasses may override this routine to provide different behavior.
1006 StmtResult
RebuildGotoStmt(SourceLocation GotoLoc
,
1007 SourceLocation LabelLoc
,
1009 return getSema().ActOnGotoStmt(GotoLoc
, LabelLoc
, Label
->getID());
1012 /// \brief Build a new indirect goto statement.
1014 /// By default, performs semantic analysis to build the new statement.
1015 /// Subclasses may override this routine to provide different behavior.
1016 StmtResult
RebuildIndirectGotoStmt(SourceLocation GotoLoc
,
1017 SourceLocation StarLoc
,
1019 return getSema().ActOnIndirectGotoStmt(GotoLoc
, StarLoc
, Target
);
1022 /// \brief Build a new return statement.
1024 /// By default, performs semantic analysis to build the new statement.
1025 /// Subclasses may override this routine to provide different behavior.
1026 StmtResult
RebuildReturnStmt(SourceLocation ReturnLoc
,
1029 return getSema().ActOnReturnStmt(ReturnLoc
, Result
);
1032 /// \brief Build a new declaration statement.
1034 /// By default, performs semantic analysis to build the new statement.
1035 /// Subclasses may override this routine to provide different behavior.
1036 StmtResult
RebuildDeclStmt(Decl
**Decls
, unsigned NumDecls
,
1037 SourceLocation StartLoc
,
1038 SourceLocation EndLoc
) {
1039 return getSema().Owned(
1040 new (getSema().Context
) DeclStmt(
1041 DeclGroupRef::Create(getSema().Context
,
1046 /// \brief Build a new inline asm statement.
1048 /// By default, performs semantic analysis to build the new statement.
1049 /// Subclasses may override this routine to provide different behavior.
1050 StmtResult
RebuildAsmStmt(SourceLocation AsmLoc
,
1053 unsigned NumOutputs
,
1055 IdentifierInfo
**Names
,
1056 MultiExprArg Constraints
,
1059 MultiExprArg Clobbers
,
1060 SourceLocation RParenLoc
,
1062 return getSema().ActOnAsmStmt(AsmLoc
, IsSimple
, IsVolatile
, NumOutputs
,
1063 NumInputs
, Names
, move(Constraints
),
1064 Exprs
, AsmString
, Clobbers
,
1068 /// \brief Build a new Objective-C @try statement.
1070 /// By default, performs semantic analysis to build the new statement.
1071 /// Subclasses may override this routine to provide different behavior.
1072 StmtResult
RebuildObjCAtTryStmt(SourceLocation AtLoc
,
1074 MultiStmtArg CatchStmts
,
1076 return getSema().ActOnObjCAtTryStmt(AtLoc
, TryBody
, move(CatchStmts
),
1080 /// \brief Rebuild an Objective-C exception declaration.
1082 /// By default, performs semantic analysis to build the new declaration.
1083 /// Subclasses may override this routine to provide different behavior.
1084 VarDecl
*RebuildObjCExceptionDecl(VarDecl
*ExceptionDecl
,
1085 TypeSourceInfo
*TInfo
, QualType T
) {
1086 return getSema().BuildObjCExceptionDecl(TInfo
, T
,
1087 ExceptionDecl
->getIdentifier(),
1088 ExceptionDecl
->getLocation());
1091 /// \brief Build a new Objective-C @catch statement.
1093 /// By default, performs semantic analysis to build the new statement.
1094 /// Subclasses may override this routine to provide different behavior.
1095 StmtResult
RebuildObjCAtCatchStmt(SourceLocation AtLoc
,
1096 SourceLocation RParenLoc
,
1099 return getSema().ActOnObjCAtCatchStmt(AtLoc
, RParenLoc
,
1103 /// \brief Build a new Objective-C @finally statement.
1105 /// By default, performs semantic analysis to build the new statement.
1106 /// Subclasses may override this routine to provide different behavior.
1107 StmtResult
RebuildObjCAtFinallyStmt(SourceLocation AtLoc
,
1109 return getSema().ActOnObjCAtFinallyStmt(AtLoc
, Body
);
1112 /// \brief Build a new Objective-C @throw statement.
1114 /// By default, performs semantic analysis to build the new statement.
1115 /// Subclasses may override this routine to provide different behavior.
1116 StmtResult
RebuildObjCAtThrowStmt(SourceLocation AtLoc
,
1118 return getSema().BuildObjCAtThrowStmt(AtLoc
, Operand
);
1121 /// \brief Build a new Objective-C @synchronized statement.
1123 /// By default, performs semantic analysis to build the new statement.
1124 /// Subclasses may override this routine to provide different behavior.
1125 StmtResult
RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc
,
1128 return getSema().ActOnObjCAtSynchronizedStmt(AtLoc
, Object
,
1132 /// \brief Build a new Objective-C fast enumeration statement.
1134 /// By default, performs semantic analysis to build the new statement.
1135 /// Subclasses may override this routine to provide different behavior.
1136 StmtResult
RebuildObjCForCollectionStmt(SourceLocation ForLoc
,
1137 SourceLocation LParenLoc
,
1140 SourceLocation RParenLoc
,
1142 return getSema().ActOnObjCForCollectionStmt(ForLoc
, LParenLoc
,
1149 /// \brief Build a new C++ exception declaration.
1151 /// By default, performs semantic analysis to build the new decaration.
1152 /// Subclasses may override this routine to provide different behavior.
1153 VarDecl
*RebuildExceptionDecl(VarDecl
*ExceptionDecl
,
1154 TypeSourceInfo
*Declarator
,
1155 IdentifierInfo
*Name
,
1156 SourceLocation Loc
) {
1157 return getSema().BuildExceptionDeclaration(0, Declarator
, Name
, Loc
);
1160 /// \brief Build a new C++ catch statement.
1162 /// By default, performs semantic analysis to build the new statement.
1163 /// Subclasses may override this routine to provide different behavior.
1164 StmtResult
RebuildCXXCatchStmt(SourceLocation CatchLoc
,
1165 VarDecl
*ExceptionDecl
,
1167 return Owned(new (getSema().Context
) CXXCatchStmt(CatchLoc
, ExceptionDecl
,
1171 /// \brief Build a new C++ try statement.
1173 /// By default, performs semantic analysis to build the new statement.
1174 /// Subclasses may override this routine to provide different behavior.
1175 StmtResult
RebuildCXXTryStmt(SourceLocation TryLoc
,
1177 MultiStmtArg Handlers
) {
1178 return getSema().ActOnCXXTryBlock(TryLoc
, TryBlock
, move(Handlers
));
1181 /// \brief Build a new expression that references a declaration.
1183 /// By default, performs semantic analysis to build the new expression.
1184 /// Subclasses may override this routine to provide different behavior.
1185 ExprResult
RebuildDeclarationNameExpr(const CXXScopeSpec
&SS
,
1188 return getSema().BuildDeclarationNameExpr(SS
, R
, RequiresADL
);
1192 /// \brief Build a new expression that references a declaration.
1194 /// By default, performs semantic analysis to build the new expression.
1195 /// Subclasses may override this routine to provide different behavior.
1196 ExprResult
RebuildDeclRefExpr(NestedNameSpecifier
*Qualifier
,
1197 SourceRange QualifierRange
,
1199 const DeclarationNameInfo
&NameInfo
,
1200 TemplateArgumentListInfo
*TemplateArgs
) {
1202 SS
.setScopeRep(Qualifier
);
1203 SS
.setRange(QualifierRange
);
1205 // FIXME: loses template args.
1207 return getSema().BuildDeclarationNameExpr(SS
, NameInfo
, VD
);
1210 /// \brief Build a new expression in parentheses.
1212 /// By default, performs semantic analysis to build the new expression.
1213 /// Subclasses may override this routine to provide different behavior.
1214 ExprResult
RebuildParenExpr(Expr
*SubExpr
, SourceLocation LParen
,
1215 SourceLocation RParen
) {
1216 return getSema().ActOnParenExpr(LParen
, RParen
, SubExpr
);
1219 /// \brief Build a new pseudo-destructor expression.
1221 /// By default, performs semantic analysis to build the new expression.
1222 /// Subclasses may override this routine to provide different behavior.
1223 ExprResult
RebuildCXXPseudoDestructorExpr(Expr
*Base
,
1224 SourceLocation OperatorLoc
,
1226 NestedNameSpecifier
*Qualifier
,
1227 SourceRange QualifierRange
,
1228 TypeSourceInfo
*ScopeType
,
1229 SourceLocation CCLoc
,
1230 SourceLocation TildeLoc
,
1231 PseudoDestructorTypeStorage Destroyed
);
1233 /// \brief Build a new unary operator expression.
1235 /// By default, performs semantic analysis to build the new expression.
1236 /// Subclasses may override this routine to provide different behavior.
1237 ExprResult
RebuildUnaryOperator(SourceLocation OpLoc
,
1238 UnaryOperatorKind Opc
,
1240 return getSema().BuildUnaryOp(/*Scope=*/0, OpLoc
, Opc
, SubExpr
);
1243 /// \brief Build a new builtin offsetof expression.
1245 /// By default, performs semantic analysis to build the new expression.
1246 /// Subclasses may override this routine to provide different behavior.
1247 ExprResult
RebuildOffsetOfExpr(SourceLocation OperatorLoc
,
1248 TypeSourceInfo
*Type
,
1249 Sema::OffsetOfComponent
*Components
,
1250 unsigned NumComponents
,
1251 SourceLocation RParenLoc
) {
1252 return getSema().BuildBuiltinOffsetOf(OperatorLoc
, Type
, Components
,
1253 NumComponents
, RParenLoc
);
1256 /// \brief Build a new sizeof or alignof expression with a type argument.
1258 /// By default, performs semantic analysis to build the new expression.
1259 /// Subclasses may override this routine to provide different behavior.
1260 ExprResult
RebuildSizeOfAlignOf(TypeSourceInfo
*TInfo
,
1261 SourceLocation OpLoc
,
1262 bool isSizeOf
, SourceRange R
) {
1263 return getSema().CreateSizeOfAlignOfExpr(TInfo
, OpLoc
, isSizeOf
, R
);
1266 /// \brief Build a new sizeof or alignof expression with an expression
1269 /// By default, performs semantic analysis to build the new expression.
1270 /// Subclasses may override this routine to provide different behavior.
1271 ExprResult
RebuildSizeOfAlignOf(Expr
*SubExpr
, SourceLocation OpLoc
,
1272 bool isSizeOf
, SourceRange R
) {
1274 = getSema().CreateSizeOfAlignOfExpr(SubExpr
, OpLoc
, isSizeOf
, R
);
1275 if (Result
.isInvalid())
1278 return move(Result
);
1281 /// \brief Build a new array subscript expression.
1283 /// By default, performs semantic analysis to build the new expression.
1284 /// Subclasses may override this routine to provide different behavior.
1285 ExprResult
RebuildArraySubscriptExpr(Expr
*LHS
,
1286 SourceLocation LBracketLoc
,
1288 SourceLocation RBracketLoc
) {
1289 return getSema().ActOnArraySubscriptExpr(/*Scope=*/0, LHS
,
1294 /// \brief Build a new call expression.
1296 /// By default, performs semantic analysis to build the new expression.
1297 /// Subclasses may override this routine to provide different behavior.
1298 ExprResult
RebuildCallExpr(Expr
*Callee
, SourceLocation LParenLoc
,
1300 SourceLocation RParenLoc
) {
1301 return getSema().ActOnCallExpr(/*Scope=*/0, Callee
, LParenLoc
,
1302 move(Args
), RParenLoc
);
1305 /// \brief Build a new member access expression.
1307 /// By default, performs semantic analysis to build the new expression.
1308 /// Subclasses may override this routine to provide different behavior.
1309 ExprResult
RebuildMemberExpr(Expr
*Base
, SourceLocation OpLoc
,
1311 NestedNameSpecifier
*Qualifier
,
1312 SourceRange QualifierRange
,
1313 const DeclarationNameInfo
&MemberNameInfo
,
1315 NamedDecl
*FoundDecl
,
1316 const TemplateArgumentListInfo
*ExplicitTemplateArgs
,
1317 NamedDecl
*FirstQualifierInScope
) {
1318 if (!Member
->getDeclName()) {
1319 // We have a reference to an unnamed field. This is always the
1320 // base of an anonymous struct/union member access, i.e. the
1321 // field is always of record type.
1322 assert(!Qualifier
&& "Can't have an unnamed field with a qualifier!");
1323 assert(Member
->getType()->isRecordType() &&
1324 "unnamed member not of record type?");
1326 if (getSema().PerformObjectMemberConversion(Base
, Qualifier
,
1330 ExprValueKind VK
= isArrow
? VK_LValue
: Base
->getValueKind();
1332 new (getSema().Context
) MemberExpr(Base
, isArrow
,
1333 Member
, MemberNameInfo
,
1334 cast
<FieldDecl
>(Member
)->getType(),
1336 return getSema().Owned(ME
);
1341 SS
.setRange(QualifierRange
);
1342 SS
.setScopeRep(Qualifier
);
1345 getSema().DefaultFunctionArrayConversion(Base
);
1346 QualType BaseType
= Base
->getType();
1348 // FIXME: this involves duplicating earlier analysis in a lot of
1349 // cases; we should avoid this when possible.
1350 LookupResult
R(getSema(), MemberNameInfo
, Sema::LookupMemberName
);
1351 R
.addDecl(FoundDecl
);
1354 return getSema().BuildMemberReferenceExpr(Base
, BaseType
, OpLoc
, isArrow
,
1355 SS
, FirstQualifierInScope
,
1356 R
, ExplicitTemplateArgs
);
1359 /// \brief Build a new binary operator expression.
1361 /// By default, performs semantic analysis to build the new expression.
1362 /// Subclasses may override this routine to provide different behavior.
1363 ExprResult
RebuildBinaryOperator(SourceLocation OpLoc
,
1364 BinaryOperatorKind Opc
,
1365 Expr
*LHS
, Expr
*RHS
) {
1366 return getSema().BuildBinOp(/*Scope=*/0, OpLoc
, Opc
, LHS
, RHS
);
1369 /// \brief Build a new conditional operator expression.
1371 /// By default, performs semantic analysis to build the new expression.
1372 /// Subclasses may override this routine to provide different behavior.
1373 ExprResult
RebuildConditionalOperator(Expr
*Cond
,
1374 SourceLocation QuestionLoc
,
1376 SourceLocation ColonLoc
,
1378 return getSema().ActOnConditionalOp(QuestionLoc
, ColonLoc
, Cond
,
1382 /// \brief Build a new C-style cast expression.
1384 /// By default, performs semantic analysis to build the new expression.
1385 /// Subclasses may override this routine to provide different behavior.
1386 ExprResult
RebuildCStyleCastExpr(SourceLocation LParenLoc
,
1387 TypeSourceInfo
*TInfo
,
1388 SourceLocation RParenLoc
,
1390 return getSema().BuildCStyleCastExpr(LParenLoc
, TInfo
, RParenLoc
,
1394 /// \brief Build a new compound literal expression.
1396 /// By default, performs semantic analysis to build the new expression.
1397 /// Subclasses may override this routine to provide different behavior.
1398 ExprResult
RebuildCompoundLiteralExpr(SourceLocation LParenLoc
,
1399 TypeSourceInfo
*TInfo
,
1400 SourceLocation RParenLoc
,
1402 return getSema().BuildCompoundLiteralExpr(LParenLoc
, TInfo
, RParenLoc
,
1406 /// \brief Build a new extended vector element access expression.
1408 /// By default, performs semantic analysis to build the new expression.
1409 /// Subclasses may override this routine to provide different behavior.
1410 ExprResult
RebuildExtVectorElementExpr(Expr
*Base
,
1411 SourceLocation OpLoc
,
1412 SourceLocation AccessorLoc
,
1413 IdentifierInfo
&Accessor
) {
1416 DeclarationNameInfo
NameInfo(&Accessor
, AccessorLoc
);
1417 return getSema().BuildMemberReferenceExpr(Base
, Base
->getType(),
1418 OpLoc
, /*IsArrow*/ false,
1419 SS
, /*FirstQualifierInScope*/ 0,
1421 /* TemplateArgs */ 0);
1424 /// \brief Build a new initializer list expression.
1426 /// By default, performs semantic analysis to build the new expression.
1427 /// Subclasses may override this routine to provide different behavior.
1428 ExprResult
RebuildInitList(SourceLocation LBraceLoc
,
1430 SourceLocation RBraceLoc
,
1431 QualType ResultTy
) {
1433 = SemaRef
.ActOnInitList(LBraceLoc
, move(Inits
), RBraceLoc
);
1434 if (Result
.isInvalid() || ResultTy
->isDependentType())
1435 return move(Result
);
1437 // Patch in the result type we were given, which may have been computed
1438 // when the initial InitListExpr was built.
1439 InitListExpr
*ILE
= cast
<InitListExpr
>((Expr
*)Result
.get());
1440 ILE
->setType(ResultTy
);
1441 return move(Result
);
1444 /// \brief Build a new designated initializer expression.
1446 /// By default, performs semantic analysis to build the new expression.
1447 /// Subclasses may override this routine to provide different behavior.
1448 ExprResult
RebuildDesignatedInitExpr(Designation
&Desig
,
1449 MultiExprArg ArrayExprs
,
1450 SourceLocation EqualOrColonLoc
,
1454 = SemaRef
.ActOnDesignatedInitializer(Desig
, EqualOrColonLoc
, GNUSyntax
,
1456 if (Result
.isInvalid())
1459 ArrayExprs
.release();
1460 return move(Result
);
1463 /// \brief Build a new value-initialized expression.
1465 /// By default, builds the implicit value initialization without performing
1466 /// any semantic analysis. Subclasses may override this routine to provide
1467 /// different behavior.
1468 ExprResult
RebuildImplicitValueInitExpr(QualType T
) {
1469 return SemaRef
.Owned(new (SemaRef
.Context
) ImplicitValueInitExpr(T
));
1472 /// \brief Build a new \c va_arg expression.
1474 /// By default, performs semantic analysis to build the new expression.
1475 /// Subclasses may override this routine to provide different behavior.
1476 ExprResult
RebuildVAArgExpr(SourceLocation BuiltinLoc
,
1477 Expr
*SubExpr
, TypeSourceInfo
*TInfo
,
1478 SourceLocation RParenLoc
) {
1479 return getSema().BuildVAArgExpr(BuiltinLoc
,
1484 /// \brief Build a new expression list in parentheses.
1486 /// By default, performs semantic analysis to build the new expression.
1487 /// Subclasses may override this routine to provide different behavior.
1488 ExprResult
RebuildParenListExpr(SourceLocation LParenLoc
,
1489 MultiExprArg SubExprs
,
1490 SourceLocation RParenLoc
) {
1491 return getSema().ActOnParenOrParenListExpr(LParenLoc
, RParenLoc
,
1495 /// \brief Build a new address-of-label expression.
1497 /// By default, performs semantic analysis, using the name of the label
1498 /// rather than attempting to map the label statement itself.
1499 /// Subclasses may override this routine to provide different behavior.
1500 ExprResult
RebuildAddrLabelExpr(SourceLocation AmpAmpLoc
,
1501 SourceLocation LabelLoc
,
1503 return getSema().ActOnAddrLabel(AmpAmpLoc
, LabelLoc
, Label
->getID());
1506 /// \brief Build a new GNU statement expression.
1508 /// By default, performs semantic analysis to build the new expression.
1509 /// Subclasses may override this routine to provide different behavior.
1510 ExprResult
RebuildStmtExpr(SourceLocation LParenLoc
,
1512 SourceLocation RParenLoc
) {
1513 return getSema().ActOnStmtExpr(LParenLoc
, SubStmt
, RParenLoc
);
1516 /// \brief Build a new __builtin_choose_expr expression.
1518 /// By default, performs semantic analysis to build the new expression.
1519 /// Subclasses may override this routine to provide different behavior.
1520 ExprResult
RebuildChooseExpr(SourceLocation BuiltinLoc
,
1521 Expr
*Cond
, Expr
*LHS
, Expr
*RHS
,
1522 SourceLocation RParenLoc
) {
1523 return SemaRef
.ActOnChooseExpr(BuiltinLoc
,
1528 /// \brief Build a new overloaded operator call expression.
1530 /// By default, performs semantic analysis to build the new expression.
1531 /// The semantic analysis provides the behavior of template instantiation,
1532 /// copying with transformations that turn what looks like an overloaded
1533 /// operator call into a use of a builtin operator, performing
1534 /// argument-dependent lookup, etc. Subclasses may override this routine to
1535 /// provide different behavior.
1536 ExprResult
RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op
,
1537 SourceLocation OpLoc
,
1542 /// \brief Build a new C++ "named" cast expression, such as static_cast or
1543 /// reinterpret_cast.
1545 /// By default, this routine dispatches to one of the more-specific routines
1546 /// for a particular named case, e.g., RebuildCXXStaticCastExpr().
1547 /// Subclasses may override this routine to provide different behavior.
1548 ExprResult
RebuildCXXNamedCastExpr(SourceLocation OpLoc
,
1549 Stmt::StmtClass Class
,
1550 SourceLocation LAngleLoc
,
1551 TypeSourceInfo
*TInfo
,
1552 SourceLocation RAngleLoc
,
1553 SourceLocation LParenLoc
,
1555 SourceLocation RParenLoc
) {
1557 case Stmt::CXXStaticCastExprClass
:
1558 return getDerived().RebuildCXXStaticCastExpr(OpLoc
, LAngleLoc
, TInfo
,
1559 RAngleLoc
, LParenLoc
,
1560 SubExpr
, RParenLoc
);
1562 case Stmt::CXXDynamicCastExprClass
:
1563 return getDerived().RebuildCXXDynamicCastExpr(OpLoc
, LAngleLoc
, TInfo
,
1564 RAngleLoc
, LParenLoc
,
1565 SubExpr
, RParenLoc
);
1567 case Stmt::CXXReinterpretCastExprClass
:
1568 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc
, LAngleLoc
, TInfo
,
1569 RAngleLoc
, LParenLoc
,
1573 case Stmt::CXXConstCastExprClass
:
1574 return getDerived().RebuildCXXConstCastExpr(OpLoc
, LAngleLoc
, TInfo
,
1575 RAngleLoc
, LParenLoc
,
1576 SubExpr
, RParenLoc
);
1579 assert(false && "Invalid C++ named cast");
1586 /// \brief Build a new C++ static_cast expression.
1588 /// By default, performs semantic analysis to build the new expression.
1589 /// Subclasses may override this routine to provide different behavior.
1590 ExprResult
RebuildCXXStaticCastExpr(SourceLocation OpLoc
,
1591 SourceLocation LAngleLoc
,
1592 TypeSourceInfo
*TInfo
,
1593 SourceLocation RAngleLoc
,
1594 SourceLocation LParenLoc
,
1596 SourceLocation RParenLoc
) {
1597 return getSema().BuildCXXNamedCast(OpLoc
, tok::kw_static_cast
,
1599 SourceRange(LAngleLoc
, RAngleLoc
),
1600 SourceRange(LParenLoc
, RParenLoc
));
1603 /// \brief Build a new C++ dynamic_cast expression.
1605 /// By default, performs semantic analysis to build the new expression.
1606 /// Subclasses may override this routine to provide different behavior.
1607 ExprResult
RebuildCXXDynamicCastExpr(SourceLocation OpLoc
,
1608 SourceLocation LAngleLoc
,
1609 TypeSourceInfo
*TInfo
,
1610 SourceLocation RAngleLoc
,
1611 SourceLocation LParenLoc
,
1613 SourceLocation RParenLoc
) {
1614 return getSema().BuildCXXNamedCast(OpLoc
, tok::kw_dynamic_cast
,
1616 SourceRange(LAngleLoc
, RAngleLoc
),
1617 SourceRange(LParenLoc
, RParenLoc
));
1620 /// \brief Build a new C++ reinterpret_cast expression.
1622 /// By default, performs semantic analysis to build the new expression.
1623 /// Subclasses may override this routine to provide different behavior.
1624 ExprResult
RebuildCXXReinterpretCastExpr(SourceLocation OpLoc
,
1625 SourceLocation LAngleLoc
,
1626 TypeSourceInfo
*TInfo
,
1627 SourceLocation RAngleLoc
,
1628 SourceLocation LParenLoc
,
1630 SourceLocation RParenLoc
) {
1631 return getSema().BuildCXXNamedCast(OpLoc
, tok::kw_reinterpret_cast
,
1633 SourceRange(LAngleLoc
, RAngleLoc
),
1634 SourceRange(LParenLoc
, RParenLoc
));
1637 /// \brief Build a new C++ const_cast expression.
1639 /// By default, performs semantic analysis to build the new expression.
1640 /// Subclasses may override this routine to provide different behavior.
1641 ExprResult
RebuildCXXConstCastExpr(SourceLocation OpLoc
,
1642 SourceLocation LAngleLoc
,
1643 TypeSourceInfo
*TInfo
,
1644 SourceLocation RAngleLoc
,
1645 SourceLocation LParenLoc
,
1647 SourceLocation RParenLoc
) {
1648 return getSema().BuildCXXNamedCast(OpLoc
, tok::kw_const_cast
,
1650 SourceRange(LAngleLoc
, RAngleLoc
),
1651 SourceRange(LParenLoc
, RParenLoc
));
1654 /// \brief Build a new C++ functional-style cast expression.
1656 /// By default, performs semantic analysis to build the new expression.
1657 /// Subclasses may override this routine to provide different behavior.
1658 ExprResult
RebuildCXXFunctionalCastExpr(TypeSourceInfo
*TInfo
,
1659 SourceLocation LParenLoc
,
1661 SourceLocation RParenLoc
) {
1662 return getSema().BuildCXXTypeConstructExpr(TInfo
, LParenLoc
,
1663 MultiExprArg(&Sub
, 1),
1667 /// \brief Build a new C++ typeid(type) expression.
1669 /// By default, performs semantic analysis to build the new expression.
1670 /// Subclasses may override this routine to provide different behavior.
1671 ExprResult
RebuildCXXTypeidExpr(QualType TypeInfoType
,
1672 SourceLocation TypeidLoc
,
1673 TypeSourceInfo
*Operand
,
1674 SourceLocation RParenLoc
) {
1675 return getSema().BuildCXXTypeId(TypeInfoType
, TypeidLoc
, Operand
,
1680 /// \brief Build a new C++ typeid(expr) expression.
1682 /// By default, performs semantic analysis to build the new expression.
1683 /// Subclasses may override this routine to provide different behavior.
1684 ExprResult
RebuildCXXTypeidExpr(QualType TypeInfoType
,
1685 SourceLocation TypeidLoc
,
1687 SourceLocation RParenLoc
) {
1688 return getSema().BuildCXXTypeId(TypeInfoType
, TypeidLoc
, Operand
,
1692 /// \brief Build a new C++ __uuidof(type) expression.
1694 /// By default, performs semantic analysis to build the new expression.
1695 /// Subclasses may override this routine to provide different behavior.
1696 ExprResult
RebuildCXXUuidofExpr(QualType TypeInfoType
,
1697 SourceLocation TypeidLoc
,
1698 TypeSourceInfo
*Operand
,
1699 SourceLocation RParenLoc
) {
1700 return getSema().BuildCXXUuidof(TypeInfoType
, TypeidLoc
, Operand
,
1704 /// \brief Build a new C++ __uuidof(expr) expression.
1706 /// By default, performs semantic analysis to build the new expression.
1707 /// Subclasses may override this routine to provide different behavior.
1708 ExprResult
RebuildCXXUuidofExpr(QualType TypeInfoType
,
1709 SourceLocation TypeidLoc
,
1711 SourceLocation RParenLoc
) {
1712 return getSema().BuildCXXUuidof(TypeInfoType
, TypeidLoc
, Operand
,
1716 /// \brief Build a new C++ "this" expression.
1718 /// By default, builds a new "this" expression without performing any
1719 /// semantic analysis. Subclasses may override this routine to provide
1720 /// different behavior.
1721 ExprResult
RebuildCXXThisExpr(SourceLocation ThisLoc
,
1724 return getSema().Owned(
1725 new (getSema().Context
) CXXThisExpr(ThisLoc
, ThisType
,
1729 /// \brief Build a new C++ throw expression.
1731 /// By default, performs semantic analysis to build the new expression.
1732 /// Subclasses may override this routine to provide different behavior.
1733 ExprResult
RebuildCXXThrowExpr(SourceLocation ThrowLoc
, Expr
*Sub
) {
1734 return getSema().ActOnCXXThrow(ThrowLoc
, Sub
);
1737 /// \brief Build a new C++ default-argument expression.
1739 /// By default, builds a new default-argument expression, which does not
1740 /// require any semantic analysis. Subclasses may override this routine to
1741 /// provide different behavior.
1742 ExprResult
RebuildCXXDefaultArgExpr(SourceLocation Loc
,
1743 ParmVarDecl
*Param
) {
1744 return getSema().Owned(CXXDefaultArgExpr::Create(getSema().Context
, Loc
,
1748 /// \brief Build a new C++ zero-initialization expression.
1750 /// By default, performs semantic analysis to build the new expression.
1751 /// Subclasses may override this routine to provide different behavior.
1752 ExprResult
RebuildCXXScalarValueInitExpr(TypeSourceInfo
*TSInfo
,
1753 SourceLocation LParenLoc
,
1754 SourceLocation RParenLoc
) {
1755 return getSema().BuildCXXTypeConstructExpr(TSInfo
, LParenLoc
,
1756 MultiExprArg(getSema(), 0, 0),
1760 /// \brief Build a new C++ "new" expression.
1762 /// By default, performs semantic analysis to build the new expression.
1763 /// Subclasses may override this routine to provide different behavior.
1764 ExprResult
RebuildCXXNewExpr(SourceLocation StartLoc
,
1766 SourceLocation PlacementLParen
,
1767 MultiExprArg PlacementArgs
,
1768 SourceLocation PlacementRParen
,
1769 SourceRange TypeIdParens
,
1770 QualType AllocatedType
,
1771 TypeSourceInfo
*AllocatedTypeInfo
,
1773 SourceLocation ConstructorLParen
,
1774 MultiExprArg ConstructorArgs
,
1775 SourceLocation ConstructorRParen
) {
1776 return getSema().BuildCXXNew(StartLoc
, UseGlobal
,
1778 move(PlacementArgs
),
1785 move(ConstructorArgs
),
1789 /// \brief Build a new C++ "delete" expression.
1791 /// By default, performs semantic analysis to build the new expression.
1792 /// Subclasses may override this routine to provide different behavior.
1793 ExprResult
RebuildCXXDeleteExpr(SourceLocation StartLoc
,
1794 bool IsGlobalDelete
,
1797 return getSema().ActOnCXXDelete(StartLoc
, IsGlobalDelete
, IsArrayForm
,
1801 /// \brief Build a new unary type trait expression.
1803 /// By default, performs semantic analysis to build the new expression.
1804 /// Subclasses may override this routine to provide different behavior.
1805 ExprResult
RebuildUnaryTypeTrait(UnaryTypeTrait Trait
,
1806 SourceLocation StartLoc
,
1808 SourceLocation RParenLoc
) {
1809 return getSema().BuildUnaryTypeTrait(Trait
, StartLoc
, T
, RParenLoc
);
1812 /// \brief Build a new binary type trait expression.
1814 /// By default, performs semantic analysis to build the new expression.
1815 /// Subclasses may override this routine to provide different behavior.
1816 ExprResult
RebuildBinaryTypeTrait(BinaryTypeTrait Trait
,
1817 SourceLocation StartLoc
,
1818 TypeSourceInfo
*LhsT
,
1819 TypeSourceInfo
*RhsT
,
1820 SourceLocation RParenLoc
) {
1821 return getSema().BuildBinaryTypeTrait(Trait
, StartLoc
, LhsT
, RhsT
, RParenLoc
);
1824 /// \brief Build a new (previously unresolved) declaration reference
1827 /// By default, performs semantic analysis to build the new expression.
1828 /// Subclasses may override this routine to provide different behavior.
1829 ExprResult
RebuildDependentScopeDeclRefExpr(NestedNameSpecifier
*NNS
,
1830 SourceRange QualifierRange
,
1831 const DeclarationNameInfo
&NameInfo
,
1832 const TemplateArgumentListInfo
*TemplateArgs
) {
1834 SS
.setRange(QualifierRange
);
1835 SS
.setScopeRep(NNS
);
1838 return getSema().BuildQualifiedTemplateIdExpr(SS
, NameInfo
,
1841 return getSema().BuildQualifiedDeclarationNameExpr(SS
, NameInfo
);
1844 /// \brief Build a new template-id expression.
1846 /// By default, performs semantic analysis to build the new expression.
1847 /// Subclasses may override this routine to provide different behavior.
1848 ExprResult
RebuildTemplateIdExpr(const CXXScopeSpec
&SS
,
1851 const TemplateArgumentListInfo
&TemplateArgs
) {
1852 return getSema().BuildTemplateIdExpr(SS
, R
, RequiresADL
, TemplateArgs
);
1855 /// \brief Build a new object-construction expression.
1857 /// By default, performs semantic analysis to build the new expression.
1858 /// Subclasses may override this routine to provide different behavior.
1859 ExprResult
RebuildCXXConstructExpr(QualType T
,
1861 CXXConstructorDecl
*Constructor
,
1864 bool RequiresZeroInit
,
1865 CXXConstructExpr::ConstructionKind ConstructKind
,
1866 SourceRange ParenRange
) {
1867 ASTOwningVector
<Expr
*> ConvertedArgs(SemaRef
);
1868 if (getSema().CompleteConstructorCall(Constructor
, move(Args
), Loc
,
1872 return getSema().BuildCXXConstructExpr(Loc
, T
, Constructor
, IsElidable
,
1873 move_arg(ConvertedArgs
),
1874 RequiresZeroInit
, ConstructKind
,
1878 /// \brief Build a new object-construction expression.
1880 /// By default, performs semantic analysis to build the new expression.
1881 /// Subclasses may override this routine to provide different behavior.
1882 ExprResult
RebuildCXXTemporaryObjectExpr(TypeSourceInfo
*TSInfo
,
1883 SourceLocation LParenLoc
,
1885 SourceLocation RParenLoc
) {
1886 return getSema().BuildCXXTypeConstructExpr(TSInfo
,
1892 /// \brief Build a new object-construction expression.
1894 /// By default, performs semantic analysis to build the new expression.
1895 /// Subclasses may override this routine to provide different behavior.
1896 ExprResult
RebuildCXXUnresolvedConstructExpr(TypeSourceInfo
*TSInfo
,
1897 SourceLocation LParenLoc
,
1899 SourceLocation RParenLoc
) {
1900 return getSema().BuildCXXTypeConstructExpr(TSInfo
,
1906 /// \brief Build a new member reference expression.
1908 /// By default, performs semantic analysis to build the new expression.
1909 /// Subclasses may override this routine to provide different behavior.
1910 ExprResult
RebuildCXXDependentScopeMemberExpr(Expr
*BaseE
,
1913 SourceLocation OperatorLoc
,
1914 NestedNameSpecifier
*Qualifier
,
1915 SourceRange QualifierRange
,
1916 NamedDecl
*FirstQualifierInScope
,
1917 const DeclarationNameInfo
&MemberNameInfo
,
1918 const TemplateArgumentListInfo
*TemplateArgs
) {
1920 SS
.setRange(QualifierRange
);
1921 SS
.setScopeRep(Qualifier
);
1923 return SemaRef
.BuildMemberReferenceExpr(BaseE
, BaseType
,
1924 OperatorLoc
, IsArrow
,
1925 SS
, FirstQualifierInScope
,
1930 /// \brief Build a new member reference expression.
1932 /// By default, performs semantic analysis to build the new expression.
1933 /// Subclasses may override this routine to provide different behavior.
1934 ExprResult
RebuildUnresolvedMemberExpr(Expr
*BaseE
,
1936 SourceLocation OperatorLoc
,
1938 NestedNameSpecifier
*Qualifier
,
1939 SourceRange QualifierRange
,
1940 NamedDecl
*FirstQualifierInScope
,
1942 const TemplateArgumentListInfo
*TemplateArgs
) {
1944 SS
.setRange(QualifierRange
);
1945 SS
.setScopeRep(Qualifier
);
1947 return SemaRef
.BuildMemberReferenceExpr(BaseE
, BaseType
,
1948 OperatorLoc
, IsArrow
,
1949 SS
, FirstQualifierInScope
,
1953 /// \brief Build a new noexcept expression.
1955 /// By default, performs semantic analysis to build the new expression.
1956 /// Subclasses may override this routine to provide different behavior.
1957 ExprResult
RebuildCXXNoexceptExpr(SourceRange Range
, Expr
*Arg
) {
1958 return SemaRef
.BuildCXXNoexceptExpr(Range
.getBegin(), Arg
, Range
.getEnd());
1961 /// \brief Build a new expression to compute the length of a parameter pack.
1962 ExprResult
RebuildSizeOfPackExpr(SourceLocation OperatorLoc
, NamedDecl
*Pack
,
1963 SourceLocation PackLoc
,
1964 SourceLocation RParenLoc
,
1966 return new (SemaRef
.Context
) SizeOfPackExpr(SemaRef
.Context
.getSizeType(),
1967 OperatorLoc
, Pack
, PackLoc
,
1971 /// \brief Build a new Objective-C @encode expression.
1973 /// By default, performs semantic analysis to build the new expression.
1974 /// Subclasses may override this routine to provide different behavior.
1975 ExprResult
RebuildObjCEncodeExpr(SourceLocation AtLoc
,
1976 TypeSourceInfo
*EncodeTypeInfo
,
1977 SourceLocation RParenLoc
) {
1978 return SemaRef
.Owned(SemaRef
.BuildObjCEncodeExpression(AtLoc
, EncodeTypeInfo
,
1982 /// \brief Build a new Objective-C class message.
1983 ExprResult
RebuildObjCMessageExpr(TypeSourceInfo
*ReceiverTypeInfo
,
1985 SourceLocation SelectorLoc
,
1986 ObjCMethodDecl
*Method
,
1987 SourceLocation LBracLoc
,
1989 SourceLocation RBracLoc
) {
1990 return SemaRef
.BuildClassMessage(ReceiverTypeInfo
,
1991 ReceiverTypeInfo
->getType(),
1992 /*SuperLoc=*/SourceLocation(),
1993 Sel
, Method
, LBracLoc
, SelectorLoc
,
1994 RBracLoc
, move(Args
));
1997 /// \brief Build a new Objective-C instance message.
1998 ExprResult
RebuildObjCMessageExpr(Expr
*Receiver
,
2000 SourceLocation SelectorLoc
,
2001 ObjCMethodDecl
*Method
,
2002 SourceLocation LBracLoc
,
2004 SourceLocation RBracLoc
) {
2005 return SemaRef
.BuildInstanceMessage(Receiver
,
2006 Receiver
->getType(),
2007 /*SuperLoc=*/SourceLocation(),
2008 Sel
, Method
, LBracLoc
, SelectorLoc
,
2009 RBracLoc
, move(Args
));
2012 /// \brief Build a new Objective-C ivar reference expression.
2014 /// By default, performs semantic analysis to build the new expression.
2015 /// Subclasses may override this routine to provide different behavior.
2016 ExprResult
RebuildObjCIvarRefExpr(Expr
*BaseArg
, ObjCIvarDecl
*Ivar
,
2017 SourceLocation IvarLoc
,
2018 bool IsArrow
, bool IsFreeIvar
) {
2019 // FIXME: We lose track of the IsFreeIvar bit.
2021 Expr
*Base
= BaseArg
;
2022 LookupResult
R(getSema(), Ivar
->getDeclName(), IvarLoc
,
2023 Sema::LookupMemberName
);
2024 ExprResult Result
= getSema().LookupMemberExpr(R
, Base
, IsArrow
,
2028 if (Result
.isInvalid())
2032 return move(Result
);
2034 return getSema().BuildMemberReferenceExpr(Base
, Base
->getType(),
2035 /*FIXME:*/IvarLoc
, IsArrow
, SS
,
2036 /*FirstQualifierInScope=*/0,
2038 /*TemplateArgs=*/0);
2041 /// \brief Build a new Objective-C property reference expression.
2043 /// By default, performs semantic analysis to build the new expression.
2044 /// Subclasses may override this routine to provide different behavior.
2045 ExprResult
RebuildObjCPropertyRefExpr(Expr
*BaseArg
,
2046 ObjCPropertyDecl
*Property
,
2047 SourceLocation PropertyLoc
) {
2049 Expr
*Base
= BaseArg
;
2050 LookupResult
R(getSema(), Property
->getDeclName(), PropertyLoc
,
2051 Sema::LookupMemberName
);
2052 bool IsArrow
= false;
2053 ExprResult Result
= getSema().LookupMemberExpr(R
, Base
, IsArrow
,
2054 /*FIME:*/PropertyLoc
,
2056 if (Result
.isInvalid())
2060 return move(Result
);
2062 return getSema().BuildMemberReferenceExpr(Base
, Base
->getType(),
2063 /*FIXME:*/PropertyLoc
, IsArrow
,
2065 /*FirstQualifierInScope=*/0,
2067 /*TemplateArgs=*/0);
2070 /// \brief Build a new Objective-C property reference expression.
2072 /// By default, performs semantic analysis to build the new expression.
2073 /// Subclasses may override this routine to provide different behavior.
2074 ExprResult
RebuildObjCPropertyRefExpr(Expr
*Base
, QualType T
,
2075 ObjCMethodDecl
*Getter
,
2076 ObjCMethodDecl
*Setter
,
2077 SourceLocation PropertyLoc
) {
2078 // Since these expressions can only be value-dependent, we do not
2079 // need to perform semantic analysis again.
2081 new (getSema().Context
) ObjCPropertyRefExpr(Getter
, Setter
, T
,
2082 VK_LValue
, OK_ObjCProperty
,
2083 PropertyLoc
, Base
));
2086 /// \brief Build a new Objective-C "isa" expression.
2088 /// By default, performs semantic analysis to build the new expression.
2089 /// Subclasses may override this routine to provide different behavior.
2090 ExprResult
RebuildObjCIsaExpr(Expr
*BaseArg
, SourceLocation IsaLoc
,
2093 Expr
*Base
= BaseArg
;
2094 LookupResult
R(getSema(), &getSema().Context
.Idents
.get("isa"), IsaLoc
,
2095 Sema::LookupMemberName
);
2096 ExprResult Result
= getSema().LookupMemberExpr(R
, Base
, IsArrow
,
2099 if (Result
.isInvalid())
2103 return move(Result
);
2105 return getSema().BuildMemberReferenceExpr(Base
, Base
->getType(),
2106 /*FIXME:*/IsaLoc
, IsArrow
, SS
,
2107 /*FirstQualifierInScope=*/0,
2109 /*TemplateArgs=*/0);
2112 /// \brief Build a new shuffle vector expression.
2114 /// By default, performs semantic analysis to build the new expression.
2115 /// Subclasses may override this routine to provide different behavior.
2116 ExprResult
RebuildShuffleVectorExpr(SourceLocation BuiltinLoc
,
2117 MultiExprArg SubExprs
,
2118 SourceLocation RParenLoc
) {
2119 // Find the declaration for __builtin_shufflevector
2120 const IdentifierInfo
&Name
2121 = SemaRef
.Context
.Idents
.get("__builtin_shufflevector");
2122 TranslationUnitDecl
*TUDecl
= SemaRef
.Context
.getTranslationUnitDecl();
2123 DeclContext::lookup_result Lookup
= TUDecl
->lookup(DeclarationName(&Name
));
2124 assert(Lookup
.first
!= Lookup
.second
&& "No __builtin_shufflevector?");
2126 // Build a reference to the __builtin_shufflevector builtin
2127 FunctionDecl
*Builtin
= cast
<FunctionDecl
>(*Lookup
.first
);
2129 = new (SemaRef
.Context
) DeclRefExpr(Builtin
, Builtin
->getType(),
2130 VK_LValue
, BuiltinLoc
);
2131 SemaRef
.UsualUnaryConversions(Callee
);
2133 // Build the CallExpr
2134 unsigned NumSubExprs
= SubExprs
.size();
2135 Expr
**Subs
= (Expr
**)SubExprs
.release();
2136 CallExpr
*TheCall
= new (SemaRef
.Context
) CallExpr(SemaRef
.Context
, Callee
,
2138 Builtin
->getCallResultType(),
2139 Expr::getValueKindForType(Builtin
->getResultType()),
2141 ExprResult
OwnedCall(SemaRef
.Owned(TheCall
));
2143 // Type-check the __builtin_shufflevector expression.
2144 ExprResult Result
= SemaRef
.SemaBuiltinShuffleVector(TheCall
);
2145 if (Result
.isInvalid())
2148 OwnedCall
.release();
2149 return move(Result
);
2152 /// \brief Build a new template argument pack expansion.
2154 /// By default, performs semantic analysis to build a new pack expansion
2155 /// for a template argument. Subclasses may override this routine to provide
2156 /// different behavior.
2157 TemplateArgumentLoc
RebuildPackExpansion(TemplateArgumentLoc Pattern
,
2158 SourceLocation EllipsisLoc
) {
2159 switch (Pattern
.getArgument().getKind()) {
2160 case TemplateArgument::Expression
: {
2162 = getSema().ActOnPackExpansion(Pattern
.getSourceExpression(),
2164 if (Result
.isInvalid())
2165 return TemplateArgumentLoc();
2167 return TemplateArgumentLoc(Result
.get(), Result
.get());
2170 case TemplateArgument::Template
:
2171 return TemplateArgumentLoc(TemplateArgument(
2172 Pattern
.getArgument().getAsTemplate(),
2174 Pattern
.getTemplateQualifierRange(),
2175 Pattern
.getTemplateNameLoc(),
2178 case TemplateArgument::Null
:
2179 case TemplateArgument::Integral
:
2180 case TemplateArgument::Declaration
:
2181 case TemplateArgument::Pack
:
2182 case TemplateArgument::TemplateExpansion
:
2183 llvm_unreachable("Pack expansion pattern has no parameter packs");
2185 case TemplateArgument::Type
:
2186 if (TypeSourceInfo
*Expansion
2187 = getSema().CheckPackExpansion(Pattern
.getTypeSourceInfo(),
2189 return TemplateArgumentLoc(TemplateArgument(Expansion
->getType()),
2194 return TemplateArgumentLoc();
2197 /// \brief Build a new expression pack expansion.
2199 /// By default, performs semantic analysis to build a new pack expansion
2200 /// for an expression. Subclasses may override this routine to provide
2201 /// different behavior.
2202 ExprResult
RebuildPackExpansion(Expr
*Pattern
, SourceLocation EllipsisLoc
) {
2203 return getSema().ActOnPackExpansion(Pattern
, EllipsisLoc
);
2207 QualType
TransformTypeInObjectScope(QualType T
,
2208 QualType ObjectType
,
2209 NamedDecl
*FirstQualifierInScope
,
2210 NestedNameSpecifier
*Prefix
);
2212 TypeSourceInfo
*TransformTypeInObjectScope(TypeSourceInfo
*T
,
2213 QualType ObjectType
,
2214 NamedDecl
*FirstQualifierInScope
,
2215 NestedNameSpecifier
*Prefix
);
2218 template<typename Derived
>
2219 StmtResult TreeTransform
<Derived
>::TransformStmt(Stmt
*S
) {
2221 return SemaRef
.Owned(S
);
2223 switch (S
->getStmtClass()) {
2224 case Stmt::NoStmtClass
: break;
2226 // Transform individual statement nodes
2227 #define STMT(Node, Parent) \
2228 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
2229 #define EXPR(Node, Parent)
2230 #include "clang/AST/StmtNodes.inc"
2232 // Transform expressions by calling TransformExpr.
2233 #define STMT(Node, Parent)
2234 #define ABSTRACT_STMT(Stmt)
2235 #define EXPR(Node, Parent) case Stmt::Node##Class:
2236 #include "clang/AST/StmtNodes.inc"
2238 ExprResult E
= getDerived().TransformExpr(cast
<Expr
>(S
));
2242 return getSema().ActOnExprStmt(getSema().MakeFullExpr(E
.take()));
2246 return SemaRef
.Owned(S
);
2250 template<typename Derived
>
2251 ExprResult TreeTransform
<Derived
>::TransformExpr(Expr
*E
) {
2253 return SemaRef
.Owned(E
);
2255 switch (E
->getStmtClass()) {
2256 case Stmt::NoStmtClass
: break;
2257 #define STMT(Node, Parent) case Stmt::Node##Class: break;
2258 #define ABSTRACT_STMT(Stmt)
2259 #define EXPR(Node, Parent) \
2260 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
2261 #include "clang/AST/StmtNodes.inc"
2264 return SemaRef
.Owned(E
);
2267 template<typename Derived
>
2268 bool TreeTransform
<Derived
>::TransformExprs(Expr
**Inputs
,
2271 llvm::SmallVectorImpl
<Expr
*> &Outputs
,
2273 for (unsigned I
= 0; I
!= NumInputs
; ++I
) {
2274 // If requested, drop call arguments that need to be dropped.
2275 if (IsCall
&& getDerived().DropCallArgument(Inputs
[I
])) {
2282 if (PackExpansionExpr
*Expansion
= dyn_cast
<PackExpansionExpr
>(Inputs
[I
])) {
2283 Expr
*Pattern
= Expansion
->getPattern();
2285 llvm::SmallVector
<UnexpandedParameterPack
, 2> Unexpanded
;
2286 getSema().collectUnexpandedParameterPacks(Pattern
, Unexpanded
);
2287 assert(!Unexpanded
.empty() && "Pack expansion without parameter packs?");
2289 // Determine whether the set of unexpanded parameter packs can and should
2292 bool RetainExpansion
= false;
2293 unsigned NumExpansions
= 0;
2294 if (getDerived().TryExpandParameterPacks(Expansion
->getEllipsisLoc(),
2295 Pattern
->getSourceRange(),
2298 Expand
, RetainExpansion
,
2303 // The transform has determined that we should perform a simple
2304 // transformation on the pack expansion, producing another pack
2306 Sema::ArgumentPackSubstitutionIndexRAII
SubstIndex(getSema(), -1);
2307 ExprResult OutPattern
= getDerived().TransformExpr(Pattern
);
2308 if (OutPattern
.isInvalid())
2311 ExprResult Out
= getDerived().RebuildPackExpansion(OutPattern
.get(),
2312 Expansion
->getEllipsisLoc());
2313 if (Out
.isInvalid())
2318 Outputs
.push_back(Out
.get());
2322 // The transform has determined that we should perform an elementwise
2323 // expansion of the pattern. Do so.
2324 for (unsigned I
= 0; I
!= NumExpansions
; ++I
) {
2325 Sema::ArgumentPackSubstitutionIndexRAII
SubstIndex(getSema(), I
);
2326 ExprResult Out
= getDerived().TransformExpr(Pattern
);
2327 if (Out
.isInvalid())
2330 if (Out
.get()->containsUnexpandedParameterPack()) {
2331 Out
= RebuildPackExpansion(Out
.get(), Expansion
->getEllipsisLoc());
2332 if (Out
.isInvalid())
2338 Outputs
.push_back(Out
.get());
2344 ExprResult Result
= getDerived().TransformExpr(Inputs
[I
]);
2345 if (Result
.isInvalid())
2348 if (Result
.get() != Inputs
[I
] && ArgChanged
)
2351 Outputs
.push_back(Result
.get());
2357 template<typename Derived
>
2358 NestedNameSpecifier
*
2359 TreeTransform
<Derived
>::TransformNestedNameSpecifier(NestedNameSpecifier
*NNS
,
2361 QualType ObjectType
,
2362 NamedDecl
*FirstQualifierInScope
) {
2363 NestedNameSpecifier
*Prefix
= NNS
->getPrefix();
2365 // Transform the prefix of this nested name specifier.
2367 Prefix
= getDerived().TransformNestedNameSpecifier(Prefix
, Range
,
2369 FirstQualifierInScope
);
2374 switch (NNS
->getKind()) {
2375 case NestedNameSpecifier::Identifier
:
2377 // The object type and qualifier-in-scope really apply to the
2379 ObjectType
= QualType();
2380 FirstQualifierInScope
= 0;
2383 assert((Prefix
|| !ObjectType
.isNull()) &&
2384 "Identifier nested-name-specifier with no prefix or object type");
2385 if (!getDerived().AlwaysRebuild() && Prefix
== NNS
->getPrefix() &&
2386 ObjectType
.isNull())
2389 return getDerived().RebuildNestedNameSpecifier(Prefix
, Range
,
2390 *NNS
->getAsIdentifier(),
2392 FirstQualifierInScope
);
2394 case NestedNameSpecifier::Namespace
: {
2396 = cast_or_null
<NamespaceDecl
>(
2397 getDerived().TransformDecl(Range
.getBegin(),
2398 NNS
->getAsNamespace()));
2399 if (!getDerived().AlwaysRebuild() &&
2400 Prefix
== NNS
->getPrefix() &&
2401 NS
== NNS
->getAsNamespace())
2404 return getDerived().RebuildNestedNameSpecifier(Prefix
, Range
, NS
);
2407 case NestedNameSpecifier::Global
:
2408 // There is no meaningful transformation that one could perform on the
2412 case NestedNameSpecifier::TypeSpecWithTemplate
:
2413 case NestedNameSpecifier::TypeSpec
: {
2414 TemporaryBase
Rebase(*this, Range
.getBegin(), DeclarationName());
2415 QualType T
= TransformTypeInObjectScope(QualType(NNS
->getAsType(), 0),
2417 FirstQualifierInScope
,
2422 if (!getDerived().AlwaysRebuild() &&
2423 Prefix
== NNS
->getPrefix() &&
2424 T
== QualType(NNS
->getAsType(), 0))
2427 return getDerived().RebuildNestedNameSpecifier(Prefix
, Range
,
2428 NNS
->getKind() == NestedNameSpecifier::TypeSpecWithTemplate
,
2433 // Required to silence a GCC warning
2437 template<typename Derived
>
2439 TreeTransform
<Derived
>
2440 ::TransformDeclarationNameInfo(const DeclarationNameInfo
&NameInfo
) {
2441 DeclarationName Name
= NameInfo
.getName();
2443 return DeclarationNameInfo();
2445 switch (Name
.getNameKind()) {
2446 case DeclarationName::Identifier
:
2447 case DeclarationName::ObjCZeroArgSelector
:
2448 case DeclarationName::ObjCOneArgSelector
:
2449 case DeclarationName::ObjCMultiArgSelector
:
2450 case DeclarationName::CXXOperatorName
:
2451 case DeclarationName::CXXLiteralOperatorName
:
2452 case DeclarationName::CXXUsingDirective
:
2455 case DeclarationName::CXXConstructorName
:
2456 case DeclarationName::CXXDestructorName
:
2457 case DeclarationName::CXXConversionFunctionName
: {
2458 TypeSourceInfo
*NewTInfo
;
2459 CanQualType NewCanTy
;
2460 if (TypeSourceInfo
*OldTInfo
= NameInfo
.getNamedTypeInfo()) {
2461 NewTInfo
= getDerived().TransformType(OldTInfo
);
2463 return DeclarationNameInfo();
2464 NewCanTy
= SemaRef
.Context
.getCanonicalType(NewTInfo
->getType());
2468 TemporaryBase
Rebase(*this, NameInfo
.getLoc(), Name
);
2469 QualType NewT
= getDerived().TransformType(Name
.getCXXNameType());
2471 return DeclarationNameInfo();
2472 NewCanTy
= SemaRef
.Context
.getCanonicalType(NewT
);
2475 DeclarationName NewName
2476 = SemaRef
.Context
.DeclarationNames
.getCXXSpecialName(Name
.getNameKind(),
2478 DeclarationNameInfo
NewNameInfo(NameInfo
);
2479 NewNameInfo
.setName(NewName
);
2480 NewNameInfo
.setNamedTypeInfo(NewTInfo
);
2485 assert(0 && "Unknown name kind.");
2486 return DeclarationNameInfo();
2489 template<typename Derived
>
2491 TreeTransform
<Derived
>::TransformTemplateName(TemplateName Name
,
2492 QualType ObjectType
,
2493 NamedDecl
*FirstQualifierInScope
) {
2494 SourceLocation Loc
= getDerived().getBaseLocation();
2496 if (QualifiedTemplateName
*QTN
= Name
.getAsQualifiedTemplateName()) {
2497 NestedNameSpecifier
*NNS
2498 = getDerived().TransformNestedNameSpecifier(QTN
->getQualifier(),
2499 /*FIXME*/ SourceRange(Loc
),
2501 FirstQualifierInScope
);
2503 return TemplateName();
2505 if (TemplateDecl
*Template
= QTN
->getTemplateDecl()) {
2506 TemplateDecl
*TransTemplate
2507 = cast_or_null
<TemplateDecl
>(getDerived().TransformDecl(Loc
, Template
));
2509 return TemplateName();
2511 if (!getDerived().AlwaysRebuild() &&
2512 NNS
== QTN
->getQualifier() &&
2513 TransTemplate
== Template
)
2516 return getDerived().RebuildTemplateName(NNS
, QTN
->hasTemplateKeyword(),
2520 // These should be getting filtered out before they make it into the AST.
2521 llvm_unreachable("overloaded template name survived to here");
2524 if (DependentTemplateName
*DTN
= Name
.getAsDependentTemplateName()) {
2525 NestedNameSpecifier
*NNS
= DTN
->getQualifier();
2527 NNS
= getDerived().TransformNestedNameSpecifier(NNS
,
2528 /*FIXME:*/SourceRange(Loc
),
2530 FirstQualifierInScope
);
2531 if (!NNS
) return TemplateName();
2533 // These apply to the scope specifier, not the template.
2534 ObjectType
= QualType();
2535 FirstQualifierInScope
= 0;
2538 if (!getDerived().AlwaysRebuild() &&
2539 NNS
== DTN
->getQualifier() &&
2540 ObjectType
.isNull())
2543 if (DTN
->isIdentifier()) {
2545 SourceRange
QualifierRange(getDerived().getBaseLocation());
2546 return getDerived().RebuildTemplateName(NNS
, QualifierRange
,
2547 *DTN
->getIdentifier(),
2549 FirstQualifierInScope
);
2552 return getDerived().RebuildTemplateName(NNS
, DTN
->getOperator(),
2556 if (TemplateDecl
*Template
= Name
.getAsTemplateDecl()) {
2557 TemplateDecl
*TransTemplate
2558 = cast_or_null
<TemplateDecl
>(getDerived().TransformDecl(Loc
, Template
));
2560 return TemplateName();
2562 if (!getDerived().AlwaysRebuild() &&
2563 TransTemplate
== Template
)
2566 return TemplateName(TransTemplate
);
2569 // These should be getting filtered out before they reach the AST.
2570 llvm_unreachable("overloaded function decl survived to here");
2571 return TemplateName();
2574 template<typename Derived
>
2575 void TreeTransform
<Derived
>::InventTemplateArgumentLoc(
2576 const TemplateArgument
&Arg
,
2577 TemplateArgumentLoc
&Output
) {
2578 SourceLocation Loc
= getDerived().getBaseLocation();
2579 switch (Arg
.getKind()) {
2580 case TemplateArgument::Null
:
2581 llvm_unreachable("null template argument in TreeTransform");
2584 case TemplateArgument::Type
:
2585 Output
= TemplateArgumentLoc(Arg
,
2586 SemaRef
.Context
.getTrivialTypeSourceInfo(Arg
.getAsType(), Loc
));
2590 case TemplateArgument::Template
:
2591 Output
= TemplateArgumentLoc(Arg
, SourceRange(), Loc
);
2594 case TemplateArgument::TemplateExpansion
:
2595 Output
= TemplateArgumentLoc(Arg
, SourceRange(), Loc
, Loc
);
2598 case TemplateArgument::Expression
:
2599 Output
= TemplateArgumentLoc(Arg
, Arg
.getAsExpr());
2602 case TemplateArgument::Declaration
:
2603 case TemplateArgument::Integral
:
2604 case TemplateArgument::Pack
:
2605 Output
= TemplateArgumentLoc(Arg
, TemplateArgumentLocInfo());
2610 template<typename Derived
>
2611 bool TreeTransform
<Derived
>::TransformTemplateArgument(
2612 const TemplateArgumentLoc
&Input
,
2613 TemplateArgumentLoc
&Output
) {
2614 const TemplateArgument
&Arg
= Input
.getArgument();
2615 switch (Arg
.getKind()) {
2616 case TemplateArgument::Null
:
2617 case TemplateArgument::Integral
:
2621 case TemplateArgument::Type
: {
2622 TypeSourceInfo
*DI
= Input
.getTypeSourceInfo();
2624 DI
= InventTypeSourceInfo(Input
.getArgument().getAsType());
2626 DI
= getDerived().TransformType(DI
);
2627 if (!DI
) return true;
2629 Output
= TemplateArgumentLoc(TemplateArgument(DI
->getType()), DI
);
2633 case TemplateArgument::Declaration
: {
2634 // FIXME: we should never have to transform one of these.
2635 DeclarationName Name
;
2636 if (NamedDecl
*ND
= dyn_cast
<NamedDecl
>(Arg
.getAsDecl()))
2637 Name
= ND
->getDeclName();
2638 TemporaryBase
Rebase(*this, Input
.getLocation(), Name
);
2639 Decl
*D
= getDerived().TransformDecl(Input
.getLocation(), Arg
.getAsDecl());
2640 if (!D
) return true;
2642 Expr
*SourceExpr
= Input
.getSourceDeclExpression();
2644 EnterExpressionEvaluationContext
Unevaluated(getSema(),
2646 ExprResult E
= getDerived().TransformExpr(SourceExpr
);
2647 SourceExpr
= (E
.isInvalid() ? 0 : E
.take());
2650 Output
= TemplateArgumentLoc(TemplateArgument(D
), SourceExpr
);
2654 case TemplateArgument::Template
: {
2655 TemporaryBase
Rebase(*this, Input
.getLocation(), DeclarationName());
2656 TemplateName Template
2657 = getDerived().TransformTemplateName(Arg
.getAsTemplate());
2658 if (Template
.isNull())
2661 Output
= TemplateArgumentLoc(TemplateArgument(Template
),
2662 Input
.getTemplateQualifierRange(),
2663 Input
.getTemplateNameLoc());
2667 case TemplateArgument::TemplateExpansion
:
2668 llvm_unreachable("Caller should expand pack expansions");
2670 case TemplateArgument::Expression
: {
2671 // Template argument expressions are not potentially evaluated.
2672 EnterExpressionEvaluationContext
Unevaluated(getSema(),
2675 Expr
*InputExpr
= Input
.getSourceExpression();
2676 if (!InputExpr
) InputExpr
= Input
.getArgument().getAsExpr();
2679 = getDerived().TransformExpr(InputExpr
);
2680 if (E
.isInvalid()) return true;
2681 Output
= TemplateArgumentLoc(TemplateArgument(E
.take()), E
.take());
2685 case TemplateArgument::Pack
: {
2686 llvm::SmallVector
<TemplateArgument
, 4> TransformedArgs
;
2687 TransformedArgs
.reserve(Arg
.pack_size());
2688 for (TemplateArgument::pack_iterator A
= Arg
.pack_begin(),
2689 AEnd
= Arg
.pack_end();
2692 // FIXME: preserve source information here when we start
2693 // caring about parameter packs.
2695 TemplateArgumentLoc InputArg
;
2696 TemplateArgumentLoc OutputArg
;
2697 getDerived().InventTemplateArgumentLoc(*A
, InputArg
);
2698 if (getDerived().TransformTemplateArgument(InputArg
, OutputArg
))
2701 TransformedArgs
.push_back(OutputArg
.getArgument());
2704 TemplateArgument
*TransformedArgsPtr
2705 = new (getSema().Context
) TemplateArgument
[TransformedArgs
.size()];
2706 std::copy(TransformedArgs
.begin(), TransformedArgs
.end(),
2707 TransformedArgsPtr
);
2708 Output
= TemplateArgumentLoc(TemplateArgument(TransformedArgsPtr
,
2709 TransformedArgs
.size()),
2710 Input
.getLocInfo());
2715 // Work around bogus GCC warning
2719 /// \brief Iterator adaptor that invents template argument location information
2720 /// for each of the template arguments in its underlying iterator.
2721 template<typename Derived
, typename InputIterator
>
2722 class TemplateArgumentLocInventIterator
{
2723 TreeTransform
<Derived
> &Self
;
2727 typedef TemplateArgumentLoc value_type
;
2728 typedef TemplateArgumentLoc reference
;
2729 typedef typename
std::iterator_traits
<InputIterator
>::difference_type
2731 typedef std::input_iterator_tag iterator_category
;
2734 TemplateArgumentLoc Arg
;
2737 explicit pointer(TemplateArgumentLoc Arg
) : Arg(Arg
) { }
2739 const TemplateArgumentLoc
*operator->() const { return &Arg
; }
2742 TemplateArgumentLocInventIterator() { }
2744 explicit TemplateArgumentLocInventIterator(TreeTransform
<Derived
> &Self
,
2746 : Self(Self
), Iter(Iter
) { }
2748 TemplateArgumentLocInventIterator
&operator++() {
2753 TemplateArgumentLocInventIterator
operator++(int) {
2754 TemplateArgumentLocInventIterator
Old(*this);
2759 reference
operator*() const {
2760 TemplateArgumentLoc Result
;
2761 Self
.InventTemplateArgumentLoc(*Iter
, Result
);
2765 pointer
operator->() const { return pointer(**this); }
2767 friend bool operator==(const TemplateArgumentLocInventIterator
&X
,
2768 const TemplateArgumentLocInventIterator
&Y
) {
2769 return X
.Iter
== Y
.Iter
;
2772 friend bool operator!=(const TemplateArgumentLocInventIterator
&X
,
2773 const TemplateArgumentLocInventIterator
&Y
) {
2774 return X
.Iter
!= Y
.Iter
;
2778 template<typename Derived
>
2779 template<typename InputIterator
>
2780 bool TreeTransform
<Derived
>::TransformTemplateArguments(InputIterator First
,
2782 TemplateArgumentListInfo
&Outputs
) {
2783 for (; First
!= Last
; ++First
) {
2784 TemplateArgumentLoc Out
;
2785 TemplateArgumentLoc In
= *First
;
2787 if (In
.getArgument().getKind() == TemplateArgument::Pack
) {
2788 // Unpack argument packs, which we translate them into separate
2790 // FIXME: We could do much better if we could guarantee that the
2791 // TemplateArgumentLocInfo for the pack expansion would be usable for
2792 // all of the template arguments in the argument pack.
2793 typedef TemplateArgumentLocInventIterator
<Derived
,
2794 TemplateArgument::pack_iterator
>
2796 if (TransformTemplateArguments(PackLocIterator(*this,
2797 In
.getArgument().pack_begin()),
2798 PackLocIterator(*this,
2799 In
.getArgument().pack_end()),
2806 if (In
.getArgument().isPackExpansion()) {
2807 // We have a pack expansion, for which we will be substituting into
2809 SourceLocation Ellipsis
;
2810 TemplateArgumentLoc Pattern
2811 = In
.getPackExpansionPattern(Ellipsis
, getSema().Context
);
2813 llvm::SmallVector
<UnexpandedParameterPack
, 2> Unexpanded
;
2814 getSema().collectUnexpandedParameterPacks(Pattern
, Unexpanded
);
2815 assert(!Unexpanded
.empty() && "Pack expansion without parameter packs?");
2817 // Determine whether the set of unexpanded parameter packs can and should
2820 bool RetainExpansion
= false;
2821 unsigned NumExpansions
= 0;
2822 if (getDerived().TryExpandParameterPacks(Ellipsis
,
2823 Pattern
.getSourceRange(),
2832 // The transform has determined that we should perform a simple
2833 // transformation on the pack expansion, producing another pack
2835 TemplateArgumentLoc OutPattern
;
2836 Sema::ArgumentPackSubstitutionIndexRAII
SubstIndex(getSema(), -1);
2837 if (getDerived().TransformTemplateArgument(Pattern
, OutPattern
))
2840 Out
= getDerived().RebuildPackExpansion(OutPattern
, Ellipsis
);
2841 if (Out
.getArgument().isNull())
2844 Outputs
.addArgument(Out
);
2848 // The transform has determined that we should perform an elementwise
2849 // expansion of the pattern. Do so.
2850 for (unsigned I
= 0; I
!= NumExpansions
; ++I
) {
2851 Sema::ArgumentPackSubstitutionIndexRAII
SubstIndex(getSema(), I
);
2853 if (getDerived().TransformTemplateArgument(Pattern
, Out
))
2856 if (Out
.getArgument().containsUnexpandedParameterPack()) {
2857 Out
= getDerived().RebuildPackExpansion(Out
, Ellipsis
);
2858 if (Out
.getArgument().isNull())
2862 Outputs
.addArgument(Out
);
2865 // If we're supposed to retain a pack expansion, do so by temporarily
2866 // forgetting the partially-substituted parameter pack.
2867 if (RetainExpansion
) {
2868 ForgetPartiallySubstitutedPackRAII
Forget(getDerived());
2870 if (getDerived().TransformTemplateArgument(Pattern
, Out
))
2873 Out
= getDerived().RebuildPackExpansion(Out
, Ellipsis
);
2874 if (Out
.getArgument().isNull())
2877 Outputs
.addArgument(Out
);
2884 if (getDerived().TransformTemplateArgument(In
, Out
))
2887 Outputs
.addArgument(Out
);
2894 //===----------------------------------------------------------------------===//
2895 // Type transformation
2896 //===----------------------------------------------------------------------===//
2898 template<typename Derived
>
2899 QualType TreeTransform
<Derived
>::TransformType(QualType T
) {
2900 if (getDerived().AlreadyTransformed(T
))
2903 // Temporary workaround. All of these transformations should
2904 // eventually turn into transformations on TypeLocs.
2905 TypeSourceInfo
*DI
= getSema().Context
.CreateTypeSourceInfo(T
);
2906 DI
->getTypeLoc().initialize(getDerived().getBaseLocation());
2908 TypeSourceInfo
*NewDI
= getDerived().TransformType(DI
);
2913 return NewDI
->getType();
2916 template<typename Derived
>
2917 TypeSourceInfo
*TreeTransform
<Derived
>::TransformType(TypeSourceInfo
*DI
) {
2918 if (getDerived().AlreadyTransformed(DI
->getType()))
2923 TypeLoc TL
= DI
->getTypeLoc();
2924 TLB
.reserve(TL
.getFullDataSize());
2926 QualType Result
= getDerived().TransformType(TLB
, TL
);
2927 if (Result
.isNull())
2930 return TLB
.getTypeSourceInfo(SemaRef
.Context
, Result
);
2933 template<typename Derived
>
2935 TreeTransform
<Derived
>::TransformType(TypeLocBuilder
&TLB
, TypeLoc T
) {
2936 switch (T
.getTypeLocClass()) {
2937 #define ABSTRACT_TYPELOC(CLASS, PARENT)
2938 #define TYPELOC(CLASS, PARENT) \
2939 case TypeLoc::CLASS: \
2940 return getDerived().Transform##CLASS##Type(TLB, cast<CLASS##TypeLoc>(T));
2941 #include "clang/AST/TypeLocNodes.def"
2944 llvm_unreachable("unhandled type loc!");
2948 /// FIXME: By default, this routine adds type qualifiers only to types
2949 /// that can have qualifiers, and silently suppresses those qualifiers
2950 /// that are not permitted (e.g., qualifiers on reference or function
2951 /// types). This is the right thing for template instantiation, but
2952 /// probably not for other clients.
2953 template<typename Derived
>
2955 TreeTransform
<Derived
>::TransformQualifiedType(TypeLocBuilder
&TLB
,
2956 QualifiedTypeLoc T
) {
2957 Qualifiers Quals
= T
.getType().getLocalQualifiers();
2959 QualType Result
= getDerived().TransformType(TLB
, T
.getUnqualifiedLoc());
2960 if (Result
.isNull())
2963 // Silently suppress qualifiers if the result type can't be qualified.
2964 // FIXME: this is the right thing for template instantiation, but
2965 // probably not for other clients.
2966 if (Result
->isFunctionType() || Result
->isReferenceType())
2969 if (!Quals
.empty()) {
2970 Result
= SemaRef
.BuildQualifiedType(Result
, T
.getBeginLoc(), Quals
);
2971 TLB
.push
<QualifiedTypeLoc
>(Result
);
2972 // No location information to preserve.
2978 /// \brief Transforms a type that was written in a scope specifier,
2979 /// given an object type, the results of unqualified lookup, and
2980 /// an already-instantiated prefix.
2982 /// The object type is provided iff the scope specifier qualifies the
2983 /// member of a dependent member-access expression. The prefix is
2984 /// provided iff the the scope specifier in which this appears has a
2987 /// This is private to TreeTransform.
2988 template<typename Derived
>
2990 TreeTransform
<Derived
>::TransformTypeInObjectScope(QualType T
,
2991 QualType ObjectType
,
2992 NamedDecl
*UnqualLookup
,
2993 NestedNameSpecifier
*Prefix
) {
2994 if (getDerived().AlreadyTransformed(T
))
2997 TypeSourceInfo
*TSI
=
2998 SemaRef
.Context
.getTrivialTypeSourceInfo(T
, getBaseLocation());
3000 TSI
= getDerived().TransformTypeInObjectScope(TSI
, ObjectType
,
3001 UnqualLookup
, Prefix
);
3002 if (!TSI
) return QualType();
3003 return TSI
->getType();
3006 template<typename Derived
>
3008 TreeTransform
<Derived
>::TransformTypeInObjectScope(TypeSourceInfo
*TSI
,
3009 QualType ObjectType
,
3010 NamedDecl
*UnqualLookup
,
3011 NestedNameSpecifier
*Prefix
) {
3012 // TODO: in some cases, we might be some verification to do here.
3013 if (ObjectType
.isNull())
3014 return getDerived().TransformType(TSI
);
3016 QualType T
= TSI
->getType();
3017 if (getDerived().AlreadyTransformed(T
))
3023 if (isa
<TemplateSpecializationType
>(T
)) {
3024 TemplateSpecializationTypeLoc TL
3025 = cast
<TemplateSpecializationTypeLoc
>(TSI
->getTypeLoc());
3027 TemplateName Template
=
3028 getDerived().TransformTemplateName(TL
.getTypePtr()->getTemplateName(),
3029 ObjectType
, UnqualLookup
);
3030 if (Template
.isNull()) return 0;
3032 Result
= getDerived()
3033 .TransformTemplateSpecializationType(TLB
, TL
, Template
);
3034 } else if (isa
<DependentTemplateSpecializationType
>(T
)) {
3035 DependentTemplateSpecializationTypeLoc TL
3036 = cast
<DependentTemplateSpecializationTypeLoc
>(TSI
->getTypeLoc());
3038 Result
= getDerived()
3039 .TransformDependentTemplateSpecializationType(TLB
, TL
, Prefix
);
3041 // Nothing special needs to be done for these.
3042 Result
= getDerived().TransformType(TLB
, TSI
->getTypeLoc());
3045 if (Result
.isNull()) return 0;
3046 return TLB
.getTypeSourceInfo(SemaRef
.Context
, Result
);
3049 template <class TyLoc
> static inline
3050 QualType
TransformTypeSpecType(TypeLocBuilder
&TLB
, TyLoc T
) {
3051 TyLoc NewT
= TLB
.push
<TyLoc
>(T
.getType());
3052 NewT
.setNameLoc(T
.getNameLoc());
3056 template<typename Derived
>
3057 QualType TreeTransform
<Derived
>::TransformBuiltinType(TypeLocBuilder
&TLB
,
3059 BuiltinTypeLoc NewT
= TLB
.push
<BuiltinTypeLoc
>(T
.getType());
3060 NewT
.setBuiltinLoc(T
.getBuiltinLoc());
3061 if (T
.needsExtraLocalData())
3062 NewT
.getWrittenBuiltinSpecs() = T
.getWrittenBuiltinSpecs();
3066 template<typename Derived
>
3067 QualType TreeTransform
<Derived
>::TransformComplexType(TypeLocBuilder
&TLB
,
3070 return TransformTypeSpecType(TLB
, T
);
3073 template<typename Derived
>
3074 QualType TreeTransform
<Derived
>::TransformPointerType(TypeLocBuilder
&TLB
,
3075 PointerTypeLoc TL
) {
3076 QualType PointeeType
3077 = getDerived().TransformType(TLB
, TL
.getPointeeLoc());
3078 if (PointeeType
.isNull())
3081 QualType Result
= TL
.getType();
3082 if (PointeeType
->getAs
<ObjCObjectType
>()) {
3083 // A dependent pointer type 'T *' has is being transformed such
3084 // that an Objective-C class type is being replaced for 'T'. The
3085 // resulting pointer type is an ObjCObjectPointerType, not a
3087 Result
= SemaRef
.Context
.getObjCObjectPointerType(PointeeType
);
3089 ObjCObjectPointerTypeLoc NewT
= TLB
.push
<ObjCObjectPointerTypeLoc
>(Result
);
3090 NewT
.setStarLoc(TL
.getStarLoc());
3094 if (getDerived().AlwaysRebuild() ||
3095 PointeeType
!= TL
.getPointeeLoc().getType()) {
3096 Result
= getDerived().RebuildPointerType(PointeeType
, TL
.getSigilLoc());
3097 if (Result
.isNull())
3101 PointerTypeLoc NewT
= TLB
.push
<PointerTypeLoc
>(Result
);
3102 NewT
.setSigilLoc(TL
.getSigilLoc());
3106 template<typename Derived
>
3108 TreeTransform
<Derived
>::TransformBlockPointerType(TypeLocBuilder
&TLB
,
3109 BlockPointerTypeLoc TL
) {
3110 QualType PointeeType
3111 = getDerived().TransformType(TLB
, TL
.getPointeeLoc());
3112 if (PointeeType
.isNull())
3115 QualType Result
= TL
.getType();
3116 if (getDerived().AlwaysRebuild() ||
3117 PointeeType
!= TL
.getPointeeLoc().getType()) {
3118 Result
= getDerived().RebuildBlockPointerType(PointeeType
,
3120 if (Result
.isNull())
3124 BlockPointerTypeLoc NewT
= TLB
.push
<BlockPointerTypeLoc
>(Result
);
3125 NewT
.setSigilLoc(TL
.getSigilLoc());
3129 /// Transforms a reference type. Note that somewhat paradoxically we
3130 /// don't care whether the type itself is an l-value type or an r-value
3131 /// type; we only care if the type was *written* as an l-value type
3132 /// or an r-value type.
3133 template<typename Derived
>
3135 TreeTransform
<Derived
>::TransformReferenceType(TypeLocBuilder
&TLB
,
3136 ReferenceTypeLoc TL
) {
3137 const ReferenceType
*T
= TL
.getTypePtr();
3139 // Note that this works with the pointee-as-written.
3140 QualType PointeeType
= getDerived().TransformType(TLB
, TL
.getPointeeLoc());
3141 if (PointeeType
.isNull())
3144 QualType Result
= TL
.getType();
3145 if (getDerived().AlwaysRebuild() ||
3146 PointeeType
!= T
->getPointeeTypeAsWritten()) {
3147 Result
= getDerived().RebuildReferenceType(PointeeType
,
3148 T
->isSpelledAsLValue(),
3150 if (Result
.isNull())
3154 // r-value references can be rebuilt as l-value references.
3155 ReferenceTypeLoc NewTL
;
3156 if (isa
<LValueReferenceType
>(Result
))
3157 NewTL
= TLB
.push
<LValueReferenceTypeLoc
>(Result
);
3159 NewTL
= TLB
.push
<RValueReferenceTypeLoc
>(Result
);
3160 NewTL
.setSigilLoc(TL
.getSigilLoc());
3165 template<typename Derived
>
3167 TreeTransform
<Derived
>::TransformLValueReferenceType(TypeLocBuilder
&TLB
,
3168 LValueReferenceTypeLoc TL
) {
3169 return TransformReferenceType(TLB
, TL
);
3172 template<typename Derived
>
3174 TreeTransform
<Derived
>::TransformRValueReferenceType(TypeLocBuilder
&TLB
,
3175 RValueReferenceTypeLoc TL
) {
3176 return TransformReferenceType(TLB
, TL
);
3179 template<typename Derived
>
3181 TreeTransform
<Derived
>::TransformMemberPointerType(TypeLocBuilder
&TLB
,
3182 MemberPointerTypeLoc TL
) {
3183 MemberPointerType
*T
= TL
.getTypePtr();
3185 QualType PointeeType
= getDerived().TransformType(TLB
, TL
.getPointeeLoc());
3186 if (PointeeType
.isNull())
3189 // TODO: preserve source information for this.
3191 = getDerived().TransformType(QualType(T
->getClass(), 0));
3192 if (ClassType
.isNull())
3195 QualType Result
= TL
.getType();
3196 if (getDerived().AlwaysRebuild() ||
3197 PointeeType
!= T
->getPointeeType() ||
3198 ClassType
!= QualType(T
->getClass(), 0)) {
3199 Result
= getDerived().RebuildMemberPointerType(PointeeType
, ClassType
,
3201 if (Result
.isNull())
3205 MemberPointerTypeLoc NewTL
= TLB
.push
<MemberPointerTypeLoc
>(Result
);
3206 NewTL
.setSigilLoc(TL
.getSigilLoc());
3211 template<typename Derived
>
3213 TreeTransform
<Derived
>::TransformConstantArrayType(TypeLocBuilder
&TLB
,
3214 ConstantArrayTypeLoc TL
) {
3215 ConstantArrayType
*T
= TL
.getTypePtr();
3216 QualType ElementType
= getDerived().TransformType(TLB
, TL
.getElementLoc());
3217 if (ElementType
.isNull())
3220 QualType Result
= TL
.getType();
3221 if (getDerived().AlwaysRebuild() ||
3222 ElementType
!= T
->getElementType()) {
3223 Result
= getDerived().RebuildConstantArrayType(ElementType
,
3224 T
->getSizeModifier(),
3226 T
->getIndexTypeCVRQualifiers(),
3227 TL
.getBracketsRange());
3228 if (Result
.isNull())
3232 ConstantArrayTypeLoc NewTL
= TLB
.push
<ConstantArrayTypeLoc
>(Result
);
3233 NewTL
.setLBracketLoc(TL
.getLBracketLoc());
3234 NewTL
.setRBracketLoc(TL
.getRBracketLoc());
3236 Expr
*Size
= TL
.getSizeExpr();
3238 EnterExpressionEvaluationContext
Unevaluated(SemaRef
, Sema::Unevaluated
);
3239 Size
= getDerived().TransformExpr(Size
).template takeAs
<Expr
>();
3241 NewTL
.setSizeExpr(Size
);
3246 template<typename Derived
>
3247 QualType TreeTransform
<Derived
>::TransformIncompleteArrayType(
3248 TypeLocBuilder
&TLB
,
3249 IncompleteArrayTypeLoc TL
) {
3250 IncompleteArrayType
*T
= TL
.getTypePtr();
3251 QualType ElementType
= getDerived().TransformType(TLB
, TL
.getElementLoc());
3252 if (ElementType
.isNull())
3255 QualType Result
= TL
.getType();
3256 if (getDerived().AlwaysRebuild() ||
3257 ElementType
!= T
->getElementType()) {
3258 Result
= getDerived().RebuildIncompleteArrayType(ElementType
,
3259 T
->getSizeModifier(),
3260 T
->getIndexTypeCVRQualifiers(),
3261 TL
.getBracketsRange());
3262 if (Result
.isNull())
3266 IncompleteArrayTypeLoc NewTL
= TLB
.push
<IncompleteArrayTypeLoc
>(Result
);
3267 NewTL
.setLBracketLoc(TL
.getLBracketLoc());
3268 NewTL
.setRBracketLoc(TL
.getRBracketLoc());
3269 NewTL
.setSizeExpr(0);
3274 template<typename Derived
>
3276 TreeTransform
<Derived
>::TransformVariableArrayType(TypeLocBuilder
&TLB
,
3277 VariableArrayTypeLoc TL
) {
3278 VariableArrayType
*T
= TL
.getTypePtr();
3279 QualType ElementType
= getDerived().TransformType(TLB
, TL
.getElementLoc());
3280 if (ElementType
.isNull())
3283 // Array bounds are not potentially evaluated contexts
3284 EnterExpressionEvaluationContext
Unevaluated(SemaRef
, Sema::Unevaluated
);
3286 ExprResult SizeResult
3287 = getDerived().TransformExpr(T
->getSizeExpr());
3288 if (SizeResult
.isInvalid())
3291 Expr
*Size
= SizeResult
.take();
3293 QualType Result
= TL
.getType();
3294 if (getDerived().AlwaysRebuild() ||
3295 ElementType
!= T
->getElementType() ||
3296 Size
!= T
->getSizeExpr()) {
3297 Result
= getDerived().RebuildVariableArrayType(ElementType
,
3298 T
->getSizeModifier(),
3300 T
->getIndexTypeCVRQualifiers(),
3301 TL
.getBracketsRange());
3302 if (Result
.isNull())
3306 VariableArrayTypeLoc NewTL
= TLB
.push
<VariableArrayTypeLoc
>(Result
);
3307 NewTL
.setLBracketLoc(TL
.getLBracketLoc());
3308 NewTL
.setRBracketLoc(TL
.getRBracketLoc());
3309 NewTL
.setSizeExpr(Size
);
3314 template<typename Derived
>
3316 TreeTransform
<Derived
>::TransformDependentSizedArrayType(TypeLocBuilder
&TLB
,
3317 DependentSizedArrayTypeLoc TL
) {
3318 DependentSizedArrayType
*T
= TL
.getTypePtr();
3319 QualType ElementType
= getDerived().TransformType(TLB
, TL
.getElementLoc());
3320 if (ElementType
.isNull())
3323 // Array bounds are not potentially evaluated contexts
3324 EnterExpressionEvaluationContext
Unevaluated(SemaRef
, Sema::Unevaluated
);
3326 ExprResult SizeResult
3327 = getDerived().TransformExpr(T
->getSizeExpr());
3328 if (SizeResult
.isInvalid())
3331 Expr
*Size
= static_cast<Expr
*>(SizeResult
.get());
3333 QualType Result
= TL
.getType();
3334 if (getDerived().AlwaysRebuild() ||
3335 ElementType
!= T
->getElementType() ||
3336 Size
!= T
->getSizeExpr()) {
3337 Result
= getDerived().RebuildDependentSizedArrayType(ElementType
,
3338 T
->getSizeModifier(),
3340 T
->getIndexTypeCVRQualifiers(),
3341 TL
.getBracketsRange());
3342 if (Result
.isNull())
3345 else SizeResult
.take();
3347 // We might have any sort of array type now, but fortunately they
3348 // all have the same location layout.
3349 ArrayTypeLoc NewTL
= TLB
.push
<ArrayTypeLoc
>(Result
);
3350 NewTL
.setLBracketLoc(TL
.getLBracketLoc());
3351 NewTL
.setRBracketLoc(TL
.getRBracketLoc());
3352 NewTL
.setSizeExpr(Size
);
3357 template<typename Derived
>
3358 QualType TreeTransform
<Derived
>::TransformDependentSizedExtVectorType(
3359 TypeLocBuilder
&TLB
,
3360 DependentSizedExtVectorTypeLoc TL
) {
3361 DependentSizedExtVectorType
*T
= TL
.getTypePtr();
3363 // FIXME: ext vector locs should be nested
3364 QualType ElementType
= getDerived().TransformType(T
->getElementType());
3365 if (ElementType
.isNull())
3368 // Vector sizes are not potentially evaluated contexts
3369 EnterExpressionEvaluationContext
Unevaluated(SemaRef
, Sema::Unevaluated
);
3371 ExprResult Size
= getDerived().TransformExpr(T
->getSizeExpr());
3372 if (Size
.isInvalid())
3375 QualType Result
= TL
.getType();
3376 if (getDerived().AlwaysRebuild() ||
3377 ElementType
!= T
->getElementType() ||
3378 Size
.get() != T
->getSizeExpr()) {
3379 Result
= getDerived().RebuildDependentSizedExtVectorType(ElementType
,
3381 T
->getAttributeLoc());
3382 if (Result
.isNull())
3386 // Result might be dependent or not.
3387 if (isa
<DependentSizedExtVectorType
>(Result
)) {
3388 DependentSizedExtVectorTypeLoc NewTL
3389 = TLB
.push
<DependentSizedExtVectorTypeLoc
>(Result
);
3390 NewTL
.setNameLoc(TL
.getNameLoc());
3392 ExtVectorTypeLoc NewTL
= TLB
.push
<ExtVectorTypeLoc
>(Result
);
3393 NewTL
.setNameLoc(TL
.getNameLoc());
3399 template<typename Derived
>
3400 QualType TreeTransform
<Derived
>::TransformVectorType(TypeLocBuilder
&TLB
,
3402 VectorType
*T
= TL
.getTypePtr();
3403 QualType ElementType
= getDerived().TransformType(T
->getElementType());
3404 if (ElementType
.isNull())
3407 QualType Result
= TL
.getType();
3408 if (getDerived().AlwaysRebuild() ||
3409 ElementType
!= T
->getElementType()) {
3410 Result
= getDerived().RebuildVectorType(ElementType
, T
->getNumElements(),
3411 T
->getVectorKind());
3412 if (Result
.isNull())
3416 VectorTypeLoc NewTL
= TLB
.push
<VectorTypeLoc
>(Result
);
3417 NewTL
.setNameLoc(TL
.getNameLoc());
3422 template<typename Derived
>
3423 QualType TreeTransform
<Derived
>::TransformExtVectorType(TypeLocBuilder
&TLB
,
3424 ExtVectorTypeLoc TL
) {
3425 VectorType
*T
= TL
.getTypePtr();
3426 QualType ElementType
= getDerived().TransformType(T
->getElementType());
3427 if (ElementType
.isNull())
3430 QualType Result
= TL
.getType();
3431 if (getDerived().AlwaysRebuild() ||
3432 ElementType
!= T
->getElementType()) {
3433 Result
= getDerived().RebuildExtVectorType(ElementType
,
3434 T
->getNumElements(),
3435 /*FIXME*/ SourceLocation());
3436 if (Result
.isNull())
3440 ExtVectorTypeLoc NewTL
= TLB
.push
<ExtVectorTypeLoc
>(Result
);
3441 NewTL
.setNameLoc(TL
.getNameLoc());
3446 template<typename Derived
>
3448 TreeTransform
<Derived
>::TransformFunctionTypeParam(ParmVarDecl
*OldParm
) {
3449 TypeSourceInfo
*OldDI
= OldParm
->getTypeSourceInfo();
3450 TypeSourceInfo
*NewDI
= getDerived().TransformType(OldDI
);
3457 return ParmVarDecl::Create(SemaRef
.Context
,
3458 OldParm
->getDeclContext(),
3459 OldParm
->getLocation(),
3460 OldParm
->getIdentifier(),
3463 OldParm
->getStorageClass(),
3464 OldParm
->getStorageClassAsWritten(),
3468 template<typename Derived
>
3469 bool TreeTransform
<Derived
>::
3470 TransformFunctionTypeParams(SourceLocation Loc
,
3471 ParmVarDecl
**Params
, unsigned NumParams
,
3472 const QualType
*ParamTypes
,
3473 llvm::SmallVectorImpl
<QualType
> &OutParamTypes
,
3474 llvm::SmallVectorImpl
<ParmVarDecl
*> *PVars
) {
3475 for (unsigned i
= 0; i
!= NumParams
; ++i
) {
3476 if (ParmVarDecl
*OldParm
= Params
[i
]) {
3477 if (OldParm
->isParameterPack()) {
3478 // We have a function parameter pack that may need to be expanded.
3479 llvm::SmallVector
<UnexpandedParameterPack
, 2> Unexpanded
;
3481 // Find the parameter packs that could be expanded.
3482 TypeLoc TL
= OldParm
->getTypeSourceInfo()->getTypeLoc();
3483 PackExpansionTypeLoc ExpansionTL
= cast
<PackExpansionTypeLoc
>(TL
);
3484 TypeLoc Pattern
= ExpansionTL
.getPatternLoc();
3485 SemaRef
.collectUnexpandedParameterPacks(Pattern
, Unexpanded
);
3487 // Determine whether we should expand the parameter packs.
3488 bool ShouldExpand
= false;
3489 bool RetainExpansion
= false;
3490 unsigned NumExpansions
= 0;
3491 if (getDerived().TryExpandParameterPacks(ExpansionTL
.getEllipsisLoc(),
3492 Pattern
.getSourceRange(),
3502 // Expand the function parameter pack into multiple, separate
3504 getDerived().ExpandingFunctionParameterPack(OldParm
);
3505 for (unsigned I
= 0; I
!= NumExpansions
; ++I
) {
3506 Sema::ArgumentPackSubstitutionIndexRAII
SubstIndex(getSema(), I
);
3507 ParmVarDecl
*NewParm
3508 = getDerived().TransformFunctionTypeParam(OldParm
);
3512 OutParamTypes
.push_back(NewParm
->getType());
3514 PVars
->push_back(NewParm
);
3517 // If we're supposed to retain a pack expansion, do so by temporarily
3518 // forgetting the partially-substituted parameter pack.
3519 if (RetainExpansion
) {
3520 ForgetPartiallySubstitutedPackRAII
Forget(getDerived());
3521 ParmVarDecl
*NewParm
3522 = getDerived().TransformFunctionTypeParam(OldParm
);
3526 OutParamTypes
.push_back(NewParm
->getType());
3528 PVars
->push_back(NewParm
);
3531 // We're done with the pack expansion.
3535 // We'll substitute the parameter now without expanding the pack
3539 Sema::ArgumentPackSubstitutionIndexRAII
SubstIndex(getSema(), -1);
3540 ParmVarDecl
*NewParm
= getDerived().TransformFunctionTypeParam(OldParm
);
3544 OutParamTypes
.push_back(NewParm
->getType());
3546 PVars
->push_back(NewParm
);
3550 // Deal with the possibility that we don't have a parameter
3551 // declaration for this parameter.
3552 QualType OldType
= ParamTypes
[i
];
3553 bool IsPackExpansion
= false;
3554 if (const PackExpansionType
*Expansion
3555 = dyn_cast
<PackExpansionType
>(OldType
)) {
3556 // We have a function parameter pack that may need to be expanded.
3557 QualType Pattern
= Expansion
->getPattern();
3558 llvm::SmallVector
<UnexpandedParameterPack
, 2> Unexpanded
;
3559 getSema().collectUnexpandedParameterPacks(Pattern
, Unexpanded
);
3561 // Determine whether we should expand the parameter packs.
3562 bool ShouldExpand
= false;
3563 bool RetainExpansion
= false;
3564 unsigned NumExpansions
= 0;
3565 if (getDerived().TryExpandParameterPacks(Loc
, SourceRange(),
3575 // Expand the function parameter pack into multiple, separate
3577 for (unsigned I
= 0; I
!= NumExpansions
; ++I
) {
3578 Sema::ArgumentPackSubstitutionIndexRAII
SubstIndex(getSema(), I
);
3579 QualType NewType
= getDerived().TransformType(Pattern
);
3580 if (NewType
.isNull())
3583 OutParamTypes
.push_back(NewType
);
3585 PVars
->push_back(0);
3588 // We're done with the pack expansion.
3592 // If we're supposed to retain a pack expansion, do so by temporarily
3593 // forgetting the partially-substituted parameter pack.
3594 if (RetainExpansion
) {
3595 ForgetPartiallySubstitutedPackRAII
Forget(getDerived());
3596 QualType NewType
= getDerived().TransformType(Pattern
);
3597 if (NewType
.isNull())
3600 OutParamTypes
.push_back(NewType
);
3602 PVars
->push_back(0);
3605 // We'll substitute the parameter now without expanding the pack
3607 OldType
= Expansion
->getPattern();
3608 IsPackExpansion
= true;
3611 Sema::ArgumentPackSubstitutionIndexRAII
SubstIndex(getSema(), -1);
3612 QualType NewType
= getDerived().TransformType(OldType
);
3613 if (NewType
.isNull())
3616 if (IsPackExpansion
)
3617 NewType
= getSema().Context
.getPackExpansionType(NewType
);
3619 OutParamTypes
.push_back(NewType
);
3621 PVars
->push_back(0);
3627 template<typename Derived
>
3629 TreeTransform
<Derived
>::TransformFunctionProtoType(TypeLocBuilder
&TLB
,
3630 FunctionProtoTypeLoc TL
) {
3631 // Transform the parameters and return type.
3633 // We instantiate in source order, with the return type first followed by
3634 // the parameters, because users tend to expect this (even if they shouldn't
3637 // When the function has a trailing return type, we instantiate the
3638 // parameters before the return type, since the return type can then refer
3639 // to the parameters themselves (via decltype, sizeof, etc.).
3641 llvm::SmallVector
<QualType
, 4> ParamTypes
;
3642 llvm::SmallVector
<ParmVarDecl
*, 4> ParamDecls
;
3643 FunctionProtoType
*T
= TL
.getTypePtr();
3645 QualType ResultType
;
3647 if (TL
.getTrailingReturn()) {
3648 if (getDerived().TransformFunctionTypeParams(TL
.getBeginLoc(),
3651 TL
.getTypePtr()->arg_type_begin(),
3652 ParamTypes
, &ParamDecls
))
3655 ResultType
= getDerived().TransformType(TLB
, TL
.getResultLoc());
3656 if (ResultType
.isNull())
3660 ResultType
= getDerived().TransformType(TLB
, TL
.getResultLoc());
3661 if (ResultType
.isNull())
3664 if (getDerived().TransformFunctionTypeParams(TL
.getBeginLoc(),
3667 TL
.getTypePtr()->arg_type_begin(),
3668 ParamTypes
, &ParamDecls
))
3672 QualType Result
= TL
.getType();
3673 if (getDerived().AlwaysRebuild() ||
3674 ResultType
!= T
->getResultType() ||
3675 T
->getNumArgs() != ParamTypes
.size() ||
3676 !std::equal(T
->arg_type_begin(), T
->arg_type_end(), ParamTypes
.begin())) {
3677 Result
= getDerived().RebuildFunctionProtoType(ResultType
,
3683 if (Result
.isNull())
3687 FunctionProtoTypeLoc NewTL
= TLB
.push
<FunctionProtoTypeLoc
>(Result
);
3688 NewTL
.setLParenLoc(TL
.getLParenLoc());
3689 NewTL
.setRParenLoc(TL
.getRParenLoc());
3690 NewTL
.setTrailingReturn(TL
.getTrailingReturn());
3691 for (unsigned i
= 0, e
= NewTL
.getNumArgs(); i
!= e
; ++i
)
3692 NewTL
.setArg(i
, ParamDecls
[i
]);
3697 template<typename Derived
>
3698 QualType TreeTransform
<Derived
>::TransformFunctionNoProtoType(
3699 TypeLocBuilder
&TLB
,
3700 FunctionNoProtoTypeLoc TL
) {
3701 FunctionNoProtoType
*T
= TL
.getTypePtr();
3702 QualType ResultType
= getDerived().TransformType(TLB
, TL
.getResultLoc());
3703 if (ResultType
.isNull())
3706 QualType Result
= TL
.getType();
3707 if (getDerived().AlwaysRebuild() ||
3708 ResultType
!= T
->getResultType())
3709 Result
= getDerived().RebuildFunctionNoProtoType(ResultType
);
3711 FunctionNoProtoTypeLoc NewTL
= TLB
.push
<FunctionNoProtoTypeLoc
>(Result
);
3712 NewTL
.setLParenLoc(TL
.getLParenLoc());
3713 NewTL
.setRParenLoc(TL
.getRParenLoc());
3714 NewTL
.setTrailingReturn(false);
3719 template<typename Derived
> QualType
3720 TreeTransform
<Derived
>::TransformUnresolvedUsingType(TypeLocBuilder
&TLB
,
3721 UnresolvedUsingTypeLoc TL
) {
3722 UnresolvedUsingType
*T
= TL
.getTypePtr();
3723 Decl
*D
= getDerived().TransformDecl(TL
.getNameLoc(), T
->getDecl());
3727 QualType Result
= TL
.getType();
3728 if (getDerived().AlwaysRebuild() || D
!= T
->getDecl()) {
3729 Result
= getDerived().RebuildUnresolvedUsingType(D
);
3730 if (Result
.isNull())
3734 // We might get an arbitrary type spec type back. We should at
3735 // least always get a type spec type, though.
3736 TypeSpecTypeLoc NewTL
= TLB
.pushTypeSpec(Result
);
3737 NewTL
.setNameLoc(TL
.getNameLoc());
3742 template<typename Derived
>
3743 QualType TreeTransform
<Derived
>::TransformTypedefType(TypeLocBuilder
&TLB
,
3744 TypedefTypeLoc TL
) {
3745 TypedefType
*T
= TL
.getTypePtr();
3746 TypedefDecl
*Typedef
3747 = cast_or_null
<TypedefDecl
>(getDerived().TransformDecl(TL
.getNameLoc(),
3752 QualType Result
= TL
.getType();
3753 if (getDerived().AlwaysRebuild() ||
3754 Typedef
!= T
->getDecl()) {
3755 Result
= getDerived().RebuildTypedefType(Typedef
);
3756 if (Result
.isNull())
3760 TypedefTypeLoc NewTL
= TLB
.push
<TypedefTypeLoc
>(Result
);
3761 NewTL
.setNameLoc(TL
.getNameLoc());
3766 template<typename Derived
>
3767 QualType TreeTransform
<Derived
>::TransformTypeOfExprType(TypeLocBuilder
&TLB
,
3768 TypeOfExprTypeLoc TL
) {
3769 // typeof expressions are not potentially evaluated contexts
3770 EnterExpressionEvaluationContext
Unevaluated(SemaRef
, Sema::Unevaluated
);
3772 ExprResult E
= getDerived().TransformExpr(TL
.getUnderlyingExpr());
3776 QualType Result
= TL
.getType();
3777 if (getDerived().AlwaysRebuild() ||
3778 E
.get() != TL
.getUnderlyingExpr()) {
3779 Result
= getDerived().RebuildTypeOfExprType(E
.get(), TL
.getTypeofLoc());
3780 if (Result
.isNull())
3785 TypeOfExprTypeLoc NewTL
= TLB
.push
<TypeOfExprTypeLoc
>(Result
);
3786 NewTL
.setTypeofLoc(TL
.getTypeofLoc());
3787 NewTL
.setLParenLoc(TL
.getLParenLoc());
3788 NewTL
.setRParenLoc(TL
.getRParenLoc());
3793 template<typename Derived
>
3794 QualType TreeTransform
<Derived
>::TransformTypeOfType(TypeLocBuilder
&TLB
,
3796 TypeSourceInfo
* Old_Under_TI
= TL
.getUnderlyingTInfo();
3797 TypeSourceInfo
* New_Under_TI
= getDerived().TransformType(Old_Under_TI
);
3801 QualType Result
= TL
.getType();
3802 if (getDerived().AlwaysRebuild() || New_Under_TI
!= Old_Under_TI
) {
3803 Result
= getDerived().RebuildTypeOfType(New_Under_TI
->getType());
3804 if (Result
.isNull())
3808 TypeOfTypeLoc NewTL
= TLB
.push
<TypeOfTypeLoc
>(Result
);
3809 NewTL
.setTypeofLoc(TL
.getTypeofLoc());
3810 NewTL
.setLParenLoc(TL
.getLParenLoc());
3811 NewTL
.setRParenLoc(TL
.getRParenLoc());
3812 NewTL
.setUnderlyingTInfo(New_Under_TI
);
3817 template<typename Derived
>
3818 QualType TreeTransform
<Derived
>::TransformDecltypeType(TypeLocBuilder
&TLB
,
3819 DecltypeTypeLoc TL
) {
3820 DecltypeType
*T
= TL
.getTypePtr();
3822 // decltype expressions are not potentially evaluated contexts
3823 EnterExpressionEvaluationContext
Unevaluated(SemaRef
, Sema::Unevaluated
);
3825 ExprResult E
= getDerived().TransformExpr(T
->getUnderlyingExpr());
3829 QualType Result
= TL
.getType();
3830 if (getDerived().AlwaysRebuild() ||
3831 E
.get() != T
->getUnderlyingExpr()) {
3832 Result
= getDerived().RebuildDecltypeType(E
.get(), TL
.getNameLoc());
3833 if (Result
.isNull())
3838 DecltypeTypeLoc NewTL
= TLB
.push
<DecltypeTypeLoc
>(Result
);
3839 NewTL
.setNameLoc(TL
.getNameLoc());
3844 template<typename Derived
>
3845 QualType TreeTransform
<Derived
>::TransformRecordType(TypeLocBuilder
&TLB
,
3847 RecordType
*T
= TL
.getTypePtr();
3849 = cast_or_null
<RecordDecl
>(getDerived().TransformDecl(TL
.getNameLoc(),
3854 QualType Result
= TL
.getType();
3855 if (getDerived().AlwaysRebuild() ||
3856 Record
!= T
->getDecl()) {
3857 Result
= getDerived().RebuildRecordType(Record
);
3858 if (Result
.isNull())
3862 RecordTypeLoc NewTL
= TLB
.push
<RecordTypeLoc
>(Result
);
3863 NewTL
.setNameLoc(TL
.getNameLoc());
3868 template<typename Derived
>
3869 QualType TreeTransform
<Derived
>::TransformEnumType(TypeLocBuilder
&TLB
,
3871 EnumType
*T
= TL
.getTypePtr();
3873 = cast_or_null
<EnumDecl
>(getDerived().TransformDecl(TL
.getNameLoc(),
3878 QualType Result
= TL
.getType();
3879 if (getDerived().AlwaysRebuild() ||
3880 Enum
!= T
->getDecl()) {
3881 Result
= getDerived().RebuildEnumType(Enum
);
3882 if (Result
.isNull())
3886 EnumTypeLoc NewTL
= TLB
.push
<EnumTypeLoc
>(Result
);
3887 NewTL
.setNameLoc(TL
.getNameLoc());
3892 template<typename Derived
>
3893 QualType TreeTransform
<Derived
>::TransformInjectedClassNameType(
3894 TypeLocBuilder
&TLB
,
3895 InjectedClassNameTypeLoc TL
) {
3896 Decl
*D
= getDerived().TransformDecl(TL
.getNameLoc(),
3897 TL
.getTypePtr()->getDecl());
3898 if (!D
) return QualType();
3900 QualType T
= SemaRef
.Context
.getTypeDeclType(cast
<TypeDecl
>(D
));
3901 TLB
.pushTypeSpec(T
).setNameLoc(TL
.getNameLoc());
3905 template<typename Derived
>
3906 QualType TreeTransform
<Derived
>::TransformTemplateTypeParmType(
3907 TypeLocBuilder
&TLB
,
3908 TemplateTypeParmTypeLoc TL
) {
3909 return TransformTypeSpecType(TLB
, TL
);
3912 template<typename Derived
>
3913 QualType TreeTransform
<Derived
>::TransformSubstTemplateTypeParmType(
3914 TypeLocBuilder
&TLB
,
3915 SubstTemplateTypeParmTypeLoc TL
) {
3916 return TransformTypeSpecType(TLB
, TL
);
3919 template<typename Derived
>
3920 QualType TreeTransform
<Derived
>::TransformTemplateSpecializationType(
3921 TypeLocBuilder
&TLB
,
3922 TemplateSpecializationTypeLoc TL
) {
3923 const TemplateSpecializationType
*T
= TL
.getTypePtr();
3925 TemplateName Template
3926 = getDerived().TransformTemplateName(T
->getTemplateName());
3927 if (Template
.isNull())
3930 return getDerived().TransformTemplateSpecializationType(TLB
, TL
, Template
);
3934 /// \brief Simple iterator that traverses the template arguments in a
3935 /// container that provides a \c getArgLoc() member function.
3937 /// This iterator is intended to be used with the iterator form of
3938 /// \c TreeTransform<Derived>::TransformTemplateArguments().
3939 template<typename ArgLocContainer
>
3940 class TemplateArgumentLocContainerIterator
{
3941 ArgLocContainer
*Container
;
3945 typedef TemplateArgumentLoc value_type
;
3946 typedef TemplateArgumentLoc reference
;
3947 typedef int difference_type
;
3948 typedef std::input_iterator_tag iterator_category
;
3951 TemplateArgumentLoc Arg
;
3954 explicit pointer(TemplateArgumentLoc Arg
) : Arg(Arg
) { }
3956 const TemplateArgumentLoc
*operator->() const {
3962 TemplateArgumentLocContainerIterator() {}
3964 TemplateArgumentLocContainerIterator(ArgLocContainer
&Container
,
3966 : Container(&Container
), Index(Index
) { }
3968 TemplateArgumentLocContainerIterator
&operator++() {
3973 TemplateArgumentLocContainerIterator
operator++(int) {
3974 TemplateArgumentLocContainerIterator
Old(*this);
3979 TemplateArgumentLoc
operator*() const {
3980 return Container
->getArgLoc(Index
);
3983 pointer
operator->() const {
3984 return pointer(Container
->getArgLoc(Index
));
3987 friend bool operator==(const TemplateArgumentLocContainerIterator
&X
,
3988 const TemplateArgumentLocContainerIterator
&Y
) {
3989 return X
.Container
== Y
.Container
&& X
.Index
== Y
.Index
;
3992 friend bool operator!=(const TemplateArgumentLocContainerIterator
&X
,
3993 const TemplateArgumentLocContainerIterator
&Y
) {
4000 template <typename Derived
>
4001 QualType TreeTransform
<Derived
>::TransformTemplateSpecializationType(
4002 TypeLocBuilder
&TLB
,
4003 TemplateSpecializationTypeLoc TL
,
4004 TemplateName Template
) {
4005 TemplateArgumentListInfo NewTemplateArgs
;
4006 NewTemplateArgs
.setLAngleLoc(TL
.getLAngleLoc());
4007 NewTemplateArgs
.setRAngleLoc(TL
.getRAngleLoc());
4008 typedef TemplateArgumentLocContainerIterator
<TemplateSpecializationTypeLoc
>
4010 if (getDerived().TransformTemplateArguments(ArgIterator(TL
, 0),
4011 ArgIterator(TL
, TL
.getNumArgs()),
4015 // FIXME: maybe don't rebuild if all the template arguments are the same.
4018 getDerived().RebuildTemplateSpecializationType(Template
,
4019 TL
.getTemplateNameLoc(),
4022 if (!Result
.isNull()) {
4023 TemplateSpecializationTypeLoc NewTL
4024 = TLB
.push
<TemplateSpecializationTypeLoc
>(Result
);
4025 NewTL
.setTemplateNameLoc(TL
.getTemplateNameLoc());
4026 NewTL
.setLAngleLoc(TL
.getLAngleLoc());
4027 NewTL
.setRAngleLoc(TL
.getRAngleLoc());
4028 for (unsigned i
= 0, e
= NewTemplateArgs
.size(); i
!= e
; ++i
)
4029 NewTL
.setArgLocInfo(i
, NewTemplateArgs
[i
].getLocInfo());
4035 template<typename Derived
>
4037 TreeTransform
<Derived
>::TransformElaboratedType(TypeLocBuilder
&TLB
,
4038 ElaboratedTypeLoc TL
) {
4039 ElaboratedType
*T
= TL
.getTypePtr();
4041 NestedNameSpecifier
*NNS
= 0;
4042 // NOTE: the qualifier in an ElaboratedType is optional.
4043 if (T
->getQualifier() != 0) {
4044 NNS
= getDerived().TransformNestedNameSpecifier(T
->getQualifier(),
4045 TL
.getQualifierRange());
4050 QualType NamedT
= getDerived().TransformType(TLB
, TL
.getNamedTypeLoc());
4051 if (NamedT
.isNull())
4054 QualType Result
= TL
.getType();
4055 if (getDerived().AlwaysRebuild() ||
4056 NNS
!= T
->getQualifier() ||
4057 NamedT
!= T
->getNamedType()) {
4058 Result
= getDerived().RebuildElaboratedType(TL
.getKeywordLoc(),
4059 T
->getKeyword(), NNS
, NamedT
);
4060 if (Result
.isNull())
4064 ElaboratedTypeLoc NewTL
= TLB
.push
<ElaboratedTypeLoc
>(Result
);
4065 NewTL
.setKeywordLoc(TL
.getKeywordLoc());
4066 NewTL
.setQualifierRange(TL
.getQualifierRange());
4071 template<typename Derived
>
4072 QualType TreeTransform
<Derived
>::TransformAttributedType(
4073 TypeLocBuilder
&TLB
,
4074 AttributedTypeLoc TL
) {
4075 const AttributedType
*oldType
= TL
.getTypePtr();
4076 QualType modifiedType
= getDerived().TransformType(TLB
, TL
.getModifiedLoc());
4077 if (modifiedType
.isNull())
4080 QualType result
= TL
.getType();
4082 // FIXME: dependent operand expressions?
4083 if (getDerived().AlwaysRebuild() ||
4084 modifiedType
!= oldType
->getModifiedType()) {
4085 // TODO: this is really lame; we should really be rebuilding the
4086 // equivalent type from first principles.
4087 QualType equivalentType
4088 = getDerived().TransformType(oldType
->getEquivalentType());
4089 if (equivalentType
.isNull())
4091 result
= SemaRef
.Context
.getAttributedType(oldType
->getAttrKind(),
4096 AttributedTypeLoc newTL
= TLB
.push
<AttributedTypeLoc
>(result
);
4097 newTL
.setAttrNameLoc(TL
.getAttrNameLoc());
4098 if (TL
.hasAttrOperand())
4099 newTL
.setAttrOperandParensRange(TL
.getAttrOperandParensRange());
4100 if (TL
.hasAttrExprOperand())
4101 newTL
.setAttrExprOperand(TL
.getAttrExprOperand());
4102 else if (TL
.hasAttrEnumOperand())
4103 newTL
.setAttrEnumOperandLoc(TL
.getAttrEnumOperandLoc());
4108 template<typename Derived
>
4110 TreeTransform
<Derived
>::TransformParenType(TypeLocBuilder
&TLB
,
4112 QualType Inner
= getDerived().TransformType(TLB
, TL
.getInnerLoc());
4116 QualType Result
= TL
.getType();
4117 if (getDerived().AlwaysRebuild() ||
4118 Inner
!= TL
.getInnerLoc().getType()) {
4119 Result
= getDerived().RebuildParenType(Inner
);
4120 if (Result
.isNull())
4124 ParenTypeLoc NewTL
= TLB
.push
<ParenTypeLoc
>(Result
);
4125 NewTL
.setLParenLoc(TL
.getLParenLoc());
4126 NewTL
.setRParenLoc(TL
.getRParenLoc());
4130 template<typename Derived
>
4131 QualType TreeTransform
<Derived
>::TransformDependentNameType(TypeLocBuilder
&TLB
,
4132 DependentNameTypeLoc TL
) {
4133 DependentNameType
*T
= TL
.getTypePtr();
4135 NestedNameSpecifier
*NNS
4136 = getDerived().TransformNestedNameSpecifier(T
->getQualifier(),
4137 TL
.getQualifierRange());
4142 = getDerived().RebuildDependentNameType(T
->getKeyword(), NNS
,
4145 TL
.getQualifierRange(),
4147 if (Result
.isNull())
4150 if (const ElaboratedType
* ElabT
= Result
->getAs
<ElaboratedType
>()) {
4151 QualType NamedT
= ElabT
->getNamedType();
4152 TLB
.pushTypeSpec(NamedT
).setNameLoc(TL
.getNameLoc());
4154 ElaboratedTypeLoc NewTL
= TLB
.push
<ElaboratedTypeLoc
>(Result
);
4155 NewTL
.setKeywordLoc(TL
.getKeywordLoc());
4156 NewTL
.setQualifierRange(TL
.getQualifierRange());
4158 DependentNameTypeLoc NewTL
= TLB
.push
<DependentNameTypeLoc
>(Result
);
4159 NewTL
.setKeywordLoc(TL
.getKeywordLoc());
4160 NewTL
.setQualifierRange(TL
.getQualifierRange());
4161 NewTL
.setNameLoc(TL
.getNameLoc());
4166 template<typename Derived
>
4167 QualType TreeTransform
<Derived
>::
4168 TransformDependentTemplateSpecializationType(TypeLocBuilder
&TLB
,
4169 DependentTemplateSpecializationTypeLoc TL
) {
4170 DependentTemplateSpecializationType
*T
= TL
.getTypePtr();
4172 NestedNameSpecifier
*NNS
4173 = getDerived().TransformNestedNameSpecifier(T
->getQualifier(),
4174 TL
.getQualifierRange());
4179 .TransformDependentTemplateSpecializationType(TLB
, TL
, NNS
);
4182 template<typename Derived
>
4183 QualType TreeTransform
<Derived
>::
4184 TransformDependentTemplateSpecializationType(TypeLocBuilder
&TLB
,
4185 DependentTemplateSpecializationTypeLoc TL
,
4186 NestedNameSpecifier
*NNS
) {
4187 DependentTemplateSpecializationType
*T
= TL
.getTypePtr();
4189 TemplateArgumentListInfo NewTemplateArgs
;
4190 NewTemplateArgs
.setLAngleLoc(TL
.getLAngleLoc());
4191 NewTemplateArgs
.setRAngleLoc(TL
.getRAngleLoc());
4193 typedef TemplateArgumentLocContainerIterator
<
4194 DependentTemplateSpecializationTypeLoc
> ArgIterator
;
4195 if (getDerived().TransformTemplateArguments(ArgIterator(TL
, 0),
4196 ArgIterator(TL
, TL
.getNumArgs()),
4201 = getDerived().RebuildDependentTemplateSpecializationType(T
->getKeyword(),
4203 TL
.getQualifierRange(),
4207 if (Result
.isNull())
4210 if (const ElaboratedType
*ElabT
= dyn_cast
<ElaboratedType
>(Result
)) {
4211 QualType NamedT
= ElabT
->getNamedType();
4213 // Copy information relevant to the template specialization.
4214 TemplateSpecializationTypeLoc NamedTL
4215 = TLB
.push
<TemplateSpecializationTypeLoc
>(NamedT
);
4216 NamedTL
.setLAngleLoc(TL
.getLAngleLoc());
4217 NamedTL
.setRAngleLoc(TL
.getRAngleLoc());
4218 for (unsigned I
= 0, E
= TL
.getNumArgs(); I
!= E
; ++I
)
4219 NamedTL
.setArgLocInfo(I
, TL
.getArgLocInfo(I
));
4221 // Copy information relevant to the elaborated type.
4222 ElaboratedTypeLoc NewTL
= TLB
.push
<ElaboratedTypeLoc
>(Result
);
4223 NewTL
.setKeywordLoc(TL
.getKeywordLoc());
4224 NewTL
.setQualifierRange(TL
.getQualifierRange());
4226 TypeLoc
NewTL(Result
, TL
.getOpaqueData());
4227 TLB
.pushFullCopy(NewTL
);
4232 template<typename Derived
>
4233 QualType TreeTransform
<Derived
>::TransformPackExpansionType(TypeLocBuilder
&TLB
,
4234 PackExpansionTypeLoc TL
) {
4235 llvm_unreachable("Caller must expansion pack expansion types");
4239 template<typename Derived
>
4241 TreeTransform
<Derived
>::TransformObjCInterfaceType(TypeLocBuilder
&TLB
,
4242 ObjCInterfaceTypeLoc TL
) {
4243 // ObjCInterfaceType is never dependent.
4244 TLB
.pushFullCopy(TL
);
4245 return TL
.getType();
4248 template<typename Derived
>
4250 TreeTransform
<Derived
>::TransformObjCObjectType(TypeLocBuilder
&TLB
,
4251 ObjCObjectTypeLoc TL
) {
4252 // ObjCObjectType is never dependent.
4253 TLB
.pushFullCopy(TL
);
4254 return TL
.getType();
4257 template<typename Derived
>
4259 TreeTransform
<Derived
>::TransformObjCObjectPointerType(TypeLocBuilder
&TLB
,
4260 ObjCObjectPointerTypeLoc TL
) {
4261 // ObjCObjectPointerType is never dependent.
4262 TLB
.pushFullCopy(TL
);
4263 return TL
.getType();
4266 //===----------------------------------------------------------------------===//
4267 // Statement transformation
4268 //===----------------------------------------------------------------------===//
4269 template<typename Derived
>
4271 TreeTransform
<Derived
>::TransformNullStmt(NullStmt
*S
) {
4272 return SemaRef
.Owned(S
);
4275 template<typename Derived
>
4277 TreeTransform
<Derived
>::TransformCompoundStmt(CompoundStmt
*S
) {
4278 return getDerived().TransformCompoundStmt(S
, false);
4281 template<typename Derived
>
4283 TreeTransform
<Derived
>::TransformCompoundStmt(CompoundStmt
*S
,
4285 bool SubStmtInvalid
= false;
4286 bool SubStmtChanged
= false;
4287 ASTOwningVector
<Stmt
*> Statements(getSema());
4288 for (CompoundStmt::body_iterator B
= S
->body_begin(), BEnd
= S
->body_end();
4290 StmtResult Result
= getDerived().TransformStmt(*B
);
4291 if (Result
.isInvalid()) {
4292 // Immediately fail if this was a DeclStmt, since it's very
4293 // likely that this will cause problems for future statements.
4294 if (isa
<DeclStmt
>(*B
))
4297 // Otherwise, just keep processing substatements and fail later.
4298 SubStmtInvalid
= true;
4302 SubStmtChanged
= SubStmtChanged
|| Result
.get() != *B
;
4303 Statements
.push_back(Result
.takeAs
<Stmt
>());
4309 if (!getDerived().AlwaysRebuild() &&
4311 return SemaRef
.Owned(S
);
4313 return getDerived().RebuildCompoundStmt(S
->getLBracLoc(),
4314 move_arg(Statements
),
4319 template<typename Derived
>
4321 TreeTransform
<Derived
>::TransformCaseStmt(CaseStmt
*S
) {
4322 ExprResult LHS
, RHS
;
4324 // The case value expressions are not potentially evaluated.
4325 EnterExpressionEvaluationContext
Unevaluated(SemaRef
, Sema::Unevaluated
);
4327 // Transform the left-hand case value.
4328 LHS
= getDerived().TransformExpr(S
->getLHS());
4329 if (LHS
.isInvalid())
4332 // Transform the right-hand case value (for the GNU case-range extension).
4333 RHS
= getDerived().TransformExpr(S
->getRHS());
4334 if (RHS
.isInvalid())
4338 // Build the case statement.
4339 // Case statements are always rebuilt so that they will attached to their
4340 // transformed switch statement.
4341 StmtResult Case
= getDerived().RebuildCaseStmt(S
->getCaseLoc(),
4343 S
->getEllipsisLoc(),
4346 if (Case
.isInvalid())
4349 // Transform the statement following the case
4350 StmtResult SubStmt
= getDerived().TransformStmt(S
->getSubStmt());
4351 if (SubStmt
.isInvalid())
4354 // Attach the body to the case statement
4355 return getDerived().RebuildCaseStmtBody(Case
.get(), SubStmt
.get());
4358 template<typename Derived
>
4360 TreeTransform
<Derived
>::TransformDefaultStmt(DefaultStmt
*S
) {
4361 // Transform the statement following the default case
4362 StmtResult SubStmt
= getDerived().TransformStmt(S
->getSubStmt());
4363 if (SubStmt
.isInvalid())
4366 // Default statements are always rebuilt
4367 return getDerived().RebuildDefaultStmt(S
->getDefaultLoc(), S
->getColonLoc(),
4371 template<typename Derived
>
4373 TreeTransform
<Derived
>::TransformLabelStmt(LabelStmt
*S
) {
4374 StmtResult SubStmt
= getDerived().TransformStmt(S
->getSubStmt());
4375 if (SubStmt
.isInvalid())
4378 // FIXME: Pass the real colon location in.
4379 SourceLocation ColonLoc
= SemaRef
.PP
.getLocForEndOfToken(S
->getIdentLoc());
4380 return getDerived().RebuildLabelStmt(S
->getIdentLoc(), S
->getID(), ColonLoc
,
4381 SubStmt
.get(), S
->HasUnusedAttribute());
4384 template<typename Derived
>
4386 TreeTransform
<Derived
>::TransformIfStmt(IfStmt
*S
) {
4387 // Transform the condition
4389 VarDecl
*ConditionVar
= 0;
4390 if (S
->getConditionVariable()) {
4392 = cast_or_null
<VarDecl
>(
4393 getDerived().TransformDefinition(
4394 S
->getConditionVariable()->getLocation(),
4395 S
->getConditionVariable()));
4399 Cond
= getDerived().TransformExpr(S
->getCond());
4401 if (Cond
.isInvalid())
4404 // Convert the condition to a boolean value.
4406 ExprResult CondE
= getSema().ActOnBooleanCondition(0, S
->getIfLoc(),
4408 if (CondE
.isInvalid())
4415 Sema::FullExprArg
FullCond(getSema().MakeFullExpr(Cond
.take()));
4416 if (!S
->getConditionVariable() && S
->getCond() && !FullCond
.get())
4419 // Transform the "then" branch.
4420 StmtResult Then
= getDerived().TransformStmt(S
->getThen());
4421 if (Then
.isInvalid())
4424 // Transform the "else" branch.
4425 StmtResult Else
= getDerived().TransformStmt(S
->getElse());
4426 if (Else
.isInvalid())
4429 if (!getDerived().AlwaysRebuild() &&
4430 FullCond
.get() == S
->getCond() &&
4431 ConditionVar
== S
->getConditionVariable() &&
4432 Then
.get() == S
->getThen() &&
4433 Else
.get() == S
->getElse())
4434 return SemaRef
.Owned(S
);
4436 return getDerived().RebuildIfStmt(S
->getIfLoc(), FullCond
, ConditionVar
,
4438 S
->getElseLoc(), Else
.get());
4441 template<typename Derived
>
4443 TreeTransform
<Derived
>::TransformSwitchStmt(SwitchStmt
*S
) {
4444 // Transform the condition.
4446 VarDecl
*ConditionVar
= 0;
4447 if (S
->getConditionVariable()) {
4449 = cast_or_null
<VarDecl
>(
4450 getDerived().TransformDefinition(
4451 S
->getConditionVariable()->getLocation(),
4452 S
->getConditionVariable()));
4456 Cond
= getDerived().TransformExpr(S
->getCond());
4458 if (Cond
.isInvalid())
4462 // Rebuild the switch statement.
4464 = getDerived().RebuildSwitchStmtStart(S
->getSwitchLoc(), Cond
.get(),
4466 if (Switch
.isInvalid())
4469 // Transform the body of the switch statement.
4470 StmtResult Body
= getDerived().TransformStmt(S
->getBody());
4471 if (Body
.isInvalid())
4474 // Complete the switch statement.
4475 return getDerived().RebuildSwitchStmtBody(S
->getSwitchLoc(), Switch
.get(),
4479 template<typename Derived
>
4481 TreeTransform
<Derived
>::TransformWhileStmt(WhileStmt
*S
) {
4482 // Transform the condition
4484 VarDecl
*ConditionVar
= 0;
4485 if (S
->getConditionVariable()) {
4487 = cast_or_null
<VarDecl
>(
4488 getDerived().TransformDefinition(
4489 S
->getConditionVariable()->getLocation(),
4490 S
->getConditionVariable()));
4494 Cond
= getDerived().TransformExpr(S
->getCond());
4496 if (Cond
.isInvalid())
4500 // Convert the condition to a boolean value.
4501 ExprResult CondE
= getSema().ActOnBooleanCondition(0, S
->getWhileLoc(),
4503 if (CondE
.isInvalid())
4509 Sema::FullExprArg
FullCond(getSema().MakeFullExpr(Cond
.take()));
4510 if (!S
->getConditionVariable() && S
->getCond() && !FullCond
.get())
4513 // Transform the body
4514 StmtResult Body
= getDerived().TransformStmt(S
->getBody());
4515 if (Body
.isInvalid())
4518 if (!getDerived().AlwaysRebuild() &&
4519 FullCond
.get() == S
->getCond() &&
4520 ConditionVar
== S
->getConditionVariable() &&
4521 Body
.get() == S
->getBody())
4524 return getDerived().RebuildWhileStmt(S
->getWhileLoc(), FullCond
,
4525 ConditionVar
, Body
.get());
4528 template<typename Derived
>
4530 TreeTransform
<Derived
>::TransformDoStmt(DoStmt
*S
) {
4531 // Transform the body
4532 StmtResult Body
= getDerived().TransformStmt(S
->getBody());
4533 if (Body
.isInvalid())
4536 // Transform the condition
4537 ExprResult Cond
= getDerived().TransformExpr(S
->getCond());
4538 if (Cond
.isInvalid())
4541 if (!getDerived().AlwaysRebuild() &&
4542 Cond
.get() == S
->getCond() &&
4543 Body
.get() == S
->getBody())
4544 return SemaRef
.Owned(S
);
4546 return getDerived().RebuildDoStmt(S
->getDoLoc(), Body
.get(), S
->getWhileLoc(),
4547 /*FIXME:*/S
->getWhileLoc(), Cond
.get(),
4551 template<typename Derived
>
4553 TreeTransform
<Derived
>::TransformForStmt(ForStmt
*S
) {
4554 // Transform the initialization statement
4555 StmtResult Init
= getDerived().TransformStmt(S
->getInit());
4556 if (Init
.isInvalid())
4559 // Transform the condition
4561 VarDecl
*ConditionVar
= 0;
4562 if (S
->getConditionVariable()) {
4564 = cast_or_null
<VarDecl
>(
4565 getDerived().TransformDefinition(
4566 S
->getConditionVariable()->getLocation(),
4567 S
->getConditionVariable()));
4571 Cond
= getDerived().TransformExpr(S
->getCond());
4573 if (Cond
.isInvalid())
4577 // Convert the condition to a boolean value.
4578 ExprResult CondE
= getSema().ActOnBooleanCondition(0, S
->getForLoc(),
4580 if (CondE
.isInvalid())
4587 Sema::FullExprArg
FullCond(getSema().MakeFullExpr(Cond
.take()));
4588 if (!S
->getConditionVariable() && S
->getCond() && !FullCond
.get())
4591 // Transform the increment
4592 ExprResult Inc
= getDerived().TransformExpr(S
->getInc());
4593 if (Inc
.isInvalid())
4596 Sema::FullExprArg
FullInc(getSema().MakeFullExpr(Inc
.get()));
4597 if (S
->getInc() && !FullInc
.get())
4600 // Transform the body
4601 StmtResult Body
= getDerived().TransformStmt(S
->getBody());
4602 if (Body
.isInvalid())
4605 if (!getDerived().AlwaysRebuild() &&
4606 Init
.get() == S
->getInit() &&
4607 FullCond
.get() == S
->getCond() &&
4608 Inc
.get() == S
->getInc() &&
4609 Body
.get() == S
->getBody())
4610 return SemaRef
.Owned(S
);
4612 return getDerived().RebuildForStmt(S
->getForLoc(), S
->getLParenLoc(),
4613 Init
.get(), FullCond
, ConditionVar
,
4614 FullInc
, S
->getRParenLoc(), Body
.get());
4617 template<typename Derived
>
4619 TreeTransform
<Derived
>::TransformGotoStmt(GotoStmt
*S
) {
4620 // Goto statements must always be rebuilt, to resolve the label.
4621 return getDerived().RebuildGotoStmt(S
->getGotoLoc(), S
->getLabelLoc(),
4625 template<typename Derived
>
4627 TreeTransform
<Derived
>::TransformIndirectGotoStmt(IndirectGotoStmt
*S
) {
4628 ExprResult Target
= getDerived().TransformExpr(S
->getTarget());
4629 if (Target
.isInvalid())
4632 if (!getDerived().AlwaysRebuild() &&
4633 Target
.get() == S
->getTarget())
4634 return SemaRef
.Owned(S
);
4636 return getDerived().RebuildIndirectGotoStmt(S
->getGotoLoc(), S
->getStarLoc(),
4640 template<typename Derived
>
4642 TreeTransform
<Derived
>::TransformContinueStmt(ContinueStmt
*S
) {
4643 return SemaRef
.Owned(S
);
4646 template<typename Derived
>
4648 TreeTransform
<Derived
>::TransformBreakStmt(BreakStmt
*S
) {
4649 return SemaRef
.Owned(S
);
4652 template<typename Derived
>
4654 TreeTransform
<Derived
>::TransformReturnStmt(ReturnStmt
*S
) {
4655 ExprResult Result
= getDerived().TransformExpr(S
->getRetValue());
4656 if (Result
.isInvalid())
4659 // FIXME: We always rebuild the return statement because there is no way
4660 // to tell whether the return type of the function has changed.
4661 return getDerived().RebuildReturnStmt(S
->getReturnLoc(), Result
.get());
4664 template<typename Derived
>
4666 TreeTransform
<Derived
>::TransformDeclStmt(DeclStmt
*S
) {
4667 bool DeclChanged
= false;
4668 llvm::SmallVector
<Decl
*, 4> Decls
;
4669 for (DeclStmt::decl_iterator D
= S
->decl_begin(), DEnd
= S
->decl_end();
4671 Decl
*Transformed
= getDerived().TransformDefinition((*D
)->getLocation(),
4676 if (Transformed
!= *D
)
4679 Decls
.push_back(Transformed
);
4682 if (!getDerived().AlwaysRebuild() && !DeclChanged
)
4683 return SemaRef
.Owned(S
);
4685 return getDerived().RebuildDeclStmt(Decls
.data(), Decls
.size(),
4686 S
->getStartLoc(), S
->getEndLoc());
4689 template<typename Derived
>
4691 TreeTransform
<Derived
>::TransformSwitchCase(SwitchCase
*S
) {
4692 assert(false && "SwitchCase is abstract and cannot be transformed");
4693 return SemaRef
.Owned(S
);
4696 template<typename Derived
>
4698 TreeTransform
<Derived
>::TransformAsmStmt(AsmStmt
*S
) {
4700 ASTOwningVector
<Expr
*> Constraints(getSema());
4701 ASTOwningVector
<Expr
*> Exprs(getSema());
4702 llvm::SmallVector
<IdentifierInfo
*, 4> Names
;
4704 ExprResult AsmString
;
4705 ASTOwningVector
<Expr
*> Clobbers(getSema());
4707 bool ExprsChanged
= false;
4709 // Go through the outputs.
4710 for (unsigned I
= 0, E
= S
->getNumOutputs(); I
!= E
; ++I
) {
4711 Names
.push_back(S
->getOutputIdentifier(I
));
4713 // No need to transform the constraint literal.
4714 Constraints
.push_back(S
->getOutputConstraintLiteral(I
));
4716 // Transform the output expr.
4717 Expr
*OutputExpr
= S
->getOutputExpr(I
);
4718 ExprResult Result
= getDerived().TransformExpr(OutputExpr
);
4719 if (Result
.isInvalid())
4722 ExprsChanged
|= Result
.get() != OutputExpr
;
4724 Exprs
.push_back(Result
.get());
4727 // Go through the inputs.
4728 for (unsigned I
= 0, E
= S
->getNumInputs(); I
!= E
; ++I
) {
4729 Names
.push_back(S
->getInputIdentifier(I
));
4731 // No need to transform the constraint literal.
4732 Constraints
.push_back(S
->getInputConstraintLiteral(I
));
4734 // Transform the input expr.
4735 Expr
*InputExpr
= S
->getInputExpr(I
);
4736 ExprResult Result
= getDerived().TransformExpr(InputExpr
);
4737 if (Result
.isInvalid())
4740 ExprsChanged
|= Result
.get() != InputExpr
;
4742 Exprs
.push_back(Result
.get());
4745 if (!getDerived().AlwaysRebuild() && !ExprsChanged
)
4746 return SemaRef
.Owned(S
);
4748 // Go through the clobbers.
4749 for (unsigned I
= 0, E
= S
->getNumClobbers(); I
!= E
; ++I
)
4750 Clobbers
.push_back(S
->getClobber(I
));
4752 // No need to transform the asm string literal.
4753 AsmString
= SemaRef
.Owned(S
->getAsmString());
4755 return getDerived().RebuildAsmStmt(S
->getAsmLoc(),
4761 move_arg(Constraints
),
4770 template<typename Derived
>
4772 TreeTransform
<Derived
>::TransformObjCAtTryStmt(ObjCAtTryStmt
*S
) {
4773 // Transform the body of the @try.
4774 StmtResult TryBody
= getDerived().TransformStmt(S
->getTryBody());
4775 if (TryBody
.isInvalid())
4778 // Transform the @catch statements (if present).
4779 bool AnyCatchChanged
= false;
4780 ASTOwningVector
<Stmt
*> CatchStmts(SemaRef
);
4781 for (unsigned I
= 0, N
= S
->getNumCatchStmts(); I
!= N
; ++I
) {
4782 StmtResult Catch
= getDerived().TransformStmt(S
->getCatchStmt(I
));
4783 if (Catch
.isInvalid())
4785 if (Catch
.get() != S
->getCatchStmt(I
))
4786 AnyCatchChanged
= true;
4787 CatchStmts
.push_back(Catch
.release());
4790 // Transform the @finally statement (if present).
4792 if (S
->getFinallyStmt()) {
4793 Finally
= getDerived().TransformStmt(S
->getFinallyStmt());
4794 if (Finally
.isInvalid())
4798 // If nothing changed, just retain this statement.
4799 if (!getDerived().AlwaysRebuild() &&
4800 TryBody
.get() == S
->getTryBody() &&
4802 Finally
.get() == S
->getFinallyStmt())
4803 return SemaRef
.Owned(S
);
4805 // Build a new statement.
4806 return getDerived().RebuildObjCAtTryStmt(S
->getAtTryLoc(), TryBody
.get(),
4807 move_arg(CatchStmts
), Finally
.get());
4810 template<typename Derived
>
4812 TreeTransform
<Derived
>::TransformObjCAtCatchStmt(ObjCAtCatchStmt
*S
) {
4813 // Transform the @catch parameter, if there is one.
4815 if (VarDecl
*FromVar
= S
->getCatchParamDecl()) {
4816 TypeSourceInfo
*TSInfo
= 0;
4817 if (FromVar
->getTypeSourceInfo()) {
4818 TSInfo
= getDerived().TransformType(FromVar
->getTypeSourceInfo());
4825 T
= TSInfo
->getType();
4827 T
= getDerived().TransformType(FromVar
->getType());
4832 Var
= getDerived().RebuildObjCExceptionDecl(FromVar
, TSInfo
, T
);
4837 StmtResult Body
= getDerived().TransformStmt(S
->getCatchBody());
4838 if (Body
.isInvalid())
4841 return getDerived().RebuildObjCAtCatchStmt(S
->getAtCatchLoc(),
4846 template<typename Derived
>
4848 TreeTransform
<Derived
>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt
*S
) {
4849 // Transform the body.
4850 StmtResult Body
= getDerived().TransformStmt(S
->getFinallyBody());
4851 if (Body
.isInvalid())
4854 // If nothing changed, just retain this statement.
4855 if (!getDerived().AlwaysRebuild() &&
4856 Body
.get() == S
->getFinallyBody())
4857 return SemaRef
.Owned(S
);
4859 // Build a new statement.
4860 return getDerived().RebuildObjCAtFinallyStmt(S
->getAtFinallyLoc(),
4864 template<typename Derived
>
4866 TreeTransform
<Derived
>::TransformObjCAtThrowStmt(ObjCAtThrowStmt
*S
) {
4868 if (S
->getThrowExpr()) {
4869 Operand
= getDerived().TransformExpr(S
->getThrowExpr());
4870 if (Operand
.isInvalid())
4874 if (!getDerived().AlwaysRebuild() &&
4875 Operand
.get() == S
->getThrowExpr())
4876 return getSema().Owned(S
);
4878 return getDerived().RebuildObjCAtThrowStmt(S
->getThrowLoc(), Operand
.get());
4881 template<typename Derived
>
4883 TreeTransform
<Derived
>::TransformObjCAtSynchronizedStmt(
4884 ObjCAtSynchronizedStmt
*S
) {
4885 // Transform the object we are locking.
4886 ExprResult Object
= getDerived().TransformExpr(S
->getSynchExpr());
4887 if (Object
.isInvalid())
4890 // Transform the body.
4891 StmtResult Body
= getDerived().TransformStmt(S
->getSynchBody());
4892 if (Body
.isInvalid())
4895 // If nothing change, just retain the current statement.
4896 if (!getDerived().AlwaysRebuild() &&
4897 Object
.get() == S
->getSynchExpr() &&
4898 Body
.get() == S
->getSynchBody())
4899 return SemaRef
.Owned(S
);
4901 // Build a new statement.
4902 return getDerived().RebuildObjCAtSynchronizedStmt(S
->getAtSynchronizedLoc(),
4903 Object
.get(), Body
.get());
4906 template<typename Derived
>
4908 TreeTransform
<Derived
>::TransformObjCForCollectionStmt(
4909 ObjCForCollectionStmt
*S
) {
4910 // Transform the element statement.
4911 StmtResult Element
= getDerived().TransformStmt(S
->getElement());
4912 if (Element
.isInvalid())
4915 // Transform the collection expression.
4916 ExprResult Collection
= getDerived().TransformExpr(S
->getCollection());
4917 if (Collection
.isInvalid())
4920 // Transform the body.
4921 StmtResult Body
= getDerived().TransformStmt(S
->getBody());
4922 if (Body
.isInvalid())
4925 // If nothing changed, just retain this statement.
4926 if (!getDerived().AlwaysRebuild() &&
4927 Element
.get() == S
->getElement() &&
4928 Collection
.get() == S
->getCollection() &&
4929 Body
.get() == S
->getBody())
4930 return SemaRef
.Owned(S
);
4932 // Build a new statement.
4933 return getDerived().RebuildObjCForCollectionStmt(S
->getForLoc(),
4934 /*FIXME:*/S
->getForLoc(),
4942 template<typename Derived
>
4944 TreeTransform
<Derived
>::TransformCXXCatchStmt(CXXCatchStmt
*S
) {
4945 // Transform the exception declaration, if any.
4947 if (S
->getExceptionDecl()) {
4948 VarDecl
*ExceptionDecl
= S
->getExceptionDecl();
4949 TypeSourceInfo
*T
= getDerived().TransformType(
4950 ExceptionDecl
->getTypeSourceInfo());
4954 Var
= getDerived().RebuildExceptionDecl(ExceptionDecl
, T
,
4955 ExceptionDecl
->getIdentifier(),
4956 ExceptionDecl
->getLocation());
4957 if (!Var
|| Var
->isInvalidDecl())
4961 // Transform the actual exception handler.
4962 StmtResult Handler
= getDerived().TransformStmt(S
->getHandlerBlock());
4963 if (Handler
.isInvalid())
4966 if (!getDerived().AlwaysRebuild() &&
4968 Handler
.get() == S
->getHandlerBlock())
4969 return SemaRef
.Owned(S
);
4971 return getDerived().RebuildCXXCatchStmt(S
->getCatchLoc(),
4976 template<typename Derived
>
4978 TreeTransform
<Derived
>::TransformCXXTryStmt(CXXTryStmt
*S
) {
4979 // Transform the try block itself.
4981 = getDerived().TransformCompoundStmt(S
->getTryBlock());
4982 if (TryBlock
.isInvalid())
4985 // Transform the handlers.
4986 bool HandlerChanged
= false;
4987 ASTOwningVector
<Stmt
*> Handlers(SemaRef
);
4988 for (unsigned I
= 0, N
= S
->getNumHandlers(); I
!= N
; ++I
) {
4990 = getDerived().TransformCXXCatchStmt(S
->getHandler(I
));
4991 if (Handler
.isInvalid())
4994 HandlerChanged
= HandlerChanged
|| Handler
.get() != S
->getHandler(I
);
4995 Handlers
.push_back(Handler
.takeAs
<Stmt
>());
4998 if (!getDerived().AlwaysRebuild() &&
4999 TryBlock
.get() == S
->getTryBlock() &&
5001 return SemaRef
.Owned(S
);
5003 return getDerived().RebuildCXXTryStmt(S
->getTryLoc(), TryBlock
.get(),
5004 move_arg(Handlers
));
5007 //===----------------------------------------------------------------------===//
5008 // Expression transformation
5009 //===----------------------------------------------------------------------===//
5010 template<typename Derived
>
5012 TreeTransform
<Derived
>::TransformPredefinedExpr(PredefinedExpr
*E
) {
5013 return SemaRef
.Owned(E
);
5016 template<typename Derived
>
5018 TreeTransform
<Derived
>::TransformDeclRefExpr(DeclRefExpr
*E
) {
5019 NestedNameSpecifier
*Qualifier
= 0;
5020 if (E
->getQualifier()) {
5021 Qualifier
= getDerived().TransformNestedNameSpecifier(E
->getQualifier(),
5022 E
->getQualifierRange());
5028 = cast_or_null
<ValueDecl
>(getDerived().TransformDecl(E
->getLocation(),
5033 DeclarationNameInfo NameInfo
= E
->getNameInfo();
5034 if (NameInfo
.getName()) {
5035 NameInfo
= getDerived().TransformDeclarationNameInfo(NameInfo
);
5036 if (!NameInfo
.getName())
5040 if (!getDerived().AlwaysRebuild() &&
5041 Qualifier
== E
->getQualifier() &&
5042 ND
== E
->getDecl() &&
5043 NameInfo
.getName() == E
->getDecl()->getDeclName() &&
5044 !E
->hasExplicitTemplateArgs()) {
5046 // Mark it referenced in the new context regardless.
5047 // FIXME: this is a bit instantiation-specific.
5048 SemaRef
.MarkDeclarationReferenced(E
->getLocation(), ND
);
5050 return SemaRef
.Owned(E
);
5053 TemplateArgumentListInfo TransArgs
, *TemplateArgs
= 0;
5054 if (E
->hasExplicitTemplateArgs()) {
5055 TemplateArgs
= &TransArgs
;
5056 TransArgs
.setLAngleLoc(E
->getLAngleLoc());
5057 TransArgs
.setRAngleLoc(E
->getRAngleLoc());
5058 if (getDerived().TransformTemplateArguments(E
->getTemplateArgs(),
5059 E
->getNumTemplateArgs(),
5064 return getDerived().RebuildDeclRefExpr(Qualifier
, E
->getQualifierRange(),
5065 ND
, NameInfo
, TemplateArgs
);
5068 template<typename Derived
>
5070 TreeTransform
<Derived
>::TransformIntegerLiteral(IntegerLiteral
*E
) {
5071 return SemaRef
.Owned(E
);
5074 template<typename Derived
>
5076 TreeTransform
<Derived
>::TransformFloatingLiteral(FloatingLiteral
*E
) {
5077 return SemaRef
.Owned(E
);
5080 template<typename Derived
>
5082 TreeTransform
<Derived
>::TransformImaginaryLiteral(ImaginaryLiteral
*E
) {
5083 return SemaRef
.Owned(E
);
5086 template<typename Derived
>
5088 TreeTransform
<Derived
>::TransformStringLiteral(StringLiteral
*E
) {
5089 return SemaRef
.Owned(E
);
5092 template<typename Derived
>
5094 TreeTransform
<Derived
>::TransformCharacterLiteral(CharacterLiteral
*E
) {
5095 return SemaRef
.Owned(E
);
5098 template<typename Derived
>
5100 TreeTransform
<Derived
>::TransformParenExpr(ParenExpr
*E
) {
5101 ExprResult SubExpr
= getDerived().TransformExpr(E
->getSubExpr());
5102 if (SubExpr
.isInvalid())
5105 if (!getDerived().AlwaysRebuild() && SubExpr
.get() == E
->getSubExpr())
5106 return SemaRef
.Owned(E
);
5108 return getDerived().RebuildParenExpr(SubExpr
.get(), E
->getLParen(),
5112 template<typename Derived
>
5114 TreeTransform
<Derived
>::TransformUnaryOperator(UnaryOperator
*E
) {
5115 ExprResult SubExpr
= getDerived().TransformExpr(E
->getSubExpr());
5116 if (SubExpr
.isInvalid())
5119 if (!getDerived().AlwaysRebuild() && SubExpr
.get() == E
->getSubExpr())
5120 return SemaRef
.Owned(E
);
5122 return getDerived().RebuildUnaryOperator(E
->getOperatorLoc(),
5127 template<typename Derived
>
5129 TreeTransform
<Derived
>::TransformOffsetOfExpr(OffsetOfExpr
*E
) {
5130 // Transform the type.
5131 TypeSourceInfo
*Type
= getDerived().TransformType(E
->getTypeSourceInfo());
5135 // Transform all of the components into components similar to what the
5137 // FIXME: It would be slightly more efficient in the non-dependent case to
5138 // just map FieldDecls, rather than requiring the rebuilder to look for
5139 // the fields again. However, __builtin_offsetof is rare enough in
5140 // template code that we don't care.
5141 bool ExprChanged
= false;
5142 typedef Sema::OffsetOfComponent Component
;
5143 typedef OffsetOfExpr::OffsetOfNode Node
;
5144 llvm::SmallVector
<Component
, 4> Components
;
5145 for (unsigned I
= 0, N
= E
->getNumComponents(); I
!= N
; ++I
) {
5146 const Node
&ON
= E
->getComponent(I
);
5148 Comp
.isBrackets
= true;
5149 Comp
.LocStart
= ON
.getRange().getBegin();
5150 Comp
.LocEnd
= ON
.getRange().getEnd();
5151 switch (ON
.getKind()) {
5153 Expr
*FromIndex
= E
->getIndexExpr(ON
.getArrayExprIndex());
5154 ExprResult Index
= getDerived().TransformExpr(FromIndex
);
5155 if (Index
.isInvalid())
5158 ExprChanged
= ExprChanged
|| Index
.get() != FromIndex
;
5159 Comp
.isBrackets
= true;
5160 Comp
.U
.E
= Index
.get();
5165 case Node::Identifier
:
5166 Comp
.isBrackets
= false;
5167 Comp
.U
.IdentInfo
= ON
.getFieldName();
5168 if (!Comp
.U
.IdentInfo
)
5174 // Will be recomputed during the rebuild.
5178 Components
.push_back(Comp
);
5181 // If nothing changed, retain the existing expression.
5182 if (!getDerived().AlwaysRebuild() &&
5183 Type
== E
->getTypeSourceInfo() &&
5185 return SemaRef
.Owned(E
);
5187 // Build a new offsetof expression.
5188 return getDerived().RebuildOffsetOfExpr(E
->getOperatorLoc(), Type
,
5189 Components
.data(), Components
.size(),
5193 template<typename Derived
>
5195 TreeTransform
<Derived
>::TransformOpaqueValueExpr(OpaqueValueExpr
*E
) {
5196 assert(getDerived().AlreadyTransformed(E
->getType()) &&
5197 "opaque value expression requires transformation");
5198 return SemaRef
.Owned(E
);
5201 template<typename Derived
>
5203 TreeTransform
<Derived
>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr
*E
) {
5204 if (E
->isArgumentType()) {
5205 TypeSourceInfo
*OldT
= E
->getArgumentTypeInfo();
5207 TypeSourceInfo
*NewT
= getDerived().TransformType(OldT
);
5211 if (!getDerived().AlwaysRebuild() && OldT
== NewT
)
5212 return SemaRef
.Owned(E
);
5214 return getDerived().RebuildSizeOfAlignOf(NewT
, E
->getOperatorLoc(),
5216 E
->getSourceRange());
5221 // C++0x [expr.sizeof]p1:
5222 // The operand is either an expression, which is an unevaluated operand
5224 EnterExpressionEvaluationContext
Unevaluated(SemaRef
, Sema::Unevaluated
);
5226 SubExpr
= getDerived().TransformExpr(E
->getArgumentExpr());
5227 if (SubExpr
.isInvalid())
5230 if (!getDerived().AlwaysRebuild() && SubExpr
.get() == E
->getArgumentExpr())
5231 return SemaRef
.Owned(E
);
5234 return getDerived().RebuildSizeOfAlignOf(SubExpr
.get(), E
->getOperatorLoc(),
5236 E
->getSourceRange());
5239 template<typename Derived
>
5241 TreeTransform
<Derived
>::TransformArraySubscriptExpr(ArraySubscriptExpr
*E
) {
5242 ExprResult LHS
= getDerived().TransformExpr(E
->getLHS());
5243 if (LHS
.isInvalid())
5246 ExprResult RHS
= getDerived().TransformExpr(E
->getRHS());
5247 if (RHS
.isInvalid())
5251 if (!getDerived().AlwaysRebuild() &&
5252 LHS
.get() == E
->getLHS() &&
5253 RHS
.get() == E
->getRHS())
5254 return SemaRef
.Owned(E
);
5256 return getDerived().RebuildArraySubscriptExpr(LHS
.get(),
5257 /*FIXME:*/E
->getLHS()->getLocStart(),
5259 E
->getRBracketLoc());
5262 template<typename Derived
>
5264 TreeTransform
<Derived
>::TransformCallExpr(CallExpr
*E
) {
5265 // Transform the callee.
5266 ExprResult Callee
= getDerived().TransformExpr(E
->getCallee());
5267 if (Callee
.isInvalid())
5270 // Transform arguments.
5271 bool ArgChanged
= false;
5272 ASTOwningVector
<Expr
*> Args(SemaRef
);
5273 if (getDerived().TransformExprs(E
->getArgs(), E
->getNumArgs(), true, Args
,
5277 if (!getDerived().AlwaysRebuild() &&
5278 Callee
.get() == E
->getCallee() &&
5280 return SemaRef
.Owned(E
);
5282 // FIXME: Wrong source location information for the '('.
5283 SourceLocation FakeLParenLoc
5284 = ((Expr
*)Callee
.get())->getSourceRange().getBegin();
5285 return getDerived().RebuildCallExpr(Callee
.get(), FakeLParenLoc
,
5290 template<typename Derived
>
5292 TreeTransform
<Derived
>::TransformMemberExpr(MemberExpr
*E
) {
5293 ExprResult Base
= getDerived().TransformExpr(E
->getBase());
5294 if (Base
.isInvalid())
5297 NestedNameSpecifier
*Qualifier
= 0;
5298 if (E
->hasQualifier()) {
5300 = getDerived().TransformNestedNameSpecifier(E
->getQualifier(),
5301 E
->getQualifierRange());
5307 = cast_or_null
<ValueDecl
>(getDerived().TransformDecl(E
->getMemberLoc(),
5308 E
->getMemberDecl()));
5312 NamedDecl
*FoundDecl
= E
->getFoundDecl();
5313 if (FoundDecl
== E
->getMemberDecl()) {
5316 FoundDecl
= cast_or_null
<NamedDecl
>(
5317 getDerived().TransformDecl(E
->getMemberLoc(), FoundDecl
));
5322 if (!getDerived().AlwaysRebuild() &&
5323 Base
.get() == E
->getBase() &&
5324 Qualifier
== E
->getQualifier() &&
5325 Member
== E
->getMemberDecl() &&
5326 FoundDecl
== E
->getFoundDecl() &&
5327 !E
->hasExplicitTemplateArgs()) {
5329 // Mark it referenced in the new context regardless.
5330 // FIXME: this is a bit instantiation-specific.
5331 SemaRef
.MarkDeclarationReferenced(E
->getMemberLoc(), Member
);
5332 return SemaRef
.Owned(E
);
5335 TemplateArgumentListInfo TransArgs
;
5336 if (E
->hasExplicitTemplateArgs()) {
5337 TransArgs
.setLAngleLoc(E
->getLAngleLoc());
5338 TransArgs
.setRAngleLoc(E
->getRAngleLoc());
5339 if (getDerived().TransformTemplateArguments(E
->getTemplateArgs(),
5340 E
->getNumTemplateArgs(),
5345 // FIXME: Bogus source location for the operator
5346 SourceLocation FakeOperatorLoc
5347 = SemaRef
.PP
.getLocForEndOfToken(E
->getBase()->getSourceRange().getEnd());
5349 // FIXME: to do this check properly, we will need to preserve the
5350 // first-qualifier-in-scope here, just in case we had a dependent
5351 // base (and therefore couldn't do the check) and a
5352 // nested-name-qualifier (and therefore could do the lookup).
5353 NamedDecl
*FirstQualifierInScope
= 0;
5355 return getDerived().RebuildMemberExpr(Base
.get(), FakeOperatorLoc
,
5358 E
->getQualifierRange(),
5359 E
->getMemberNameInfo(),
5362 (E
->hasExplicitTemplateArgs()
5364 FirstQualifierInScope
);
5367 template<typename Derived
>
5369 TreeTransform
<Derived
>::TransformBinaryOperator(BinaryOperator
*E
) {
5370 ExprResult LHS
= getDerived().TransformExpr(E
->getLHS());
5371 if (LHS
.isInvalid())
5374 ExprResult RHS
= getDerived().TransformExpr(E
->getRHS());
5375 if (RHS
.isInvalid())
5378 if (!getDerived().AlwaysRebuild() &&
5379 LHS
.get() == E
->getLHS() &&
5380 RHS
.get() == E
->getRHS())
5381 return SemaRef
.Owned(E
);
5383 return getDerived().RebuildBinaryOperator(E
->getOperatorLoc(), E
->getOpcode(),
5384 LHS
.get(), RHS
.get());
5387 template<typename Derived
>
5389 TreeTransform
<Derived
>::TransformCompoundAssignOperator(
5390 CompoundAssignOperator
*E
) {
5391 return getDerived().TransformBinaryOperator(E
);
5394 template<typename Derived
>
5396 TreeTransform
<Derived
>::TransformConditionalOperator(ConditionalOperator
*E
) {
5397 ExprResult Cond
= getDerived().TransformExpr(E
->getCond());
5398 if (Cond
.isInvalid())
5401 ExprResult LHS
= getDerived().TransformExpr(E
->getLHS());
5402 if (LHS
.isInvalid())
5405 ExprResult RHS
= getDerived().TransformExpr(E
->getRHS());
5406 if (RHS
.isInvalid())
5409 if (!getDerived().AlwaysRebuild() &&
5410 Cond
.get() == E
->getCond() &&
5411 LHS
.get() == E
->getLHS() &&
5412 RHS
.get() == E
->getRHS())
5413 return SemaRef
.Owned(E
);
5415 return getDerived().RebuildConditionalOperator(Cond
.get(),
5416 E
->getQuestionLoc(),
5422 template<typename Derived
>
5424 TreeTransform
<Derived
>::TransformImplicitCastExpr(ImplicitCastExpr
*E
) {
5425 // Implicit casts are eliminated during transformation, since they
5426 // will be recomputed by semantic analysis after transformation.
5427 return getDerived().TransformExpr(E
->getSubExprAsWritten());
5430 template<typename Derived
>
5432 TreeTransform
<Derived
>::TransformCStyleCastExpr(CStyleCastExpr
*E
) {
5433 TypeSourceInfo
*Type
= getDerived().TransformType(E
->getTypeInfoAsWritten());
5438 = getDerived().TransformExpr(E
->getSubExprAsWritten());
5439 if (SubExpr
.isInvalid())
5442 if (!getDerived().AlwaysRebuild() &&
5443 Type
== E
->getTypeInfoAsWritten() &&
5444 SubExpr
.get() == E
->getSubExpr())
5445 return SemaRef
.Owned(E
);
5447 return getDerived().RebuildCStyleCastExpr(E
->getLParenLoc(),
5453 template<typename Derived
>
5455 TreeTransform
<Derived
>::TransformCompoundLiteralExpr(CompoundLiteralExpr
*E
) {
5456 TypeSourceInfo
*OldT
= E
->getTypeSourceInfo();
5457 TypeSourceInfo
*NewT
= getDerived().TransformType(OldT
);
5461 ExprResult Init
= getDerived().TransformExpr(E
->getInitializer());
5462 if (Init
.isInvalid())
5465 if (!getDerived().AlwaysRebuild() &&
5467 Init
.get() == E
->getInitializer())
5468 return SemaRef
.Owned(E
);
5470 // Note: the expression type doesn't necessarily match the
5471 // type-as-written, but that's okay, because it should always be
5472 // derivable from the initializer.
5474 return getDerived().RebuildCompoundLiteralExpr(E
->getLParenLoc(), NewT
,
5475 /*FIXME:*/E
->getInitializer()->getLocEnd(),
5479 template<typename Derived
>
5481 TreeTransform
<Derived
>::TransformExtVectorElementExpr(ExtVectorElementExpr
*E
) {
5482 ExprResult Base
= getDerived().TransformExpr(E
->getBase());
5483 if (Base
.isInvalid())
5486 if (!getDerived().AlwaysRebuild() &&
5487 Base
.get() == E
->getBase())
5488 return SemaRef
.Owned(E
);
5490 // FIXME: Bad source location
5491 SourceLocation FakeOperatorLoc
5492 = SemaRef
.PP
.getLocForEndOfToken(E
->getBase()->getLocEnd());
5493 return getDerived().RebuildExtVectorElementExpr(Base
.get(), FakeOperatorLoc
,
5494 E
->getAccessorLoc(),
5498 template<typename Derived
>
5500 TreeTransform
<Derived
>::TransformInitListExpr(InitListExpr
*E
) {
5501 bool InitChanged
= false;
5503 ASTOwningVector
<Expr
*, 4> Inits(SemaRef
);
5504 if (getDerived().TransformExprs(E
->getInits(), E
->getNumInits(), false,
5505 Inits
, &InitChanged
))
5508 if (!getDerived().AlwaysRebuild() && !InitChanged
)
5509 return SemaRef
.Owned(E
);
5511 return getDerived().RebuildInitList(E
->getLBraceLoc(), move_arg(Inits
),
5512 E
->getRBraceLoc(), E
->getType());
5515 template<typename Derived
>
5517 TreeTransform
<Derived
>::TransformDesignatedInitExpr(DesignatedInitExpr
*E
) {
5520 // transform the initializer value
5521 ExprResult Init
= getDerived().TransformExpr(E
->getInit());
5522 if (Init
.isInvalid())
5525 // transform the designators.
5526 ASTOwningVector
<Expr
*, 4> ArrayExprs(SemaRef
);
5527 bool ExprChanged
= false;
5528 for (DesignatedInitExpr::designators_iterator D
= E
->designators_begin(),
5529 DEnd
= E
->designators_end();
5531 if (D
->isFieldDesignator()) {
5532 Desig
.AddDesignator(Designator::getField(D
->getFieldName(),
5538 if (D
->isArrayDesignator()) {
5539 ExprResult Index
= getDerived().TransformExpr(E
->getArrayIndex(*D
));
5540 if (Index
.isInvalid())
5543 Desig
.AddDesignator(Designator::getArray(Index
.get(),
5544 D
->getLBracketLoc()));
5546 ExprChanged
= ExprChanged
|| Init
.get() != E
->getArrayIndex(*D
);
5547 ArrayExprs
.push_back(Index
.release());
5551 assert(D
->isArrayRangeDesignator() && "New kind of designator?");
5553 = getDerived().TransformExpr(E
->getArrayRangeStart(*D
));
5554 if (Start
.isInvalid())
5557 ExprResult End
= getDerived().TransformExpr(E
->getArrayRangeEnd(*D
));
5558 if (End
.isInvalid())
5561 Desig
.AddDesignator(Designator::getArrayRange(Start
.get(),
5563 D
->getLBracketLoc(),
5564 D
->getEllipsisLoc()));
5566 ExprChanged
= ExprChanged
|| Start
.get() != E
->getArrayRangeStart(*D
) ||
5567 End
.get() != E
->getArrayRangeEnd(*D
);
5569 ArrayExprs
.push_back(Start
.release());
5570 ArrayExprs
.push_back(End
.release());
5573 if (!getDerived().AlwaysRebuild() &&
5574 Init
.get() == E
->getInit() &&
5576 return SemaRef
.Owned(E
);
5578 return getDerived().RebuildDesignatedInitExpr(Desig
, move_arg(ArrayExprs
),
5579 E
->getEqualOrColonLoc(),
5580 E
->usesGNUSyntax(), Init
.get());
5583 template<typename Derived
>
5585 TreeTransform
<Derived
>::TransformImplicitValueInitExpr(
5586 ImplicitValueInitExpr
*E
) {
5587 TemporaryBase
Rebase(*this, E
->getLocStart(), DeclarationName());
5589 // FIXME: Will we ever have proper type location here? Will we actually
5590 // need to transform the type?
5591 QualType T
= getDerived().TransformType(E
->getType());
5595 if (!getDerived().AlwaysRebuild() &&
5597 return SemaRef
.Owned(E
);
5599 return getDerived().RebuildImplicitValueInitExpr(T
);
5602 template<typename Derived
>
5604 TreeTransform
<Derived
>::TransformVAArgExpr(VAArgExpr
*E
) {
5605 TypeSourceInfo
*TInfo
= getDerived().TransformType(E
->getWrittenTypeInfo());
5609 ExprResult SubExpr
= getDerived().TransformExpr(E
->getSubExpr());
5610 if (SubExpr
.isInvalid())
5613 if (!getDerived().AlwaysRebuild() &&
5614 TInfo
== E
->getWrittenTypeInfo() &&
5615 SubExpr
.get() == E
->getSubExpr())
5616 return SemaRef
.Owned(E
);
5618 return getDerived().RebuildVAArgExpr(E
->getBuiltinLoc(), SubExpr
.get(),
5619 TInfo
, E
->getRParenLoc());
5622 template<typename Derived
>
5624 TreeTransform
<Derived
>::TransformParenListExpr(ParenListExpr
*E
) {
5625 bool ArgumentChanged
= false;
5626 ASTOwningVector
<Expr
*, 4> Inits(SemaRef
);
5627 if (TransformExprs(E
->getExprs(), E
->getNumExprs(), true, Inits
,
5631 return getDerived().RebuildParenListExpr(E
->getLParenLoc(),
5636 /// \brief Transform an address-of-label expression.
5638 /// By default, the transformation of an address-of-label expression always
5639 /// rebuilds the expression, so that the label identifier can be resolved to
5640 /// the corresponding label statement by semantic analysis.
5641 template<typename Derived
>
5643 TreeTransform
<Derived
>::TransformAddrLabelExpr(AddrLabelExpr
*E
) {
5644 return getDerived().RebuildAddrLabelExpr(E
->getAmpAmpLoc(), E
->getLabelLoc(),
5648 template<typename Derived
>
5650 TreeTransform
<Derived
>::TransformStmtExpr(StmtExpr
*E
) {
5652 = getDerived().TransformCompoundStmt(E
->getSubStmt(), true);
5653 if (SubStmt
.isInvalid())
5656 if (!getDerived().AlwaysRebuild() &&
5657 SubStmt
.get() == E
->getSubStmt())
5658 return SemaRef
.Owned(E
);
5660 return getDerived().RebuildStmtExpr(E
->getLParenLoc(),
5665 template<typename Derived
>
5667 TreeTransform
<Derived
>::TransformChooseExpr(ChooseExpr
*E
) {
5668 ExprResult Cond
= getDerived().TransformExpr(E
->getCond());
5669 if (Cond
.isInvalid())
5672 ExprResult LHS
= getDerived().TransformExpr(E
->getLHS());
5673 if (LHS
.isInvalid())
5676 ExprResult RHS
= getDerived().TransformExpr(E
->getRHS());
5677 if (RHS
.isInvalid())
5680 if (!getDerived().AlwaysRebuild() &&
5681 Cond
.get() == E
->getCond() &&
5682 LHS
.get() == E
->getLHS() &&
5683 RHS
.get() == E
->getRHS())
5684 return SemaRef
.Owned(E
);
5686 return getDerived().RebuildChooseExpr(E
->getBuiltinLoc(),
5687 Cond
.get(), LHS
.get(), RHS
.get(),
5691 template<typename Derived
>
5693 TreeTransform
<Derived
>::TransformGNUNullExpr(GNUNullExpr
*E
) {
5694 return SemaRef
.Owned(E
);
5697 template<typename Derived
>
5699 TreeTransform
<Derived
>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr
*E
) {
5700 switch (E
->getOperator()) {
5704 case OO_Array_Delete
:
5705 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr");
5709 // This is a call to an object's operator().
5710 assert(E
->getNumArgs() >= 1 && "Object call is missing arguments");
5712 // Transform the object itself.
5713 ExprResult Object
= getDerived().TransformExpr(E
->getArg(0));
5714 if (Object
.isInvalid())
5717 // FIXME: Poor location information
5718 SourceLocation FakeLParenLoc
5719 = SemaRef
.PP
.getLocForEndOfToken(
5720 static_cast<Expr
*>(Object
.get())->getLocEnd());
5722 // Transform the call arguments.
5723 ASTOwningVector
<Expr
*> Args(SemaRef
);
5724 if (getDerived().TransformExprs(E
->getArgs() + 1, E
->getNumArgs() - 1, true,
5728 return getDerived().RebuildCallExpr(Object
.get(), FakeLParenLoc
,
5733 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
5735 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
5736 #include "clang/Basic/OperatorKinds.def"
5741 case OO_Conditional
:
5742 llvm_unreachable("conditional operator is not actually overloadable");
5746 case NUM_OVERLOADED_OPERATORS
:
5747 llvm_unreachable("not an overloaded operator?");
5751 ExprResult Callee
= getDerived().TransformExpr(E
->getCallee());
5752 if (Callee
.isInvalid())
5755 ExprResult First
= getDerived().TransformExpr(E
->getArg(0));
5756 if (First
.isInvalid())
5760 if (E
->getNumArgs() == 2) {
5761 Second
= getDerived().TransformExpr(E
->getArg(1));
5762 if (Second
.isInvalid())
5766 if (!getDerived().AlwaysRebuild() &&
5767 Callee
.get() == E
->getCallee() &&
5768 First
.get() == E
->getArg(0) &&
5769 (E
->getNumArgs() != 2 || Second
.get() == E
->getArg(1)))
5770 return SemaRef
.Owned(E
);
5772 return getDerived().RebuildCXXOperatorCallExpr(E
->getOperator(),
5773 E
->getOperatorLoc(),
5779 template<typename Derived
>
5781 TreeTransform
<Derived
>::TransformCXXMemberCallExpr(CXXMemberCallExpr
*E
) {
5782 return getDerived().TransformCallExpr(E
);
5785 template<typename Derived
>
5787 TreeTransform
<Derived
>::TransformCXXNamedCastExpr(CXXNamedCastExpr
*E
) {
5788 TypeSourceInfo
*Type
= getDerived().TransformType(E
->getTypeInfoAsWritten());
5793 = getDerived().TransformExpr(E
->getSubExprAsWritten());
5794 if (SubExpr
.isInvalid())
5797 if (!getDerived().AlwaysRebuild() &&
5798 Type
== E
->getTypeInfoAsWritten() &&
5799 SubExpr
.get() == E
->getSubExpr())
5800 return SemaRef
.Owned(E
);
5802 // FIXME: Poor source location information here.
5803 SourceLocation FakeLAngleLoc
5804 = SemaRef
.PP
.getLocForEndOfToken(E
->getOperatorLoc());
5805 SourceLocation FakeRAngleLoc
= E
->getSubExpr()->getSourceRange().getBegin();
5806 SourceLocation FakeRParenLoc
5807 = SemaRef
.PP
.getLocForEndOfToken(
5808 E
->getSubExpr()->getSourceRange().getEnd());
5809 return getDerived().RebuildCXXNamedCastExpr(E
->getOperatorLoc(),
5819 template<typename Derived
>
5821 TreeTransform
<Derived
>::TransformCXXStaticCastExpr(CXXStaticCastExpr
*E
) {
5822 return getDerived().TransformCXXNamedCastExpr(E
);
5825 template<typename Derived
>
5827 TreeTransform
<Derived
>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr
*E
) {
5828 return getDerived().TransformCXXNamedCastExpr(E
);
5831 template<typename Derived
>
5833 TreeTransform
<Derived
>::TransformCXXReinterpretCastExpr(
5834 CXXReinterpretCastExpr
*E
) {
5835 return getDerived().TransformCXXNamedCastExpr(E
);
5838 template<typename Derived
>
5840 TreeTransform
<Derived
>::TransformCXXConstCastExpr(CXXConstCastExpr
*E
) {
5841 return getDerived().TransformCXXNamedCastExpr(E
);
5844 template<typename Derived
>
5846 TreeTransform
<Derived
>::TransformCXXFunctionalCastExpr(
5847 CXXFunctionalCastExpr
*E
) {
5848 TypeSourceInfo
*Type
= getDerived().TransformType(E
->getTypeInfoAsWritten());
5853 = getDerived().TransformExpr(E
->getSubExprAsWritten());
5854 if (SubExpr
.isInvalid())
5857 if (!getDerived().AlwaysRebuild() &&
5858 Type
== E
->getTypeInfoAsWritten() &&
5859 SubExpr
.get() == E
->getSubExpr())
5860 return SemaRef
.Owned(E
);
5862 return getDerived().RebuildCXXFunctionalCastExpr(Type
,
5863 /*FIXME:*/E
->getSubExpr()->getLocStart(),
5868 template<typename Derived
>
5870 TreeTransform
<Derived
>::TransformCXXTypeidExpr(CXXTypeidExpr
*E
) {
5871 if (E
->isTypeOperand()) {
5872 TypeSourceInfo
*TInfo
5873 = getDerived().TransformType(E
->getTypeOperandSourceInfo());
5877 if (!getDerived().AlwaysRebuild() &&
5878 TInfo
== E
->getTypeOperandSourceInfo())
5879 return SemaRef
.Owned(E
);
5881 return getDerived().RebuildCXXTypeidExpr(E
->getType(),
5887 // We don't know whether the expression is potentially evaluated until
5888 // after we perform semantic analysis, so the expression is potentially
5889 // potentially evaluated.
5890 EnterExpressionEvaluationContext
Unevaluated(SemaRef
,
5891 Sema::PotentiallyPotentiallyEvaluated
);
5893 ExprResult SubExpr
= getDerived().TransformExpr(E
->getExprOperand());
5894 if (SubExpr
.isInvalid())
5897 if (!getDerived().AlwaysRebuild() &&
5898 SubExpr
.get() == E
->getExprOperand())
5899 return SemaRef
.Owned(E
);
5901 return getDerived().RebuildCXXTypeidExpr(E
->getType(),
5907 template<typename Derived
>
5909 TreeTransform
<Derived
>::TransformCXXUuidofExpr(CXXUuidofExpr
*E
) {
5910 if (E
->isTypeOperand()) {
5911 TypeSourceInfo
*TInfo
5912 = getDerived().TransformType(E
->getTypeOperandSourceInfo());
5916 if (!getDerived().AlwaysRebuild() &&
5917 TInfo
== E
->getTypeOperandSourceInfo())
5918 return SemaRef
.Owned(E
);
5920 return getDerived().RebuildCXXTypeidExpr(E
->getType(),
5926 // We don't know whether the expression is potentially evaluated until
5927 // after we perform semantic analysis, so the expression is potentially
5928 // potentially evaluated.
5929 EnterExpressionEvaluationContext
Unevaluated(SemaRef
, Sema::Unevaluated
);
5931 ExprResult SubExpr
= getDerived().TransformExpr(E
->getExprOperand());
5932 if (SubExpr
.isInvalid())
5935 if (!getDerived().AlwaysRebuild() &&
5936 SubExpr
.get() == E
->getExprOperand())
5937 return SemaRef
.Owned(E
);
5939 return getDerived().RebuildCXXUuidofExpr(E
->getType(),
5945 template<typename Derived
>
5947 TreeTransform
<Derived
>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr
*E
) {
5948 return SemaRef
.Owned(E
);
5951 template<typename Derived
>
5953 TreeTransform
<Derived
>::TransformCXXNullPtrLiteralExpr(
5954 CXXNullPtrLiteralExpr
*E
) {
5955 return SemaRef
.Owned(E
);
5958 template<typename Derived
>
5960 TreeTransform
<Derived
>::TransformCXXThisExpr(CXXThisExpr
*E
) {
5961 DeclContext
*DC
= getSema().getFunctionLevelDeclContext();
5962 CXXMethodDecl
*MD
= dyn_cast
<CXXMethodDecl
>(DC
);
5963 QualType T
= MD
->getThisType(getSema().Context
);
5965 if (!getDerived().AlwaysRebuild() && T
== E
->getType())
5966 return SemaRef
.Owned(E
);
5968 return getDerived().RebuildCXXThisExpr(E
->getLocStart(), T
, E
->isImplicit());
5971 template<typename Derived
>
5973 TreeTransform
<Derived
>::TransformCXXThrowExpr(CXXThrowExpr
*E
) {
5974 ExprResult SubExpr
= getDerived().TransformExpr(E
->getSubExpr());
5975 if (SubExpr
.isInvalid())
5978 if (!getDerived().AlwaysRebuild() &&
5979 SubExpr
.get() == E
->getSubExpr())
5980 return SemaRef
.Owned(E
);
5982 return getDerived().RebuildCXXThrowExpr(E
->getThrowLoc(), SubExpr
.get());
5985 template<typename Derived
>
5987 TreeTransform
<Derived
>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr
*E
) {
5989 = cast_or_null
<ParmVarDecl
>(getDerived().TransformDecl(E
->getLocStart(),
5994 if (!getDerived().AlwaysRebuild() &&
5995 Param
== E
->getParam())
5996 return SemaRef
.Owned(E
);
5998 return getDerived().RebuildCXXDefaultArgExpr(E
->getUsedLocation(), Param
);
6001 template<typename Derived
>
6003 TreeTransform
<Derived
>::TransformCXXScalarValueInitExpr(
6004 CXXScalarValueInitExpr
*E
) {
6005 TypeSourceInfo
*T
= getDerived().TransformType(E
->getTypeSourceInfo());
6009 if (!getDerived().AlwaysRebuild() &&
6010 T
== E
->getTypeSourceInfo())
6011 return SemaRef
.Owned(E
);
6013 return getDerived().RebuildCXXScalarValueInitExpr(T
,
6014 /*FIXME:*/T
->getTypeLoc().getEndLoc(),
6018 template<typename Derived
>
6020 TreeTransform
<Derived
>::TransformCXXNewExpr(CXXNewExpr
*E
) {
6021 // Transform the type that we're allocating
6022 TypeSourceInfo
*AllocTypeInfo
6023 = getDerived().TransformType(E
->getAllocatedTypeSourceInfo());
6027 // Transform the size of the array we're allocating (if any).
6028 ExprResult ArraySize
= getDerived().TransformExpr(E
->getArraySize());
6029 if (ArraySize
.isInvalid())
6032 // Transform the placement arguments (if any).
6033 bool ArgumentChanged
= false;
6034 ASTOwningVector
<Expr
*> PlacementArgs(SemaRef
);
6035 if (getDerived().TransformExprs(E
->getPlacementArgs(),
6036 E
->getNumPlacementArgs(), true,
6037 PlacementArgs
, &ArgumentChanged
))
6040 // transform the constructor arguments (if any).
6041 ASTOwningVector
<Expr
*> ConstructorArgs(SemaRef
);
6042 if (TransformExprs(E
->getConstructorArgs(), E
->getNumConstructorArgs(), true,
6043 ConstructorArgs
, &ArgumentChanged
))
6046 // Transform constructor, new operator, and delete operator.
6047 CXXConstructorDecl
*Constructor
= 0;
6048 if (E
->getConstructor()) {
6049 Constructor
= cast_or_null
<CXXConstructorDecl
>(
6050 getDerived().TransformDecl(E
->getLocStart(),
6051 E
->getConstructor()));
6056 FunctionDecl
*OperatorNew
= 0;
6057 if (E
->getOperatorNew()) {
6058 OperatorNew
= cast_or_null
<FunctionDecl
>(
6059 getDerived().TransformDecl(E
->getLocStart(),
6060 E
->getOperatorNew()));
6065 FunctionDecl
*OperatorDelete
= 0;
6066 if (E
->getOperatorDelete()) {
6067 OperatorDelete
= cast_or_null
<FunctionDecl
>(
6068 getDerived().TransformDecl(E
->getLocStart(),
6069 E
->getOperatorDelete()));
6070 if (!OperatorDelete
)
6074 if (!getDerived().AlwaysRebuild() &&
6075 AllocTypeInfo
== E
->getAllocatedTypeSourceInfo() &&
6076 ArraySize
.get() == E
->getArraySize() &&
6077 Constructor
== E
->getConstructor() &&
6078 OperatorNew
== E
->getOperatorNew() &&
6079 OperatorDelete
== E
->getOperatorDelete() &&
6081 // Mark any declarations we need as referenced.
6082 // FIXME: instantiation-specific.
6084 SemaRef
.MarkDeclarationReferenced(E
->getLocStart(), Constructor
);
6086 SemaRef
.MarkDeclarationReferenced(E
->getLocStart(), OperatorNew
);
6088 SemaRef
.MarkDeclarationReferenced(E
->getLocStart(), OperatorDelete
);
6089 return SemaRef
.Owned(E
);
6092 QualType AllocType
= AllocTypeInfo
->getType();
6093 if (!ArraySize
.get()) {
6094 // If no array size was specified, but the new expression was
6095 // instantiated with an array type (e.g., "new T" where T is
6096 // instantiated with "int[4]"), extract the outer bound from the
6097 // array type as our array size. We do this with constant and
6098 // dependently-sized array types.
6099 const ArrayType
*ArrayT
= SemaRef
.Context
.getAsArrayType(AllocType
);
6102 } else if (const ConstantArrayType
*ConsArrayT
6103 = dyn_cast
<ConstantArrayType
>(ArrayT
)) {
6105 = SemaRef
.Owned(IntegerLiteral::Create(SemaRef
.Context
,
6106 ConsArrayT
->getSize(),
6107 SemaRef
.Context
.getSizeType(),
6108 /*FIXME:*/E
->getLocStart()));
6109 AllocType
= ConsArrayT
->getElementType();
6110 } else if (const DependentSizedArrayType
*DepArrayT
6111 = dyn_cast
<DependentSizedArrayType
>(ArrayT
)) {
6112 if (DepArrayT
->getSizeExpr()) {
6113 ArraySize
= SemaRef
.Owned(DepArrayT
->getSizeExpr());
6114 AllocType
= DepArrayT
->getElementType();
6119 return getDerived().RebuildCXXNewExpr(E
->getLocStart(),
6121 /*FIXME:*/E
->getLocStart(),
6122 move_arg(PlacementArgs
),
6123 /*FIXME:*/E
->getLocStart(),
6124 E
->getTypeIdParens(),
6128 /*FIXME:*/E
->getLocStart(),
6129 move_arg(ConstructorArgs
),
6133 template<typename Derived
>
6135 TreeTransform
<Derived
>::TransformCXXDeleteExpr(CXXDeleteExpr
*E
) {
6136 ExprResult Operand
= getDerived().TransformExpr(E
->getArgument());
6137 if (Operand
.isInvalid())
6140 // Transform the delete operator, if known.
6141 FunctionDecl
*OperatorDelete
= 0;
6142 if (E
->getOperatorDelete()) {
6143 OperatorDelete
= cast_or_null
<FunctionDecl
>(
6144 getDerived().TransformDecl(E
->getLocStart(),
6145 E
->getOperatorDelete()));
6146 if (!OperatorDelete
)
6150 if (!getDerived().AlwaysRebuild() &&
6151 Operand
.get() == E
->getArgument() &&
6152 OperatorDelete
== E
->getOperatorDelete()) {
6153 // Mark any declarations we need as referenced.
6154 // FIXME: instantiation-specific.
6156 SemaRef
.MarkDeclarationReferenced(E
->getLocStart(), OperatorDelete
);
6158 if (!E
->getArgument()->isTypeDependent()) {
6159 QualType Destroyed
= SemaRef
.Context
.getBaseElementType(
6160 E
->getDestroyedType());
6161 if (const RecordType
*DestroyedRec
= Destroyed
->getAs
<RecordType
>()) {
6162 CXXRecordDecl
*Record
= cast
<CXXRecordDecl
>(DestroyedRec
->getDecl());
6163 SemaRef
.MarkDeclarationReferenced(E
->getLocStart(),
6164 SemaRef
.LookupDestructor(Record
));
6168 return SemaRef
.Owned(E
);
6171 return getDerived().RebuildCXXDeleteExpr(E
->getLocStart(),
6172 E
->isGlobalDelete(),
6177 template<typename Derived
>
6179 TreeTransform
<Derived
>::TransformCXXPseudoDestructorExpr(
6180 CXXPseudoDestructorExpr
*E
) {
6181 ExprResult Base
= getDerived().TransformExpr(E
->getBase());
6182 if (Base
.isInvalid())
6185 ParsedType ObjectTypePtr
;
6186 bool MayBePseudoDestructor
= false;
6187 Base
= SemaRef
.ActOnStartCXXMemberReference(0, Base
.get(),
6188 E
->getOperatorLoc(),
6189 E
->isArrow()? tok::arrow
: tok::period
,
6191 MayBePseudoDestructor
);
6192 if (Base
.isInvalid())
6195 QualType ObjectType
= ObjectTypePtr
.get();
6196 NestedNameSpecifier
*Qualifier
= E
->getQualifier();
6199 = getDerived().TransformNestedNameSpecifier(E
->getQualifier(),
6200 E
->getQualifierRange(),
6206 PseudoDestructorTypeStorage Destroyed
;
6207 if (E
->getDestroyedTypeInfo()) {
6208 TypeSourceInfo
*DestroyedTypeInfo
6209 = getDerived().TransformTypeInObjectScope(E
->getDestroyedTypeInfo(),
6210 ObjectType
, 0, Qualifier
);
6211 if (!DestroyedTypeInfo
)
6213 Destroyed
= DestroyedTypeInfo
;
6214 } else if (ObjectType
->isDependentType()) {
6215 // We aren't likely to be able to resolve the identifier down to a type
6216 // now anyway, so just retain the identifier.
6217 Destroyed
= PseudoDestructorTypeStorage(E
->getDestroyedTypeIdentifier(),
6218 E
->getDestroyedTypeLoc());
6220 // Look for a destructor known with the given name.
6223 SS
.setScopeRep(Qualifier
);
6224 SS
.setRange(E
->getQualifierRange());
6227 ParsedType T
= SemaRef
.getDestructorName(E
->getTildeLoc(),
6228 *E
->getDestroyedTypeIdentifier(),
6229 E
->getDestroyedTypeLoc(),
6237 = SemaRef
.Context
.getTrivialTypeSourceInfo(SemaRef
.GetTypeFromParser(T
),
6238 E
->getDestroyedTypeLoc());
6241 TypeSourceInfo
*ScopeTypeInfo
= 0;
6242 if (E
->getScopeTypeInfo()) {
6243 ScopeTypeInfo
= getDerived().TransformType(E
->getScopeTypeInfo());
6248 return getDerived().RebuildCXXPseudoDestructorExpr(Base
.get(),
6249 E
->getOperatorLoc(),
6252 E
->getQualifierRange(),
6254 E
->getColonColonLoc(),
6259 template<typename Derived
>
6261 TreeTransform
<Derived
>::TransformUnresolvedLookupExpr(
6262 UnresolvedLookupExpr
*Old
) {
6263 TemporaryBase
Rebase(*this, Old
->getNameLoc(), DeclarationName());
6265 LookupResult
R(SemaRef
, Old
->getName(), Old
->getNameLoc(),
6266 Sema::LookupOrdinaryName
);
6268 // Transform all the decls.
6269 for (UnresolvedLookupExpr::decls_iterator I
= Old
->decls_begin(),
6270 E
= Old
->decls_end(); I
!= E
; ++I
) {
6271 NamedDecl
*InstD
= static_cast<NamedDecl
*>(
6272 getDerived().TransformDecl(Old
->getNameLoc(),
6275 // Silently ignore these if a UsingShadowDecl instantiated to nothing.
6276 // This can happen because of dependent hiding.
6277 if (isa
<UsingShadowDecl
>(*I
))
6283 // Expand using declarations.
6284 if (isa
<UsingDecl
>(InstD
)) {
6285 UsingDecl
*UD
= cast
<UsingDecl
>(InstD
);
6286 for (UsingDecl::shadow_iterator I
= UD
->shadow_begin(),
6287 E
= UD
->shadow_end(); I
!= E
; ++I
)
6295 // Resolve a kind, but don't do any further analysis. If it's
6296 // ambiguous, the callee needs to deal with it.
6299 // Rebuild the nested-name qualifier, if present.
6301 NestedNameSpecifier
*Qualifier
= 0;
6302 if (Old
->getQualifier()) {
6303 Qualifier
= getDerived().TransformNestedNameSpecifier(Old
->getQualifier(),
6304 Old
->getQualifierRange());
6308 SS
.setScopeRep(Qualifier
);
6309 SS
.setRange(Old
->getQualifierRange());
6312 if (Old
->getNamingClass()) {
6313 CXXRecordDecl
*NamingClass
6314 = cast_or_null
<CXXRecordDecl
>(getDerived().TransformDecl(
6316 Old
->getNamingClass()));
6320 R
.setNamingClass(NamingClass
);
6323 // If we have no template arguments, it's a normal declaration name.
6324 if (!Old
->hasExplicitTemplateArgs())
6325 return getDerived().RebuildDeclarationNameExpr(SS
, R
, Old
->requiresADL());
6327 // If we have template arguments, rebuild them, then rebuild the
6328 // templateid expression.
6329 TemplateArgumentListInfo
TransArgs(Old
->getLAngleLoc(), Old
->getRAngleLoc());
6330 if (getDerived().TransformTemplateArguments(Old
->getTemplateArgs(),
6331 Old
->getNumTemplateArgs(),
6335 return getDerived().RebuildTemplateIdExpr(SS
, R
, Old
->requiresADL(),
6339 template<typename Derived
>
6341 TreeTransform
<Derived
>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr
*E
) {
6342 TypeSourceInfo
*T
= getDerived().TransformType(E
->getQueriedTypeSourceInfo());
6346 if (!getDerived().AlwaysRebuild() &&
6347 T
== E
->getQueriedTypeSourceInfo())
6348 return SemaRef
.Owned(E
);
6350 return getDerived().RebuildUnaryTypeTrait(E
->getTrait(),
6356 template<typename Derived
>
6358 TreeTransform
<Derived
>::TransformBinaryTypeTraitExpr(BinaryTypeTraitExpr
*E
) {
6359 TypeSourceInfo
*LhsT
= getDerived().TransformType(E
->getLhsTypeSourceInfo());
6363 TypeSourceInfo
*RhsT
= getDerived().TransformType(E
->getRhsTypeSourceInfo());
6367 if (!getDerived().AlwaysRebuild() &&
6368 LhsT
== E
->getLhsTypeSourceInfo() && RhsT
== E
->getRhsTypeSourceInfo())
6369 return SemaRef
.Owned(E
);
6371 return getDerived().RebuildBinaryTypeTrait(E
->getTrait(),
6377 template<typename Derived
>
6379 TreeTransform
<Derived
>::TransformDependentScopeDeclRefExpr(
6380 DependentScopeDeclRefExpr
*E
) {
6381 NestedNameSpecifier
*NNS
6382 = getDerived().TransformNestedNameSpecifier(E
->getQualifier(),
6383 E
->getQualifierRange());
6387 // TODO: If this is a conversion-function-id, verify that the
6388 // destination type name (if present) resolves the same way after
6389 // instantiation as it did in the local scope.
6391 DeclarationNameInfo NameInfo
6392 = getDerived().TransformDeclarationNameInfo(E
->getNameInfo());
6393 if (!NameInfo
.getName())
6396 if (!E
->hasExplicitTemplateArgs()) {
6397 if (!getDerived().AlwaysRebuild() &&
6398 NNS
== E
->getQualifier() &&
6399 // Note: it is sufficient to compare the Name component of NameInfo:
6400 // if name has not changed, DNLoc has not changed either.
6401 NameInfo
.getName() == E
->getDeclName())
6402 return SemaRef
.Owned(E
);
6404 return getDerived().RebuildDependentScopeDeclRefExpr(NNS
,
6405 E
->getQualifierRange(),
6407 /*TemplateArgs*/ 0);
6410 TemplateArgumentListInfo
TransArgs(E
->getLAngleLoc(), E
->getRAngleLoc());
6411 if (getDerived().TransformTemplateArguments(E
->getTemplateArgs(),
6412 E
->getNumTemplateArgs(),
6416 return getDerived().RebuildDependentScopeDeclRefExpr(NNS
,
6417 E
->getQualifierRange(),
6422 template<typename Derived
>
6424 TreeTransform
<Derived
>::TransformCXXConstructExpr(CXXConstructExpr
*E
) {
6425 // CXXConstructExprs are always implicit, so when we have a
6426 // 1-argument construction we just transform that argument.
6427 if (E
->getNumArgs() == 1 ||
6428 (E
->getNumArgs() > 1 && getDerived().DropCallArgument(E
->getArg(1))))
6429 return getDerived().TransformExpr(E
->getArg(0));
6431 TemporaryBase
Rebase(*this, /*FIXME*/E
->getLocStart(), DeclarationName());
6433 QualType T
= getDerived().TransformType(E
->getType());
6437 CXXConstructorDecl
*Constructor
6438 = cast_or_null
<CXXConstructorDecl
>(
6439 getDerived().TransformDecl(E
->getLocStart(),
6440 E
->getConstructor()));
6444 bool ArgumentChanged
= false;
6445 ASTOwningVector
<Expr
*> Args(SemaRef
);
6446 if (getDerived().TransformExprs(E
->getArgs(), E
->getNumArgs(), true, Args
,
6450 if (!getDerived().AlwaysRebuild() &&
6451 T
== E
->getType() &&
6452 Constructor
== E
->getConstructor() &&
6454 // Mark the constructor as referenced.
6455 // FIXME: Instantiation-specific
6456 SemaRef
.MarkDeclarationReferenced(E
->getLocStart(), Constructor
);
6457 return SemaRef
.Owned(E
);
6460 return getDerived().RebuildCXXConstructExpr(T
, /*FIXME:*/E
->getLocStart(),
6461 Constructor
, E
->isElidable(),
6463 E
->requiresZeroInitialization(),
6464 E
->getConstructionKind(),
6465 E
->getParenRange());
6468 /// \brief Transform a C++ temporary-binding expression.
6470 /// Since CXXBindTemporaryExpr nodes are implicitly generated, we just
6471 /// transform the subexpression and return that.
6472 template<typename Derived
>
6474 TreeTransform
<Derived
>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr
*E
) {
6475 return getDerived().TransformExpr(E
->getSubExpr());
6478 /// \brief Transform a C++ expression that contains cleanups that should
6479 /// be run after the expression is evaluated.
6481 /// Since ExprWithCleanups nodes are implicitly generated, we
6482 /// just transform the subexpression and return that.
6483 template<typename Derived
>
6485 TreeTransform
<Derived
>::TransformExprWithCleanups(ExprWithCleanups
*E
) {
6486 return getDerived().TransformExpr(E
->getSubExpr());
6489 template<typename Derived
>
6491 TreeTransform
<Derived
>::TransformCXXTemporaryObjectExpr(
6492 CXXTemporaryObjectExpr
*E
) {
6493 TypeSourceInfo
*T
= getDerived().TransformType(E
->getTypeSourceInfo());
6497 CXXConstructorDecl
*Constructor
6498 = cast_or_null
<CXXConstructorDecl
>(
6499 getDerived().TransformDecl(E
->getLocStart(),
6500 E
->getConstructor()));
6504 bool ArgumentChanged
= false;
6505 ASTOwningVector
<Expr
*> Args(SemaRef
);
6506 Args
.reserve(E
->getNumArgs());
6507 if (TransformExprs(E
->getArgs(), E
->getNumArgs(), true, Args
,
6511 if (!getDerived().AlwaysRebuild() &&
6512 T
== E
->getTypeSourceInfo() &&
6513 Constructor
== E
->getConstructor() &&
6515 // FIXME: Instantiation-specific
6516 SemaRef
.MarkDeclarationReferenced(E
->getLocStart(), Constructor
);
6517 return SemaRef
.MaybeBindToTemporary(E
);
6520 return getDerived().RebuildCXXTemporaryObjectExpr(T
,
6521 /*FIXME:*/T
->getTypeLoc().getEndLoc(),
6526 template<typename Derived
>
6528 TreeTransform
<Derived
>::TransformCXXUnresolvedConstructExpr(
6529 CXXUnresolvedConstructExpr
*E
) {
6530 TypeSourceInfo
*T
= getDerived().TransformType(E
->getTypeSourceInfo());
6534 bool ArgumentChanged
= false;
6535 ASTOwningVector
<Expr
*> Args(SemaRef
);
6536 Args
.reserve(E
->arg_size());
6537 if (getDerived().TransformExprs(E
->arg_begin(), E
->arg_size(), true, Args
,
6541 if (!getDerived().AlwaysRebuild() &&
6542 T
== E
->getTypeSourceInfo() &&
6544 return SemaRef
.Owned(E
);
6546 // FIXME: we're faking the locations of the commas
6547 return getDerived().RebuildCXXUnresolvedConstructExpr(T
,
6553 template<typename Derived
>
6555 TreeTransform
<Derived
>::TransformCXXDependentScopeMemberExpr(
6556 CXXDependentScopeMemberExpr
*E
) {
6557 // Transform the base of the expression.
6558 ExprResult
Base((Expr
*) 0);
6561 QualType ObjectType
;
6562 if (!E
->isImplicitAccess()) {
6563 OldBase
= E
->getBase();
6564 Base
= getDerived().TransformExpr(OldBase
);
6565 if (Base
.isInvalid())
6568 // Start the member reference and compute the object's type.
6569 ParsedType ObjectTy
;
6570 bool MayBePseudoDestructor
= false;
6571 Base
= SemaRef
.ActOnStartCXXMemberReference(0, Base
.get(),
6572 E
->getOperatorLoc(),
6573 E
->isArrow()? tok::arrow
: tok::period
,
6575 MayBePseudoDestructor
);
6576 if (Base
.isInvalid())
6579 ObjectType
= ObjectTy
.get();
6580 BaseType
= ((Expr
*) Base
.get())->getType();
6583 BaseType
= getDerived().TransformType(E
->getBaseType());
6584 ObjectType
= BaseType
->getAs
<PointerType
>()->getPointeeType();
6587 // Transform the first part of the nested-name-specifier that qualifies
6589 NamedDecl
*FirstQualifierInScope
6590 = getDerived().TransformFirstQualifierInScope(
6591 E
->getFirstQualifierFoundInScope(),
6592 E
->getQualifierRange().getBegin());
6594 NestedNameSpecifier
*Qualifier
= 0;
6595 if (E
->getQualifier()) {
6596 Qualifier
= getDerived().TransformNestedNameSpecifier(E
->getQualifier(),
6597 E
->getQualifierRange(),
6599 FirstQualifierInScope
);
6604 // TODO: If this is a conversion-function-id, verify that the
6605 // destination type name (if present) resolves the same way after
6606 // instantiation as it did in the local scope.
6608 DeclarationNameInfo NameInfo
6609 = getDerived().TransformDeclarationNameInfo(E
->getMemberNameInfo());
6610 if (!NameInfo
.getName())
6613 if (!E
->hasExplicitTemplateArgs()) {
6614 // This is a reference to a member without an explicitly-specified
6615 // template argument list. Optimize for this common case.
6616 if (!getDerived().AlwaysRebuild() &&
6617 Base
.get() == OldBase
&&
6618 BaseType
== E
->getBaseType() &&
6619 Qualifier
== E
->getQualifier() &&
6620 NameInfo
.getName() == E
->getMember() &&
6621 FirstQualifierInScope
== E
->getFirstQualifierFoundInScope())
6622 return SemaRef
.Owned(E
);
6624 return getDerived().RebuildCXXDependentScopeMemberExpr(Base
.get(),
6627 E
->getOperatorLoc(),
6629 E
->getQualifierRange(),
6630 FirstQualifierInScope
,
6632 /*TemplateArgs*/ 0);
6635 TemplateArgumentListInfo
TransArgs(E
->getLAngleLoc(), E
->getRAngleLoc());
6636 if (getDerived().TransformTemplateArguments(E
->getTemplateArgs(),
6637 E
->getNumTemplateArgs(),
6641 return getDerived().RebuildCXXDependentScopeMemberExpr(Base
.get(),
6644 E
->getOperatorLoc(),
6646 E
->getQualifierRange(),
6647 FirstQualifierInScope
,
6652 template<typename Derived
>
6654 TreeTransform
<Derived
>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr
*Old
) {
6655 // Transform the base of the expression.
6656 ExprResult
Base((Expr
*) 0);
6658 if (!Old
->isImplicitAccess()) {
6659 Base
= getDerived().TransformExpr(Old
->getBase());
6660 if (Base
.isInvalid())
6662 BaseType
= ((Expr
*) Base
.get())->getType();
6664 BaseType
= getDerived().TransformType(Old
->getBaseType());
6667 NestedNameSpecifier
*Qualifier
= 0;
6668 if (Old
->getQualifier()) {
6670 = getDerived().TransformNestedNameSpecifier(Old
->getQualifier(),
6671 Old
->getQualifierRange());
6676 LookupResult
R(SemaRef
, Old
->getMemberNameInfo(),
6677 Sema::LookupOrdinaryName
);
6679 // Transform all the decls.
6680 for (UnresolvedMemberExpr::decls_iterator I
= Old
->decls_begin(),
6681 E
= Old
->decls_end(); I
!= E
; ++I
) {
6682 NamedDecl
*InstD
= static_cast<NamedDecl
*>(
6683 getDerived().TransformDecl(Old
->getMemberLoc(),
6686 // Silently ignore these if a UsingShadowDecl instantiated to nothing.
6687 // This can happen because of dependent hiding.
6688 if (isa
<UsingShadowDecl
>(*I
))
6694 // Expand using declarations.
6695 if (isa
<UsingDecl
>(InstD
)) {
6696 UsingDecl
*UD
= cast
<UsingDecl
>(InstD
);
6697 for (UsingDecl::shadow_iterator I
= UD
->shadow_begin(),
6698 E
= UD
->shadow_end(); I
!= E
; ++I
)
6708 // Determine the naming class.
6709 if (Old
->getNamingClass()) {
6710 CXXRecordDecl
*NamingClass
6711 = cast_or_null
<CXXRecordDecl
>(getDerived().TransformDecl(
6712 Old
->getMemberLoc(),
6713 Old
->getNamingClass()));
6717 R
.setNamingClass(NamingClass
);
6720 TemplateArgumentListInfo TransArgs
;
6721 if (Old
->hasExplicitTemplateArgs()) {
6722 TransArgs
.setLAngleLoc(Old
->getLAngleLoc());
6723 TransArgs
.setRAngleLoc(Old
->getRAngleLoc());
6724 if (getDerived().TransformTemplateArguments(Old
->getTemplateArgs(),
6725 Old
->getNumTemplateArgs(),
6730 // FIXME: to do this check properly, we will need to preserve the
6731 // first-qualifier-in-scope here, just in case we had a dependent
6732 // base (and therefore couldn't do the check) and a
6733 // nested-name-qualifier (and therefore could do the lookup).
6734 NamedDecl
*FirstQualifierInScope
= 0;
6736 return getDerived().RebuildUnresolvedMemberExpr(Base
.get(),
6738 Old
->getOperatorLoc(),
6741 Old
->getQualifierRange(),
6742 FirstQualifierInScope
,
6744 (Old
->hasExplicitTemplateArgs()
6748 template<typename Derived
>
6750 TreeTransform
<Derived
>::TransformCXXNoexceptExpr(CXXNoexceptExpr
*E
) {
6751 ExprResult SubExpr
= getDerived().TransformExpr(E
->getOperand());
6752 if (SubExpr
.isInvalid())
6755 if (!getDerived().AlwaysRebuild() && SubExpr
.get() == E
->getOperand())
6756 return SemaRef
.Owned(E
);
6758 return getDerived().RebuildCXXNoexceptExpr(E
->getSourceRange(),SubExpr
.get());
6761 template<typename Derived
>
6763 TreeTransform
<Derived
>::TransformPackExpansionExpr(PackExpansionExpr
*E
) {
6764 llvm_unreachable("pack expansion expression in unhandled context");
6768 template<typename Derived
>
6770 TreeTransform
<Derived
>::TransformSizeOfPackExpr(SizeOfPackExpr
*E
) {
6771 // If E is not value-dependent, then nothing will change when we transform it.
6772 // Note: This is an instantiation-centric view.
6773 if (!E
->isValueDependent())
6774 return SemaRef
.Owned(E
);
6776 // Note: None of the implementations of TryExpandParameterPacks can ever
6777 // produce a diagnostic when given only a single unexpanded parameter pack,
6779 UnexpandedParameterPack
Unexpanded(E
->getPack(), E
->getPackLoc());
6780 bool ShouldExpand
= false;
6781 bool RetainExpansion
= false;
6782 unsigned NumExpansions
= 0;
6783 if (getDerived().TryExpandParameterPacks(E
->getOperatorLoc(), E
->getPackLoc(),
6785 ShouldExpand
, RetainExpansion
,
6789 if (!ShouldExpand
|| RetainExpansion
)
6790 return SemaRef
.Owned(E
);
6792 // We now know the length of the parameter pack, so build a new expression
6793 // that stores that length.
6794 return getDerived().RebuildSizeOfPackExpr(E
->getOperatorLoc(), E
->getPack(),
6795 E
->getPackLoc(), E
->getRParenLoc(),
6799 template<typename Derived
>
6801 TreeTransform
<Derived
>::TransformObjCStringLiteral(ObjCStringLiteral
*E
) {
6802 return SemaRef
.Owned(E
);
6805 template<typename Derived
>
6807 TreeTransform
<Derived
>::TransformObjCEncodeExpr(ObjCEncodeExpr
*E
) {
6808 TypeSourceInfo
*EncodedTypeInfo
6809 = getDerived().TransformType(E
->getEncodedTypeSourceInfo());
6810 if (!EncodedTypeInfo
)
6813 if (!getDerived().AlwaysRebuild() &&
6814 EncodedTypeInfo
== E
->getEncodedTypeSourceInfo())
6815 return SemaRef
.Owned(E
);
6817 return getDerived().RebuildObjCEncodeExpr(E
->getAtLoc(),
6822 template<typename Derived
>
6824 TreeTransform
<Derived
>::TransformObjCMessageExpr(ObjCMessageExpr
*E
) {
6825 // Transform arguments.
6826 bool ArgChanged
= false;
6827 ASTOwningVector
<Expr
*> Args(SemaRef
);
6828 Args
.reserve(E
->getNumArgs());
6829 if (getDerived().TransformExprs(E
->getArgs(), E
->getNumArgs(), false, Args
,
6833 if (E
->getReceiverKind() == ObjCMessageExpr::Class
) {
6834 // Class message: transform the receiver type.
6835 TypeSourceInfo
*ReceiverTypeInfo
6836 = getDerived().TransformType(E
->getClassReceiverTypeInfo());
6837 if (!ReceiverTypeInfo
)
6840 // If nothing changed, just retain the existing message send.
6841 if (!getDerived().AlwaysRebuild() &&
6842 ReceiverTypeInfo
== E
->getClassReceiverTypeInfo() && !ArgChanged
)
6843 return SemaRef
.Owned(E
);
6845 // Build a new class message send.
6846 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo
,
6848 E
->getSelectorLoc(),
6855 // Instance message: transform the receiver
6856 assert(E
->getReceiverKind() == ObjCMessageExpr::Instance
&&
6857 "Only class and instance messages may be instantiated");
6859 = getDerived().TransformExpr(E
->getInstanceReceiver());
6860 if (Receiver
.isInvalid())
6863 // If nothing changed, just retain the existing message send.
6864 if (!getDerived().AlwaysRebuild() &&
6865 Receiver
.get() == E
->getInstanceReceiver() && !ArgChanged
)
6866 return SemaRef
.Owned(E
);
6868 // Build a new instance message send.
6869 return getDerived().RebuildObjCMessageExpr(Receiver
.get(),
6871 E
->getSelectorLoc(),
6878 template<typename Derived
>
6880 TreeTransform
<Derived
>::TransformObjCSelectorExpr(ObjCSelectorExpr
*E
) {
6881 return SemaRef
.Owned(E
);
6884 template<typename Derived
>
6886 TreeTransform
<Derived
>::TransformObjCProtocolExpr(ObjCProtocolExpr
*E
) {
6887 return SemaRef
.Owned(E
);
6890 template<typename Derived
>
6892 TreeTransform
<Derived
>::TransformObjCIvarRefExpr(ObjCIvarRefExpr
*E
) {
6893 // Transform the base expression.
6894 ExprResult Base
= getDerived().TransformExpr(E
->getBase());
6895 if (Base
.isInvalid())
6898 // We don't need to transform the ivar; it will never change.
6900 // If nothing changed, just retain the existing expression.
6901 if (!getDerived().AlwaysRebuild() &&
6902 Base
.get() == E
->getBase())
6903 return SemaRef
.Owned(E
);
6905 return getDerived().RebuildObjCIvarRefExpr(Base
.get(), E
->getDecl(),
6907 E
->isArrow(), E
->isFreeIvar());
6910 template<typename Derived
>
6912 TreeTransform
<Derived
>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr
*E
) {
6913 // 'super' and types never change. Property never changes. Just
6914 // retain the existing expression.
6915 if (!E
->isObjectReceiver())
6916 return SemaRef
.Owned(E
);
6918 // Transform the base expression.
6919 ExprResult Base
= getDerived().TransformExpr(E
->getBase());
6920 if (Base
.isInvalid())
6923 // We don't need to transform the property; it will never change.
6925 // If nothing changed, just retain the existing expression.
6926 if (!getDerived().AlwaysRebuild() &&
6927 Base
.get() == E
->getBase())
6928 return SemaRef
.Owned(E
);
6930 if (E
->isExplicitProperty())
6931 return getDerived().RebuildObjCPropertyRefExpr(Base
.get(),
6932 E
->getExplicitProperty(),
6935 return getDerived().RebuildObjCPropertyRefExpr(Base
.get(),
6937 E
->getImplicitPropertyGetter(),
6938 E
->getImplicitPropertySetter(),
6942 template<typename Derived
>
6944 TreeTransform
<Derived
>::TransformObjCIsaExpr(ObjCIsaExpr
*E
) {
6945 // Transform the base expression.
6946 ExprResult Base
= getDerived().TransformExpr(E
->getBase());
6947 if (Base
.isInvalid())
6950 // If nothing changed, just retain the existing expression.
6951 if (!getDerived().AlwaysRebuild() &&
6952 Base
.get() == E
->getBase())
6953 return SemaRef
.Owned(E
);
6955 return getDerived().RebuildObjCIsaExpr(Base
.get(), E
->getIsaMemberLoc(),
6959 template<typename Derived
>
6961 TreeTransform
<Derived
>::TransformShuffleVectorExpr(ShuffleVectorExpr
*E
) {
6962 bool ArgumentChanged
= false;
6963 ASTOwningVector
<Expr
*> SubExprs(SemaRef
);
6964 SubExprs
.reserve(E
->getNumSubExprs());
6965 if (getDerived().TransformExprs(E
->getSubExprs(), E
->getNumSubExprs(), false,
6966 SubExprs
, &ArgumentChanged
))
6969 if (!getDerived().AlwaysRebuild() &&
6971 return SemaRef
.Owned(E
);
6973 return getDerived().RebuildShuffleVectorExpr(E
->getBuiltinLoc(),
6978 template<typename Derived
>
6980 TreeTransform
<Derived
>::TransformBlockExpr(BlockExpr
*E
) {
6981 SourceLocation
CaretLoc(E
->getExprLoc());
6983 SemaRef
.ActOnBlockStart(CaretLoc
, /*Scope=*/0);
6984 BlockScopeInfo
*CurBlock
= SemaRef
.getCurBlock();
6985 CurBlock
->TheDecl
->setIsVariadic(E
->getBlockDecl()->isVariadic());
6986 llvm::SmallVector
<ParmVarDecl
*, 4> Params
;
6987 llvm::SmallVector
<QualType
, 4> ParamTypes
;
6989 // Parameter substitution.
6990 // FIXME: Variadic templates
6991 const BlockDecl
*BD
= E
->getBlockDecl();
6992 for (BlockDecl::param_const_iterator P
= BD
->param_begin(),
6993 EN
= BD
->param_end(); P
!= EN
; ++P
) {
6994 ParmVarDecl
*OldParm
= (*P
);
6995 ParmVarDecl
*NewParm
= getDerived().TransformFunctionTypeParam(OldParm
);
6996 QualType NewType
= NewParm
->getType();
6997 Params
.push_back(NewParm
);
6998 ParamTypes
.push_back(NewParm
->getType());
7001 const FunctionType
*BExprFunctionType
= E
->getFunctionType();
7002 QualType BExprResultType
= BExprFunctionType
->getResultType();
7003 if (!BExprResultType
.isNull()) {
7004 if (!BExprResultType
->isDependentType())
7005 CurBlock
->ReturnType
= BExprResultType
;
7006 else if (BExprResultType
!= SemaRef
.Context
.DependentTy
)
7007 CurBlock
->ReturnType
= getDerived().TransformType(BExprResultType
);
7010 QualType FunctionType
= getDerived().RebuildFunctionProtoType(
7011 CurBlock
->ReturnType
,
7016 BExprFunctionType
->getExtInfo());
7017 CurBlock
->FunctionType
= FunctionType
;
7019 // Set the parameters on the block decl.
7020 if (!Params
.empty())
7021 CurBlock
->TheDecl
->setParams(Params
.data(), Params
.size());
7023 // Transform the body
7024 StmtResult Body
= getDerived().TransformStmt(E
->getBody());
7025 if (Body
.isInvalid())
7028 return SemaRef
.ActOnBlockStmtExpr(CaretLoc
, Body
.get(), /*Scope=*/0);
7031 template<typename Derived
>
7033 TreeTransform
<Derived
>::TransformBlockDeclRefExpr(BlockDeclRefExpr
*E
) {
7034 NestedNameSpecifier
*Qualifier
= 0;
7037 = cast_or_null
<ValueDecl
>(getDerived().TransformDecl(E
->getLocation(),
7042 if (!getDerived().AlwaysRebuild() &&
7043 ND
== E
->getDecl()) {
7044 // Mark it referenced in the new context regardless.
7045 // FIXME: this is a bit instantiation-specific.
7046 SemaRef
.MarkDeclarationReferenced(E
->getLocation(), ND
);
7048 return SemaRef
.Owned(E
);
7051 DeclarationNameInfo
NameInfo(E
->getDecl()->getDeclName(), E
->getLocation());
7052 return getDerived().RebuildDeclRefExpr(Qualifier
, SourceLocation(),
7056 //===----------------------------------------------------------------------===//
7057 // Type reconstruction
7058 //===----------------------------------------------------------------------===//
7060 template<typename Derived
>
7061 QualType TreeTransform
<Derived
>::RebuildPointerType(QualType PointeeType
,
7062 SourceLocation Star
) {
7063 return SemaRef
.BuildPointerType(PointeeType
, Star
,
7064 getDerived().getBaseEntity());
7067 template<typename Derived
>
7068 QualType TreeTransform
<Derived
>::RebuildBlockPointerType(QualType PointeeType
,
7069 SourceLocation Star
) {
7070 return SemaRef
.BuildBlockPointerType(PointeeType
, Star
,
7071 getDerived().getBaseEntity());
7074 template<typename Derived
>
7076 TreeTransform
<Derived
>::RebuildReferenceType(QualType ReferentType
,
7077 bool WrittenAsLValue
,
7078 SourceLocation Sigil
) {
7079 return SemaRef
.BuildReferenceType(ReferentType
, WrittenAsLValue
,
7080 Sigil
, getDerived().getBaseEntity());
7083 template<typename Derived
>
7085 TreeTransform
<Derived
>::RebuildMemberPointerType(QualType PointeeType
,
7087 SourceLocation Sigil
) {
7088 return SemaRef
.BuildMemberPointerType(PointeeType
, ClassType
,
7089 Sigil
, getDerived().getBaseEntity());
7092 template<typename Derived
>
7094 TreeTransform
<Derived
>::RebuildArrayType(QualType ElementType
,
7095 ArrayType::ArraySizeModifier SizeMod
,
7096 const llvm::APInt
*Size
,
7098 unsigned IndexTypeQuals
,
7099 SourceRange BracketsRange
) {
7100 if (SizeExpr
|| !Size
)
7101 return SemaRef
.BuildArrayType(ElementType
, SizeMod
, SizeExpr
,
7102 IndexTypeQuals
, BracketsRange
,
7103 getDerived().getBaseEntity());
7105 QualType Types
[] = {
7106 SemaRef
.Context
.UnsignedCharTy
, SemaRef
.Context
.UnsignedShortTy
,
7107 SemaRef
.Context
.UnsignedIntTy
, SemaRef
.Context
.UnsignedLongTy
,
7108 SemaRef
.Context
.UnsignedLongLongTy
, SemaRef
.Context
.UnsignedInt128Ty
7110 const unsigned NumTypes
= sizeof(Types
) / sizeof(QualType
);
7112 for (unsigned I
= 0; I
!= NumTypes
; ++I
)
7113 if (Size
->getBitWidth() == SemaRef
.Context
.getIntWidth(Types
[I
])) {
7114 SizeType
= Types
[I
];
7118 IntegerLiteral
ArraySize(SemaRef
.Context
, *Size
, SizeType
,
7119 /*FIXME*/BracketsRange
.getBegin());
7120 return SemaRef
.BuildArrayType(ElementType
, SizeMod
, &ArraySize
,
7121 IndexTypeQuals
, BracketsRange
,
7122 getDerived().getBaseEntity());
7125 template<typename Derived
>
7127 TreeTransform
<Derived
>::RebuildConstantArrayType(QualType ElementType
,
7128 ArrayType::ArraySizeModifier SizeMod
,
7129 const llvm::APInt
&Size
,
7130 unsigned IndexTypeQuals
,
7131 SourceRange BracketsRange
) {
7132 return getDerived().RebuildArrayType(ElementType
, SizeMod
, &Size
, 0,
7133 IndexTypeQuals
, BracketsRange
);
7136 template<typename Derived
>
7138 TreeTransform
<Derived
>::RebuildIncompleteArrayType(QualType ElementType
,
7139 ArrayType::ArraySizeModifier SizeMod
,
7140 unsigned IndexTypeQuals
,
7141 SourceRange BracketsRange
) {
7142 return getDerived().RebuildArrayType(ElementType
, SizeMod
, 0, 0,
7143 IndexTypeQuals
, BracketsRange
);
7146 template<typename Derived
>
7148 TreeTransform
<Derived
>::RebuildVariableArrayType(QualType ElementType
,
7149 ArrayType::ArraySizeModifier SizeMod
,
7151 unsigned IndexTypeQuals
,
7152 SourceRange BracketsRange
) {
7153 return getDerived().RebuildArrayType(ElementType
, SizeMod
, 0,
7155 IndexTypeQuals
, BracketsRange
);
7158 template<typename Derived
>
7160 TreeTransform
<Derived
>::RebuildDependentSizedArrayType(QualType ElementType
,
7161 ArrayType::ArraySizeModifier SizeMod
,
7163 unsigned IndexTypeQuals
,
7164 SourceRange BracketsRange
) {
7165 return getDerived().RebuildArrayType(ElementType
, SizeMod
, 0,
7167 IndexTypeQuals
, BracketsRange
);
7170 template<typename Derived
>
7171 QualType TreeTransform
<Derived
>::RebuildVectorType(QualType ElementType
,
7172 unsigned NumElements
,
7173 VectorType::VectorKind VecKind
) {
7174 // FIXME: semantic checking!
7175 return SemaRef
.Context
.getVectorType(ElementType
, NumElements
, VecKind
);
7178 template<typename Derived
>
7179 QualType TreeTransform
<Derived
>::RebuildExtVectorType(QualType ElementType
,
7180 unsigned NumElements
,
7181 SourceLocation AttributeLoc
) {
7182 llvm::APInt
numElements(SemaRef
.Context
.getIntWidth(SemaRef
.Context
.IntTy
),
7184 IntegerLiteral
*VectorSize
7185 = IntegerLiteral::Create(SemaRef
.Context
, numElements
, SemaRef
.Context
.IntTy
,
7187 return SemaRef
.BuildExtVectorType(ElementType
, VectorSize
, AttributeLoc
);
7190 template<typename Derived
>
7192 TreeTransform
<Derived
>::RebuildDependentSizedExtVectorType(QualType ElementType
,
7194 SourceLocation AttributeLoc
) {
7195 return SemaRef
.BuildExtVectorType(ElementType
, SizeExpr
, AttributeLoc
);
7198 template<typename Derived
>
7199 QualType TreeTransform
<Derived
>::RebuildFunctionProtoType(QualType T
,
7200 QualType
*ParamTypes
,
7201 unsigned NumParamTypes
,
7204 const FunctionType::ExtInfo
&Info
) {
7205 return SemaRef
.BuildFunctionType(T
, ParamTypes
, NumParamTypes
, Variadic
,
7207 getDerived().getBaseLocation(),
7208 getDerived().getBaseEntity(),
7212 template<typename Derived
>
7213 QualType TreeTransform
<Derived
>::RebuildFunctionNoProtoType(QualType T
) {
7214 return SemaRef
.Context
.getFunctionNoProtoType(T
);
7217 template<typename Derived
>
7218 QualType TreeTransform
<Derived
>::RebuildUnresolvedUsingType(Decl
*D
) {
7219 assert(D
&& "no decl found");
7220 if (D
->isInvalidDecl()) return QualType();
7222 // FIXME: Doesn't account for ObjCInterfaceDecl!
7224 if (isa
<UsingDecl
>(D
)) {
7225 UsingDecl
*Using
= cast
<UsingDecl
>(D
);
7226 assert(Using
->isTypeName() &&
7227 "UnresolvedUsingTypenameDecl transformed to non-typename using");
7229 // A valid resolved using typename decl points to exactly one type decl.
7230 assert(++Using
->shadow_begin() == Using
->shadow_end());
7231 Ty
= cast
<TypeDecl
>((*Using
->shadow_begin())->getTargetDecl());
7234 assert(isa
<UnresolvedUsingTypenameDecl
>(D
) &&
7235 "UnresolvedUsingTypenameDecl transformed to non-using decl");
7236 Ty
= cast
<UnresolvedUsingTypenameDecl
>(D
);
7239 return SemaRef
.Context
.getTypeDeclType(Ty
);
7242 template<typename Derived
>
7243 QualType TreeTransform
<Derived
>::RebuildTypeOfExprType(Expr
*E
,
7244 SourceLocation Loc
) {
7245 return SemaRef
.BuildTypeofExprType(E
, Loc
);
7248 template<typename Derived
>
7249 QualType TreeTransform
<Derived
>::RebuildTypeOfType(QualType Underlying
) {
7250 return SemaRef
.Context
.getTypeOfType(Underlying
);
7253 template<typename Derived
>
7254 QualType TreeTransform
<Derived
>::RebuildDecltypeType(Expr
*E
,
7255 SourceLocation Loc
) {
7256 return SemaRef
.BuildDecltypeType(E
, Loc
);
7259 template<typename Derived
>
7260 QualType TreeTransform
<Derived
>::RebuildTemplateSpecializationType(
7261 TemplateName Template
,
7262 SourceLocation TemplateNameLoc
,
7263 const TemplateArgumentListInfo
&TemplateArgs
) {
7264 return SemaRef
.CheckTemplateIdType(Template
, TemplateNameLoc
, TemplateArgs
);
7267 template<typename Derived
>
7268 NestedNameSpecifier
*
7269 TreeTransform
<Derived
>::RebuildNestedNameSpecifier(NestedNameSpecifier
*Prefix
,
7272 QualType ObjectType
,
7273 NamedDecl
*FirstQualifierInScope
) {
7275 // FIXME: The source location information is all wrong.
7277 SS
.setScopeRep(Prefix
);
7278 return static_cast<NestedNameSpecifier
*>(
7279 SemaRef
.BuildCXXNestedNameSpecifier(0, SS
, Range
.getEnd(),
7282 FirstQualifierInScope
,
7286 template<typename Derived
>
7287 NestedNameSpecifier
*
7288 TreeTransform
<Derived
>::RebuildNestedNameSpecifier(NestedNameSpecifier
*Prefix
,
7290 NamespaceDecl
*NS
) {
7291 return NestedNameSpecifier::Create(SemaRef
.Context
, Prefix
, NS
);
7294 template<typename Derived
>
7295 NestedNameSpecifier
*
7296 TreeTransform
<Derived
>::RebuildNestedNameSpecifier(NestedNameSpecifier
*Prefix
,
7300 if (T
->isDependentType() || T
->isRecordType() ||
7301 (SemaRef
.getLangOptions().CPlusPlus0x
&& T
->isEnumeralType())) {
7302 assert(!T
.hasLocalQualifiers() && "Can't get cv-qualifiers here");
7303 return NestedNameSpecifier::Create(SemaRef
.Context
, Prefix
, TemplateKW
,
7307 SemaRef
.Diag(Range
.getBegin(), diag::err_nested_name_spec_non_tag
) << T
;
7311 template<typename Derived
>
7313 TreeTransform
<Derived
>::RebuildTemplateName(NestedNameSpecifier
*Qualifier
,
7315 TemplateDecl
*Template
) {
7316 return SemaRef
.Context
.getQualifiedTemplateName(Qualifier
, TemplateKW
,
7320 template<typename Derived
>
7322 TreeTransform
<Derived
>::RebuildTemplateName(NestedNameSpecifier
*Qualifier
,
7323 SourceRange QualifierRange
,
7324 const IdentifierInfo
&II
,
7325 QualType ObjectType
,
7326 NamedDecl
*FirstQualifierInScope
) {
7328 SS
.setRange(QualifierRange
);
7329 SS
.setScopeRep(Qualifier
);
7331 Name
.setIdentifier(&II
, /*FIXME:*/getDerived().getBaseLocation());
7332 Sema::TemplateTy Template
;
7333 getSema().ActOnDependentTemplateName(/*Scope=*/0,
7334 /*FIXME:*/getDerived().getBaseLocation(),
7337 ParsedType::make(ObjectType
),
7338 /*EnteringContext=*/false,
7340 return Template
.get();
7343 template<typename Derived
>
7345 TreeTransform
<Derived
>::RebuildTemplateName(NestedNameSpecifier
*Qualifier
,
7346 OverloadedOperatorKind Operator
,
7347 QualType ObjectType
) {
7349 SS
.setRange(SourceRange(getDerived().getBaseLocation()));
7350 SS
.setScopeRep(Qualifier
);
7352 SourceLocation SymbolLocations
[3]; // FIXME: Bogus location information.
7353 Name
.setOperatorFunctionId(/*FIXME:*/getDerived().getBaseLocation(),
7354 Operator
, SymbolLocations
);
7355 Sema::TemplateTy Template
;
7356 getSema().ActOnDependentTemplateName(/*Scope=*/0,
7357 /*FIXME:*/getDerived().getBaseLocation(),
7360 ParsedType::make(ObjectType
),
7361 /*EnteringContext=*/false,
7363 return Template
.template getAsVal
<TemplateName
>();
7366 template<typename Derived
>
7368 TreeTransform
<Derived
>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op
,
7369 SourceLocation OpLoc
,
7373 Expr
*Callee
= OrigCallee
->IgnoreParenCasts();
7374 bool isPostIncDec
= Second
&& (Op
== OO_PlusPlus
|| Op
== OO_MinusMinus
);
7376 // Determine whether this should be a builtin operation.
7377 if (Op
== OO_Subscript
) {
7378 if (!First
->getType()->isOverloadableType() &&
7379 !Second
->getType()->isOverloadableType())
7380 return getSema().CreateBuiltinArraySubscriptExpr(First
,
7381 Callee
->getLocStart(),
7383 } else if (Op
== OO_Arrow
) {
7384 // -> is never a builtin operation.
7385 return SemaRef
.BuildOverloadedArrowExpr(0, First
, OpLoc
);
7386 } else if (Second
== 0 || isPostIncDec
) {
7387 if (!First
->getType()->isOverloadableType()) {
7388 // The argument is not of overloadable type, so try to create a
7389 // built-in unary operation.
7390 UnaryOperatorKind Opc
7391 = UnaryOperator::getOverloadedOpcode(Op
, isPostIncDec
);
7393 return getSema().CreateBuiltinUnaryOp(OpLoc
, Opc
, First
);
7396 if (!First
->getType()->isOverloadableType() &&
7397 !Second
->getType()->isOverloadableType()) {
7398 // Neither of the arguments is an overloadable type, so try to
7399 // create a built-in binary operation.
7400 BinaryOperatorKind Opc
= BinaryOperator::getOverloadedOpcode(Op
);
7402 = SemaRef
.CreateBuiltinBinOp(OpLoc
, Opc
, First
, Second
);
7403 if (Result
.isInvalid())
7406 return move(Result
);
7410 // Compute the transformed set of functions (and function templates) to be
7411 // used during overload resolution.
7412 UnresolvedSet
<16> Functions
;
7414 if (UnresolvedLookupExpr
*ULE
= dyn_cast
<UnresolvedLookupExpr
>(Callee
)) {
7415 assert(ULE
->requiresADL());
7417 // FIXME: Do we have to check
7418 // IsAcceptableNonMemberOperatorCandidate for each of these?
7419 Functions
.append(ULE
->decls_begin(), ULE
->decls_end());
7421 Functions
.addDecl(cast
<DeclRefExpr
>(Callee
)->getDecl());
7424 // Add any functions found via argument-dependent lookup.
7425 Expr
*Args
[2] = { First
, Second
};
7426 unsigned NumArgs
= 1 + (Second
!= 0);
7428 // Create the overloaded operator invocation for unary operators.
7429 if (NumArgs
== 1 || isPostIncDec
) {
7430 UnaryOperatorKind Opc
7431 = UnaryOperator::getOverloadedOpcode(Op
, isPostIncDec
);
7432 return SemaRef
.CreateOverloadedUnaryOp(OpLoc
, Opc
, Functions
, First
);
7435 if (Op
== OO_Subscript
)
7436 return SemaRef
.CreateOverloadedArraySubscriptExpr(Callee
->getLocStart(),
7441 // Create the overloaded operator invocation for binary operators.
7442 BinaryOperatorKind Opc
= BinaryOperator::getOverloadedOpcode(Op
);
7444 = SemaRef
.CreateOverloadedBinOp(OpLoc
, Opc
, Functions
, Args
[0], Args
[1]);
7445 if (Result
.isInvalid())
7448 return move(Result
);
7451 template<typename Derived
>
7453 TreeTransform
<Derived
>::RebuildCXXPseudoDestructorExpr(Expr
*Base
,
7454 SourceLocation OperatorLoc
,
7456 NestedNameSpecifier
*Qualifier
,
7457 SourceRange QualifierRange
,
7458 TypeSourceInfo
*ScopeType
,
7459 SourceLocation CCLoc
,
7460 SourceLocation TildeLoc
,
7461 PseudoDestructorTypeStorage Destroyed
) {
7464 SS
.setRange(QualifierRange
);
7465 SS
.setScopeRep(Qualifier
);
7468 QualType BaseType
= Base
->getType();
7469 if (Base
->isTypeDependent() || Destroyed
.getIdentifier() ||
7470 (!isArrow
&& !BaseType
->getAs
<RecordType
>()) ||
7471 (isArrow
&& BaseType
->getAs
<PointerType
>() &&
7472 !BaseType
->getAs
<PointerType
>()->getPointeeType()
7473 ->template getAs
<RecordType
>())){
7474 // This pseudo-destructor expression is still a pseudo-destructor.
7475 return SemaRef
.BuildPseudoDestructorExpr(Base
, OperatorLoc
,
7476 isArrow
? tok::arrow
: tok::period
,
7477 SS
, ScopeType
, CCLoc
, TildeLoc
,
7482 TypeSourceInfo
*DestroyedType
= Destroyed
.getTypeSourceInfo();
7483 DeclarationName
Name(SemaRef
.Context
.DeclarationNames
.getCXXDestructorName(
7484 SemaRef
.Context
.getCanonicalType(DestroyedType
->getType())));
7485 DeclarationNameInfo
NameInfo(Name
, Destroyed
.getLocation());
7486 NameInfo
.setNamedTypeInfo(DestroyedType
);
7488 // FIXME: the ScopeType should be tacked onto SS.
7490 return getSema().BuildMemberReferenceExpr(Base
, BaseType
,
7491 OperatorLoc
, isArrow
,
7492 SS
, /*FIXME: FirstQualifier*/ 0,
7494 /*TemplateArgs*/ 0);
7497 } // end namespace clang
7499 #endif // LLVM_CLANG_SEMA_TREETRANSFORM_H