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
18 #include "clang/Sema/SemaDiagnostic.h"
19 #include "clang/AST/Decl.h"
20 #include "clang/AST/Expr.h"
21 #include "clang/AST/ExprCXX.h"
22 #include "clang/AST/ExprObjC.h"
23 #include "clang/AST/Stmt.h"
24 #include "clang/AST/StmtCXX.h"
25 #include "clang/AST/StmtObjC.h"
26 #include "clang/AST/TypeLocBuilder.h"
27 #include "clang/Parse/Ownership.h"
28 #include "clang/Parse/Designator.h"
29 #include "clang/Lex/Preprocessor.h"
30 #include "llvm/Support/ErrorHandling.h"
35 /// \brief A semantic tree transformation that allows one to transform one
36 /// abstract syntax tree into another.
38 /// A new tree transformation is defined by creating a new subclass \c X of
39 /// \c TreeTransform<X> and then overriding certain operations to provide
40 /// behavior specific to that transformation. For example, template
41 /// instantiation is implemented as a tree transformation where the
42 /// transformation of TemplateTypeParmType nodes involves substituting the
43 /// template arguments for their corresponding template parameters; a similar
44 /// transformation is performed for non-type template parameters and
45 /// template template parameters.
47 /// This tree-transformation template uses static polymorphism to allow
48 /// subclasses to customize any of its operations. Thus, a subclass can
49 /// override any of the transformation or rebuild operators by providing an
50 /// operation with the same signature as the default implementation. The
51 /// overridding function should not be virtual.
53 /// Semantic tree transformations are split into two stages, either of which
54 /// can be replaced by a subclass. The "transform" step transforms an AST node
55 /// or the parts of an AST node using the various transformation functions,
56 /// then passes the pieces on to the "rebuild" step, which constructs a new AST
57 /// node of the appropriate kind from the pieces. The default transformation
58 /// routines recursively transform the operands to composite AST nodes (e.g.,
59 /// the pointee type of a PointerType node) and, if any of those operand nodes
60 /// were changed by the transformation, invokes the rebuild operation to create
63 /// Subclasses can customize the transformation at various levels. The
64 /// most coarse-grained transformations involve replacing TransformType(),
65 /// TransformExpr(), TransformDecl(), TransformNestedNameSpecifier(),
66 /// TransformTemplateName(), or TransformTemplateArgument() with entirely
67 /// new implementations.
69 /// For more fine-grained transformations, subclasses can replace any of the
70 /// \c TransformXXX functions (where XXX is the name of an AST node, e.g.,
71 /// PointerType, StmtExpr) to alter the transformation. As mentioned previously,
72 /// replacing TransformTemplateTypeParmType() allows template instantiation
73 /// to substitute template arguments for their corresponding template
74 /// parameters. Additionally, subclasses can override the \c RebuildXXX
75 /// functions to control how AST nodes are rebuilt when their operands change.
76 /// By default, \c TreeTransform will invoke semantic analysis to rebuild
77 /// AST nodes. However, certain other tree transformations (e.g, cloning) may
78 /// be able to use more efficient rebuild steps.
80 /// There are a handful of other functions that can be overridden, allowing one
81 /// to avoid traversing nodes that don't need any transformation
82 /// (\c AlreadyTransformed()), force rebuilding AST nodes even when their
83 /// operands have not changed (\c AlwaysRebuild()), and customize the
84 /// default locations and entity names used for type-checking
85 /// (\c getBaseLocation(), \c getBaseEntity()).
86 template<typename Derived>
92 typedef Sema::OwningStmtResult OwningStmtResult;
93 typedef Sema::OwningExprResult OwningExprResult;
94 typedef Sema::StmtArg StmtArg;
95 typedef Sema::ExprArg ExprArg;
96 typedef Sema::MultiExprArg MultiExprArg;
97 typedef Sema::MultiStmtArg MultiStmtArg;
98 typedef Sema::DeclPtrTy DeclPtrTy;
100 /// \brief Initializes a new tree transformer.
101 TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { }
103 /// \brief Retrieves a reference to the derived class.
104 Derived &getDerived() { return static_cast<Derived&>(*this); }
106 /// \brief Retrieves a reference to the derived class.
107 const Derived &getDerived() const {
108 return static_cast<const Derived&>(*this);
111 /// \brief Retrieves a reference to the semantic analysis object used for
112 /// this tree transform.
113 Sema &getSema() const { return SemaRef; }
115 /// \brief Whether the transformation should always rebuild AST nodes, even
116 /// if none of the children have changed.
118 /// Subclasses may override this function to specify when the transformation
119 /// should rebuild all AST nodes.
120 bool AlwaysRebuild() { return false; }
122 /// \brief Returns the location of the entity being transformed, if that
123 /// information was not available elsewhere in the AST.
125 /// By default, returns no source-location information. Subclasses can
126 /// provide an alternative implementation that provides better location
128 SourceLocation getBaseLocation() { return SourceLocation(); }
130 /// \brief Returns the name of the entity being transformed, if that
131 /// information was not available elsewhere in the AST.
133 /// By default, returns an empty name. Subclasses can provide an alternative
134 /// implementation with a more precise name.
135 DeclarationName getBaseEntity() { return DeclarationName(); }
137 /// \brief Sets the "base" location and entity when that
138 /// information is known based on another transformation.
140 /// By default, the source location and entity are ignored. Subclasses can
141 /// override this function to provide a customized implementation.
142 void setBase(SourceLocation Loc, DeclarationName Entity) { }
144 /// \brief RAII object that temporarily sets the base location and entity
145 /// used for reporting diagnostics in types.
146 class TemporaryBase {
148 SourceLocation OldLocation;
149 DeclarationName OldEntity;
152 TemporaryBase(TreeTransform &Self, SourceLocation Location,
153 DeclarationName Entity) : Self(Self) {
154 OldLocation = Self.getDerived().getBaseLocation();
155 OldEntity = Self.getDerived().getBaseEntity();
156 Self.getDerived().setBase(Location, Entity);
160 Self.getDerived().setBase(OldLocation, OldEntity);
164 /// \brief Determine whether the given type \p T has already been
167 /// Subclasses can provide an alternative implementation of this routine
168 /// to short-circuit evaluation when it is known that a given type will
169 /// not change. For example, template instantiation need not traverse
170 /// non-dependent types.
171 bool AlreadyTransformed(QualType T) {
175 /// \brief Determine whether the given call argument should be dropped, e.g.,
176 /// because it is a default argument.
178 /// Subclasses can provide an alternative implementation of this routine to
179 /// determine which kinds of call arguments get dropped. By default,
180 /// CXXDefaultArgument nodes are dropped (prior to transformation).
181 bool DropCallArgument(Expr *E) {
182 return E->isDefaultArgument();
185 /// \brief Transforms the given type into another type.
187 /// By default, this routine transforms a type by creating a
188 /// TypeSourceInfo for it and delegating to the appropriate
189 /// function. This is expensive, but we don't mind, because
190 /// this method is deprecated anyway; all users should be
191 /// switched to storing TypeSourceInfos.
193 /// \returns the transformed type.
194 QualType TransformType(QualType T, QualType ObjectType = QualType());
196 /// \brief Transforms the given type-with-location into a new
197 /// type-with-location.
199 /// By default, this routine transforms a type by delegating to the
200 /// appropriate TransformXXXType to build a new type. Subclasses
201 /// may override this function (to take over all type
202 /// transformations) or some set of the TransformXXXType functions
203 /// to alter the transformation.
204 TypeSourceInfo *TransformType(TypeSourceInfo *DI,
205 QualType ObjectType = QualType());
207 /// \brief Transform the given type-with-location into a new
208 /// type, collecting location information in the given builder
211 QualType TransformType(TypeLocBuilder &TLB, TypeLoc TL,
212 QualType ObjectType = QualType());
214 /// \brief Transform the given statement.
216 /// By default, this routine transforms a statement by delegating to the
217 /// appropriate TransformXXXStmt function to transform a specific kind of
218 /// statement or the TransformExpr() function to transform an expression.
219 /// Subclasses may override this function to transform statements using some
222 /// \returns the transformed statement.
223 OwningStmtResult TransformStmt(Stmt *S);
225 /// \brief Transform the given expression.
227 /// By default, this routine transforms an expression by delegating to the
228 /// appropriate TransformXXXExpr function to build a new expression.
229 /// Subclasses may override this function to transform expressions using some
232 /// \returns the transformed expression.
233 OwningExprResult TransformExpr(Expr *E);
235 /// \brief Transform the given declaration, which is referenced from a type
238 /// By default, acts as the identity function on declarations. Subclasses
239 /// may override this function to provide alternate behavior.
240 Decl *TransformDecl(SourceLocation Loc, Decl *D) { return D; }
242 /// \brief Transform the definition of the given declaration.
244 /// By default, invokes TransformDecl() to transform the declaration.
245 /// Subclasses may override this function to provide alternate behavior.
246 Decl *TransformDefinition(SourceLocation Loc, Decl *D) {
247 return getDerived().TransformDecl(Loc, D);
250 /// \brief Transform the given declaration, which was the first part of a
251 /// nested-name-specifier in a member access expression.
253 /// This specific declaration transformation only applies to the first
254 /// identifier in a nested-name-specifier of a member access expression, e.g.,
255 /// the \c T in \c x->T::member
257 /// By default, invokes TransformDecl() to transform the declaration.
258 /// Subclasses may override this function to provide alternate behavior.
259 NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc) {
260 return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D));
263 /// \brief Transform the given nested-name-specifier.
265 /// By default, transforms all of the types and declarations within the
266 /// nested-name-specifier. Subclasses may override this function to provide
267 /// alternate behavior.
268 NestedNameSpecifier *TransformNestedNameSpecifier(NestedNameSpecifier *NNS,
270 QualType ObjectType = QualType(),
271 NamedDecl *FirstQualifierInScope = 0);
273 /// \brief Transform the given declaration name.
275 /// By default, transforms the types of conversion function, constructor,
276 /// and destructor names and then (if needed) rebuilds the declaration name.
277 /// Identifiers and selectors are returned unmodified. Sublcasses may
278 /// override this function to provide alternate behavior.
279 DeclarationName TransformDeclarationName(DeclarationName Name,
281 QualType ObjectType = QualType());
283 /// \brief Transform the given template name.
285 /// By default, transforms the template name by transforming the declarations
286 /// and nested-name-specifiers that occur within the template name.
287 /// Subclasses may override this function to provide alternate behavior.
288 TemplateName TransformTemplateName(TemplateName Name,
289 QualType ObjectType = QualType());
291 /// \brief Transform the given template argument.
293 /// By default, this operation transforms the type, expression, or
294 /// declaration stored within the template argument and constructs a
295 /// new template argument from the transformed result. Subclasses may
296 /// override this function to provide alternate behavior.
298 /// Returns true if there was an error.
299 bool TransformTemplateArgument(const TemplateArgumentLoc &Input,
300 TemplateArgumentLoc &Output);
302 /// \brief Fakes up a TemplateArgumentLoc for a given TemplateArgument.
303 void InventTemplateArgumentLoc(const TemplateArgument &Arg,
304 TemplateArgumentLoc &ArgLoc);
306 /// \brief Fakes up a TypeSourceInfo for a type.
307 TypeSourceInfo *InventTypeSourceInfo(QualType T) {
308 return SemaRef.Context.getTrivialTypeSourceInfo(T,
309 getDerived().getBaseLocation());
312 #define ABSTRACT_TYPELOC(CLASS, PARENT)
313 #define TYPELOC(CLASS, PARENT) \
314 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T, \
315 QualType ObjectType = QualType());
316 #include "clang/AST/TypeLocNodes.def"
318 /// \brief Transforms the parameters of a function type into the
321 /// The result vectors should be kept in sync; null entries in the
322 /// variables vector are acceptable.
324 /// Return true on error.
325 bool TransformFunctionTypeParams(FunctionProtoTypeLoc TL,
326 llvm::SmallVectorImpl<QualType> &PTypes,
327 llvm::SmallVectorImpl<ParmVarDecl*> &PVars);
329 /// \brief Transforms a single function-type parameter. Return null
331 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm);
333 QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL,
334 QualType ObjectType);
337 TransformTemplateSpecializationType(const TemplateSpecializationType *T,
338 QualType ObjectType);
340 OwningStmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr);
341 OwningExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *E);
343 #define STMT(Node, Parent) \
344 OwningStmtResult Transform##Node(Node *S);
345 #define EXPR(Node, Parent) \
346 OwningExprResult Transform##Node(Node *E);
347 #define ABSTRACT_STMT(Stmt)
348 #include "clang/AST/StmtNodes.inc"
350 /// \brief Build a new pointer type given its pointee type.
352 /// By default, performs semantic analysis when building the pointer type.
353 /// Subclasses may override this routine to provide different behavior.
354 QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);
356 /// \brief Build a new block pointer type given its pointee type.
358 /// By default, performs semantic analysis when building the block pointer
359 /// type. Subclasses may override this routine to provide different behavior.
360 QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);
362 /// \brief Build a new reference type given the type it references.
364 /// By default, performs semantic analysis when building the
365 /// reference type. Subclasses may override this routine to provide
366 /// different behavior.
368 /// \param LValue whether the type was written with an lvalue sigil
369 /// or an rvalue sigil.
370 QualType RebuildReferenceType(QualType ReferentType,
372 SourceLocation Sigil);
374 /// \brief Build a new member pointer type given the pointee type and the
375 /// class type it refers into.
377 /// By default, performs semantic analysis when building the member pointer
378 /// type. Subclasses may override this routine to provide different behavior.
379 QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
380 SourceLocation Sigil);
382 /// \brief Build a new array type given the element type, size
383 /// modifier, size of the array (if known), size expression, and index type
386 /// By default, performs semantic analysis when building the array type.
387 /// Subclasses may override this routine to provide different behavior.
388 /// Also by default, all of the other Rebuild*Array
389 QualType RebuildArrayType(QualType ElementType,
390 ArrayType::ArraySizeModifier SizeMod,
391 const llvm::APInt *Size,
393 unsigned IndexTypeQuals,
394 SourceRange BracketsRange);
396 /// \brief Build a new constant array type given the element type, size
397 /// modifier, (known) size of the array, and index type qualifiers.
399 /// By default, performs semantic analysis when building the array type.
400 /// Subclasses may override this routine to provide different behavior.
401 QualType RebuildConstantArrayType(QualType ElementType,
402 ArrayType::ArraySizeModifier SizeMod,
403 const llvm::APInt &Size,
404 unsigned IndexTypeQuals,
405 SourceRange BracketsRange);
407 /// \brief Build a new incomplete array type given the element type, size
408 /// modifier, and index type qualifiers.
410 /// By default, performs semantic analysis when building the array type.
411 /// Subclasses may override this routine to provide different behavior.
412 QualType RebuildIncompleteArrayType(QualType ElementType,
413 ArrayType::ArraySizeModifier SizeMod,
414 unsigned IndexTypeQuals,
415 SourceRange BracketsRange);
417 /// \brief Build a new variable-length array type given the element type,
418 /// size modifier, size expression, and index type qualifiers.
420 /// By default, performs semantic analysis when building the array type.
421 /// Subclasses may override this routine to provide different behavior.
422 QualType RebuildVariableArrayType(QualType ElementType,
423 ArrayType::ArraySizeModifier SizeMod,
425 unsigned IndexTypeQuals,
426 SourceRange BracketsRange);
428 /// \brief Build a new dependent-sized array type given the element type,
429 /// size modifier, size expression, and index type qualifiers.
431 /// By default, performs semantic analysis when building the array type.
432 /// Subclasses may override this routine to provide different behavior.
433 QualType RebuildDependentSizedArrayType(QualType ElementType,
434 ArrayType::ArraySizeModifier SizeMod,
436 unsigned IndexTypeQuals,
437 SourceRange BracketsRange);
439 /// \brief Build a new vector type given the element type and
440 /// number of elements.
442 /// By default, performs semantic analysis when building the vector type.
443 /// Subclasses may override this routine to provide different behavior.
444 QualType RebuildVectorType(QualType ElementType, unsigned NumElements,
445 VectorType::AltiVecSpecific AltiVecSpec);
447 /// \brief Build a new extended vector type given the element type and
448 /// number of elements.
450 /// By default, performs semantic analysis when building the vector type.
451 /// Subclasses may override this routine to provide different behavior.
452 QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements,
453 SourceLocation AttributeLoc);
455 /// \brief Build a new potentially dependently-sized extended vector type
456 /// given the element type and number of elements.
458 /// By default, performs semantic analysis when building the vector type.
459 /// Subclasses may override this routine to provide different behavior.
460 QualType RebuildDependentSizedExtVectorType(QualType ElementType,
462 SourceLocation AttributeLoc);
464 /// \brief Build a new function type.
466 /// By default, performs semantic analysis when building the function type.
467 /// Subclasses may override this routine to provide different behavior.
468 QualType RebuildFunctionProtoType(QualType T,
469 QualType *ParamTypes,
470 unsigned NumParamTypes,
471 bool Variadic, unsigned Quals);
473 /// \brief Build a new unprototyped function type.
474 QualType RebuildFunctionNoProtoType(QualType ResultType);
476 /// \brief Rebuild an unresolved typename type, given the decl that
477 /// the UnresolvedUsingTypenameDecl was transformed to.
478 QualType RebuildUnresolvedUsingType(Decl *D);
480 /// \brief Build a new typedef type.
481 QualType RebuildTypedefType(TypedefDecl *Typedef) {
482 return SemaRef.Context.getTypeDeclType(Typedef);
485 /// \brief Build a new class/struct/union type.
486 QualType RebuildRecordType(RecordDecl *Record) {
487 return SemaRef.Context.getTypeDeclType(Record);
490 /// \brief Build a new Enum type.
491 QualType RebuildEnumType(EnumDecl *Enum) {
492 return SemaRef.Context.getTypeDeclType(Enum);
495 /// \brief Build a new typeof(expr) type.
497 /// By default, performs semantic analysis when building the typeof type.
498 /// Subclasses may override this routine to provide different behavior.
499 QualType RebuildTypeOfExprType(ExprArg Underlying);
501 /// \brief Build a new typeof(type) type.
503 /// By default, builds a new TypeOfType with the given underlying type.
504 QualType RebuildTypeOfType(QualType Underlying);
506 /// \brief Build a new C++0x decltype type.
508 /// By default, performs semantic analysis when building the decltype type.
509 /// Subclasses may override this routine to provide different behavior.
510 QualType RebuildDecltypeType(ExprArg Underlying);
512 /// \brief Build a new template specialization type.
514 /// By default, performs semantic analysis when building the template
515 /// specialization type. Subclasses may override this routine to provide
516 /// different behavior.
517 QualType RebuildTemplateSpecializationType(TemplateName Template,
518 SourceLocation TemplateLoc,
519 const TemplateArgumentListInfo &Args);
521 /// \brief Build a new qualified name type.
523 /// By default, builds a new ElaboratedType type from the keyword,
524 /// the nested-name-specifier and the named type.
525 /// Subclasses may override this routine to provide different behavior.
526 QualType RebuildElaboratedType(ElaboratedTypeKeyword Keyword,
527 NestedNameSpecifier *NNS, QualType Named) {
528 return SemaRef.Context.getElaboratedType(Keyword, NNS, Named);
531 /// \brief Build a new typename type that refers to a template-id.
533 /// By default, builds a new DependentNameType type from the
534 /// nested-name-specifier and the given type. Subclasses may override
535 /// this routine to provide different behavior.
536 QualType RebuildDependentTemplateSpecializationType(
537 ElaboratedTypeKeyword Keyword,
538 NestedNameSpecifier *NNS,
539 const IdentifierInfo *Name,
540 SourceLocation NameLoc,
541 const TemplateArgumentListInfo &Args) {
542 // Rebuild the template name.
543 // TODO: avoid TemplateName abstraction
544 TemplateName InstName =
545 getDerived().RebuildTemplateName(NNS, *Name, QualType());
547 if (InstName.isNull())
550 // If it's still dependent, make a dependent specialization.
551 if (InstName.getAsDependentTemplateName())
552 return SemaRef.Context.getDependentTemplateSpecializationType(
553 Keyword, NNS, Name, Args);
555 // Otherwise, make an elaborated type wrapping a non-dependent
558 getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
559 if (T.isNull()) return QualType();
561 return SemaRef.Context.getElaboratedType(Keyword, NNS, T);
564 /// \brief Build a new typename type that refers to an identifier.
566 /// By default, performs semantic analysis when building the typename type
567 /// (or elaborated type). Subclasses may override this routine to provide
568 /// different behavior.
569 QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword,
570 NestedNameSpecifier *NNS,
571 const IdentifierInfo *Id,
572 SourceLocation KeywordLoc,
573 SourceRange NNSRange,
574 SourceLocation IdLoc) {
577 SS.setRange(NNSRange);
579 if (NNS->isDependent()) {
580 // If the name is still dependent, just build a new dependent name type.
581 if (!SemaRef.computeDeclContext(SS))
582 return SemaRef.Context.getDependentNameType(Keyword, NNS, Id);
585 if (Keyword == ETK_None || Keyword == ETK_Typename)
586 return SemaRef.CheckTypenameType(Keyword, NNS, *Id,
587 KeywordLoc, NNSRange, IdLoc);
589 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
591 // We had a dependent elaborated-type-specifier that has been transformed
592 // into a non-dependent elaborated-type-specifier. Find the tag we're
594 LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
595 DeclContext *DC = SemaRef.computeDeclContext(SS, false);
599 if (SemaRef.RequireCompleteDeclContext(SS, DC))
603 SemaRef.LookupQualifiedName(Result, DC);
604 switch (Result.getResultKind()) {
605 case LookupResult::NotFound:
606 case LookupResult::NotFoundInCurrentInstantiation:
609 case LookupResult::Found:
610 Tag = Result.getAsSingle<TagDecl>();
613 case LookupResult::FoundOverloaded:
614 case LookupResult::FoundUnresolvedValue:
615 llvm_unreachable("Tag lookup cannot find non-tags");
618 case LookupResult::Ambiguous:
619 // Let the LookupResult structure handle ambiguities.
624 // FIXME: Would be nice to highlight just the source range.
625 SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope)
630 if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind, IdLoc, *Id)) {
631 SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id;
632 SemaRef.Diag(Tag->getLocation(), diag::note_previous_use);
636 // Build the elaborated-type-specifier type.
637 QualType T = SemaRef.Context.getTypeDeclType(Tag);
638 return SemaRef.Context.getElaboratedType(Keyword, NNS, T);
641 /// \brief Build a new nested-name-specifier given the prefix and an
642 /// identifier that names the next step in the nested-name-specifier.
644 /// By default, performs semantic analysis when building the new
645 /// nested-name-specifier. Subclasses may override this routine to provide
646 /// different behavior.
647 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
651 NamedDecl *FirstQualifierInScope);
653 /// \brief Build a new nested-name-specifier given the prefix and the
654 /// namespace named in the next step in the nested-name-specifier.
656 /// By default, performs semantic analysis when building the new
657 /// nested-name-specifier. Subclasses may override this routine to provide
658 /// different behavior.
659 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
663 /// \brief Build a new nested-name-specifier given the prefix and the
664 /// type named in the next step in the nested-name-specifier.
666 /// By default, performs semantic analysis when building the new
667 /// nested-name-specifier. Subclasses may override this routine to provide
668 /// different behavior.
669 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
674 /// \brief Build a new template name given a nested name specifier, a flag
675 /// indicating whether the "template" keyword was provided, and the template
676 /// that the template name refers to.
678 /// By default, builds the new template name directly. Subclasses may override
679 /// this routine to provide different behavior.
680 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier,
682 TemplateDecl *Template);
684 /// \brief Build a new template name given a nested name specifier and the
685 /// name that is referred to as a template.
687 /// By default, performs semantic analysis to determine whether the name can
688 /// be resolved to a specific template, then builds the appropriate kind of
689 /// template name. Subclasses may override this routine to provide different
691 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier,
692 const IdentifierInfo &II,
693 QualType ObjectType);
695 /// \brief Build a new template name given a nested name specifier and the
696 /// overloaded operator name that is referred to as a template.
698 /// By default, performs semantic analysis to determine whether the name can
699 /// be resolved to a specific template, then builds the appropriate kind of
700 /// template name. Subclasses may override this routine to provide different
702 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier,
703 OverloadedOperatorKind Operator,
704 QualType ObjectType);
706 /// \brief Build a new compound statement.
708 /// By default, performs semantic analysis to build the new statement.
709 /// Subclasses may override this routine to provide different behavior.
710 OwningStmtResult RebuildCompoundStmt(SourceLocation LBraceLoc,
711 MultiStmtArg Statements,
712 SourceLocation RBraceLoc,
714 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, move(Statements),
718 /// \brief Build a new case statement.
720 /// By default, performs semantic analysis to build the new statement.
721 /// Subclasses may override this routine to provide different behavior.
722 OwningStmtResult RebuildCaseStmt(SourceLocation CaseLoc,
724 SourceLocation EllipsisLoc,
726 SourceLocation ColonLoc) {
727 return getSema().ActOnCaseStmt(CaseLoc, move(LHS), EllipsisLoc, move(RHS),
731 /// \brief Attach the body to a new case statement.
733 /// By default, performs semantic analysis to build the new statement.
734 /// Subclasses may override this routine to provide different behavior.
735 OwningStmtResult RebuildCaseStmtBody(StmtArg S, StmtArg Body) {
736 getSema().ActOnCaseStmtBody(S.get(), move(Body));
740 /// \brief Build a new default statement.
742 /// By default, performs semantic analysis to build the new statement.
743 /// Subclasses may override this routine to provide different behavior.
744 OwningStmtResult RebuildDefaultStmt(SourceLocation DefaultLoc,
745 SourceLocation ColonLoc,
747 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, move(SubStmt),
751 /// \brief Build a new label statement.
753 /// By default, performs semantic analysis to build the new statement.
754 /// Subclasses may override this routine to provide different behavior.
755 OwningStmtResult RebuildLabelStmt(SourceLocation IdentLoc,
757 SourceLocation ColonLoc,
759 return SemaRef.ActOnLabelStmt(IdentLoc, Id, ColonLoc, move(SubStmt));
762 /// \brief Build a new "if" statement.
764 /// By default, performs semantic analysis to build the new statement.
765 /// Subclasses may override this routine to provide different behavior.
766 OwningStmtResult RebuildIfStmt(SourceLocation IfLoc, Sema::FullExprArg Cond,
767 VarDecl *CondVar, StmtArg Then,
768 SourceLocation ElseLoc, StmtArg Else) {
769 return getSema().ActOnIfStmt(IfLoc, Cond, DeclPtrTy::make(CondVar),
770 move(Then), ElseLoc, move(Else));
773 /// \brief Start building a new switch statement.
775 /// By default, performs semantic analysis to build the new statement.
776 /// Subclasses may override this routine to provide different behavior.
777 OwningStmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc,
780 return getSema().ActOnStartOfSwitchStmt(SwitchLoc, move(Cond),
781 DeclPtrTy::make(CondVar));
784 /// \brief Attach the body to the switch statement.
786 /// By default, performs semantic analysis to build the new statement.
787 /// Subclasses may override this routine to provide different behavior.
788 OwningStmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc,
789 StmtArg Switch, StmtArg Body) {
790 return getSema().ActOnFinishSwitchStmt(SwitchLoc, move(Switch),
794 /// \brief Build a new while statement.
796 /// By default, performs semantic analysis to build the new statement.
797 /// Subclasses may override this routine to provide different behavior.
798 OwningStmtResult RebuildWhileStmt(SourceLocation WhileLoc,
799 Sema::FullExprArg Cond,
802 return getSema().ActOnWhileStmt(WhileLoc, Cond,
803 DeclPtrTy::make(CondVar), move(Body));
806 /// \brief Build a new do-while statement.
808 /// By default, performs semantic analysis to build the new statement.
809 /// Subclasses may override this routine to provide different behavior.
810 OwningStmtResult RebuildDoStmt(SourceLocation DoLoc, StmtArg Body,
811 SourceLocation WhileLoc,
812 SourceLocation LParenLoc,
814 SourceLocation RParenLoc) {
815 return getSema().ActOnDoStmt(DoLoc, move(Body), WhileLoc, LParenLoc,
816 move(Cond), RParenLoc);
819 /// \brief Build a new for statement.
821 /// By default, performs semantic analysis to build the new statement.
822 /// Subclasses may override this routine to provide different behavior.
823 OwningStmtResult RebuildForStmt(SourceLocation ForLoc,
824 SourceLocation LParenLoc,
825 StmtArg Init, Sema::FullExprArg Cond,
826 VarDecl *CondVar, Sema::FullExprArg Inc,
827 SourceLocation RParenLoc, StmtArg Body) {
828 return getSema().ActOnForStmt(ForLoc, LParenLoc, move(Init), Cond,
829 DeclPtrTy::make(CondVar),
830 Inc, RParenLoc, move(Body));
833 /// \brief Build a new goto statement.
835 /// By default, performs semantic analysis to build the new statement.
836 /// Subclasses may override this routine to provide different behavior.
837 OwningStmtResult RebuildGotoStmt(SourceLocation GotoLoc,
838 SourceLocation LabelLoc,
840 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label->getID());
843 /// \brief Build a new indirect goto statement.
845 /// By default, performs semantic analysis to build the new statement.
846 /// Subclasses may override this routine to provide different behavior.
847 OwningStmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc,
848 SourceLocation StarLoc,
850 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, move(Target));
853 /// \brief Build a new return statement.
855 /// By default, performs semantic analysis to build the new statement.
856 /// Subclasses may override this routine to provide different behavior.
857 OwningStmtResult RebuildReturnStmt(SourceLocation ReturnLoc,
860 return getSema().ActOnReturnStmt(ReturnLoc, move(Result));
863 /// \brief Build a new declaration statement.
865 /// By default, performs semantic analysis to build the new statement.
866 /// Subclasses may override this routine to provide different behavior.
867 OwningStmtResult RebuildDeclStmt(Decl **Decls, unsigned NumDecls,
868 SourceLocation StartLoc,
869 SourceLocation EndLoc) {
870 return getSema().Owned(
871 new (getSema().Context) DeclStmt(
872 DeclGroupRef::Create(getSema().Context,
877 /// \brief Build a new inline asm statement.
879 /// By default, performs semantic analysis to build the new statement.
880 /// Subclasses may override this routine to provide different behavior.
881 OwningStmtResult RebuildAsmStmt(SourceLocation AsmLoc,
886 IdentifierInfo **Names,
887 MultiExprArg Constraints,
890 MultiExprArg Clobbers,
891 SourceLocation RParenLoc,
893 return getSema().ActOnAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
894 NumInputs, Names, move(Constraints),
895 move(Exprs), move(AsmString), move(Clobbers),
899 /// \brief Build a new Objective-C @try statement.
901 /// By default, performs semantic analysis to build the new statement.
902 /// Subclasses may override this routine to provide different behavior.
903 OwningStmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc,
905 MultiStmtArg CatchStmts,
907 return getSema().ActOnObjCAtTryStmt(AtLoc, move(TryBody), move(CatchStmts),
911 /// \brief Rebuild an Objective-C exception declaration.
913 /// By default, performs semantic analysis to build the new declaration.
914 /// Subclasses may override this routine to provide different behavior.
915 VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
916 TypeSourceInfo *TInfo, QualType T) {
917 return getSema().BuildObjCExceptionDecl(TInfo, T,
918 ExceptionDecl->getIdentifier(),
919 ExceptionDecl->getLocation());
922 /// \brief Build a new Objective-C @catch statement.
924 /// By default, performs semantic analysis to build the new statement.
925 /// Subclasses may override this routine to provide different behavior.
926 OwningStmtResult RebuildObjCAtCatchStmt(SourceLocation AtLoc,
927 SourceLocation RParenLoc,
930 return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
931 Sema::DeclPtrTy::make(Var),
935 /// \brief Build a new Objective-C @finally statement.
937 /// By default, performs semantic analysis to build the new statement.
938 /// Subclasses may override this routine to provide different behavior.
939 OwningStmtResult RebuildObjCAtFinallyStmt(SourceLocation AtLoc,
941 return getSema().ActOnObjCAtFinallyStmt(AtLoc, move(Body));
944 /// \brief Build a new Objective-C @throw statement.
946 /// By default, performs semantic analysis to build the new statement.
947 /// Subclasses may override this routine to provide different behavior.
948 OwningStmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc,
950 return getSema().BuildObjCAtThrowStmt(AtLoc, move(Operand));
953 /// \brief Build a new Objective-C @synchronized statement.
955 /// By default, performs semantic analysis to build the new statement.
956 /// Subclasses may override this routine to provide different behavior.
957 OwningStmtResult RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc,
960 return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, move(Object),
964 /// \brief Build a new Objective-C fast enumeration statement.
966 /// By default, performs semantic analysis to build the new statement.
967 /// Subclasses may override this routine to provide different behavior.
968 OwningStmtResult RebuildObjCForCollectionStmt(SourceLocation ForLoc,
969 SourceLocation LParenLoc,
972 SourceLocation RParenLoc,
974 return getSema().ActOnObjCForCollectionStmt(ForLoc, LParenLoc,
981 /// \brief Build a new C++ exception declaration.
983 /// By default, performs semantic analysis to build the new decaration.
984 /// Subclasses may override this routine to provide different behavior.
985 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl, QualType T,
986 TypeSourceInfo *Declarator,
987 IdentifierInfo *Name,
989 SourceRange TypeRange) {
990 return getSema().BuildExceptionDeclaration(0, T, Declarator, Name, Loc,
994 /// \brief Build a new C++ catch statement.
996 /// By default, performs semantic analysis to build the new statement.
997 /// Subclasses may override this routine to provide different behavior.
998 OwningStmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc,
999 VarDecl *ExceptionDecl,
1001 return getSema().Owned(
1002 new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl,
1003 Handler.takeAs<Stmt>()));
1006 /// \brief Build a new C++ try statement.
1008 /// By default, performs semantic analysis to build the new statement.
1009 /// Subclasses may override this routine to provide different behavior.
1010 OwningStmtResult RebuildCXXTryStmt(SourceLocation TryLoc,
1012 MultiStmtArg Handlers) {
1013 return getSema().ActOnCXXTryBlock(TryLoc, move(TryBlock), move(Handlers));
1016 /// \brief Build a new expression that references a declaration.
1018 /// By default, performs semantic analysis to build the new expression.
1019 /// Subclasses may override this routine to provide different behavior.
1020 OwningExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS,
1023 return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
1027 /// \brief Build a new expression that references a declaration.
1029 /// By default, performs semantic analysis to build the new expression.
1030 /// Subclasses may override this routine to provide different behavior.
1031 OwningExprResult RebuildDeclRefExpr(NestedNameSpecifier *Qualifier,
1032 SourceRange QualifierRange,
1033 ValueDecl *VD, SourceLocation Loc,
1034 TemplateArgumentListInfo *TemplateArgs) {
1036 SS.setScopeRep(Qualifier);
1037 SS.setRange(QualifierRange);
1039 // FIXME: loses template args.
1041 return getSema().BuildDeclarationNameExpr(SS, Loc, VD);
1044 /// \brief Build a new expression in parentheses.
1046 /// By default, performs semantic analysis to build the new expression.
1047 /// Subclasses may override this routine to provide different behavior.
1048 OwningExprResult RebuildParenExpr(ExprArg SubExpr, SourceLocation LParen,
1049 SourceLocation RParen) {
1050 return getSema().ActOnParenExpr(LParen, RParen, move(SubExpr));
1053 /// \brief Build a new pseudo-destructor expression.
1055 /// By default, performs semantic analysis to build the new expression.
1056 /// Subclasses may override this routine to provide different behavior.
1057 OwningExprResult RebuildCXXPseudoDestructorExpr(ExprArg Base,
1058 SourceLocation OperatorLoc,
1060 NestedNameSpecifier *Qualifier,
1061 SourceRange QualifierRange,
1062 TypeSourceInfo *ScopeType,
1063 SourceLocation CCLoc,
1064 SourceLocation TildeLoc,
1065 PseudoDestructorTypeStorage Destroyed);
1067 /// \brief Build a new unary operator expression.
1069 /// By default, performs semantic analysis to build the new expression.
1070 /// Subclasses may override this routine to provide different behavior.
1071 OwningExprResult RebuildUnaryOperator(SourceLocation OpLoc,
1072 UnaryOperator::Opcode Opc,
1074 return getSema().BuildUnaryOp(/*Scope=*/0, OpLoc, Opc, move(SubExpr));
1077 /// \brief Build a new builtin offsetof expression.
1079 /// By default, performs semantic analysis to build the new expression.
1080 /// Subclasses may override this routine to provide different behavior.
1081 OwningExprResult RebuildOffsetOfExpr(SourceLocation OperatorLoc,
1082 TypeSourceInfo *Type,
1083 Action::OffsetOfComponent *Components,
1084 unsigned NumComponents,
1085 SourceLocation RParenLoc) {
1086 return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
1087 NumComponents, RParenLoc);
1090 /// \brief Build a new sizeof or alignof expression with a type argument.
1092 /// By default, performs semantic analysis to build the new expression.
1093 /// Subclasses may override this routine to provide different behavior.
1094 OwningExprResult RebuildSizeOfAlignOf(TypeSourceInfo *TInfo,
1095 SourceLocation OpLoc,
1096 bool isSizeOf, SourceRange R) {
1097 return getSema().CreateSizeOfAlignOfExpr(TInfo, OpLoc, isSizeOf, R);
1100 /// \brief Build a new sizeof or alignof expression with an expression
1103 /// By default, performs semantic analysis to build the new expression.
1104 /// Subclasses may override this routine to provide different behavior.
1105 OwningExprResult RebuildSizeOfAlignOf(ExprArg SubExpr, SourceLocation OpLoc,
1106 bool isSizeOf, SourceRange R) {
1107 OwningExprResult Result
1108 = getSema().CreateSizeOfAlignOfExpr((Expr *)SubExpr.get(),
1109 OpLoc, isSizeOf, R);
1110 if (Result.isInvalid())
1111 return getSema().ExprError();
1114 return move(Result);
1117 /// \brief Build a new array subscript expression.
1119 /// By default, performs semantic analysis to build the new expression.
1120 /// Subclasses may override this routine to provide different behavior.
1121 OwningExprResult RebuildArraySubscriptExpr(ExprArg LHS,
1122 SourceLocation LBracketLoc,
1124 SourceLocation RBracketLoc) {
1125 return getSema().ActOnArraySubscriptExpr(/*Scope=*/0, move(LHS),
1126 LBracketLoc, move(RHS),
1130 /// \brief Build a new call expression.
1132 /// By default, performs semantic analysis to build the new expression.
1133 /// Subclasses may override this routine to provide different behavior.
1134 OwningExprResult RebuildCallExpr(ExprArg Callee, SourceLocation LParenLoc,
1136 SourceLocation *CommaLocs,
1137 SourceLocation RParenLoc) {
1138 return getSema().ActOnCallExpr(/*Scope=*/0, move(Callee), LParenLoc,
1139 move(Args), CommaLocs, RParenLoc);
1142 /// \brief Build a new member access expression.
1144 /// By default, performs semantic analysis to build the new expression.
1145 /// Subclasses may override this routine to provide different behavior.
1146 OwningExprResult RebuildMemberExpr(ExprArg Base, SourceLocation OpLoc,
1148 NestedNameSpecifier *Qualifier,
1149 SourceRange QualifierRange,
1150 SourceLocation MemberLoc,
1152 NamedDecl *FoundDecl,
1153 const TemplateArgumentListInfo *ExplicitTemplateArgs,
1154 NamedDecl *FirstQualifierInScope) {
1155 if (!Member->getDeclName()) {
1156 // We have a reference to an unnamed field.
1157 assert(!Qualifier && "Can't have an unnamed field with a qualifier!");
1159 Expr *BaseExpr = Base.takeAs<Expr>();
1160 if (getSema().PerformObjectMemberConversion(BaseExpr, Qualifier,
1162 return getSema().ExprError();
1165 new (getSema().Context) MemberExpr(BaseExpr, isArrow,
1167 cast<FieldDecl>(Member)->getType());
1168 return getSema().Owned(ME);
1173 SS.setRange(QualifierRange);
1174 SS.setScopeRep(Qualifier);
1177 Expr *BaseExpr = Base.takeAs<Expr>();
1178 getSema().DefaultFunctionArrayConversion(BaseExpr);
1179 QualType BaseType = BaseExpr->getType();
1181 // FIXME: this involves duplicating earlier analysis in a lot of
1182 // cases; we should avoid this when possible.
1183 LookupResult R(getSema(), Member->getDeclName(), MemberLoc,
1184 Sema::LookupMemberName);
1185 R.addDecl(FoundDecl);
1188 return getSema().BuildMemberReferenceExpr(getSema().Owned(BaseExpr),
1189 BaseType, OpLoc, isArrow,
1190 SS, FirstQualifierInScope,
1191 R, ExplicitTemplateArgs);
1194 /// \brief Build a new binary operator expression.
1196 /// By default, performs semantic analysis to build the new expression.
1197 /// Subclasses may override this routine to provide different behavior.
1198 OwningExprResult RebuildBinaryOperator(SourceLocation OpLoc,
1199 BinaryOperator::Opcode Opc,
1200 ExprArg LHS, ExprArg RHS) {
1201 return getSema().BuildBinOp(/*Scope=*/0, OpLoc, Opc,
1202 LHS.takeAs<Expr>(), RHS.takeAs<Expr>());
1205 /// \brief Build a new conditional operator expression.
1207 /// By default, performs semantic analysis to build the new expression.
1208 /// Subclasses may override this routine to provide different behavior.
1209 OwningExprResult RebuildConditionalOperator(ExprArg Cond,
1210 SourceLocation QuestionLoc,
1212 SourceLocation ColonLoc,
1214 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, move(Cond),
1215 move(LHS), move(RHS));
1218 /// \brief Build a new C-style cast expression.
1220 /// By default, performs semantic analysis to build the new expression.
1221 /// Subclasses may override this routine to provide different behavior.
1222 OwningExprResult RebuildCStyleCastExpr(SourceLocation LParenLoc,
1223 TypeSourceInfo *TInfo,
1224 SourceLocation RParenLoc,
1226 return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
1230 /// \brief Build a new compound literal expression.
1232 /// By default, performs semantic analysis to build the new expression.
1233 /// Subclasses may override this routine to provide different behavior.
1234 OwningExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc,
1235 TypeSourceInfo *TInfo,
1236 SourceLocation RParenLoc,
1238 return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
1242 /// \brief Build a new extended vector element access expression.
1244 /// By default, performs semantic analysis to build the new expression.
1245 /// Subclasses may override this routine to provide different behavior.
1246 OwningExprResult RebuildExtVectorElementExpr(ExprArg Base,
1247 SourceLocation OpLoc,
1248 SourceLocation AccessorLoc,
1249 IdentifierInfo &Accessor) {
1252 QualType BaseType = ((Expr*) Base.get())->getType();
1253 return getSema().BuildMemberReferenceExpr(move(Base), BaseType,
1254 OpLoc, /*IsArrow*/ false,
1255 SS, /*FirstQualifierInScope*/ 0,
1256 DeclarationName(&Accessor),
1258 /* TemplateArgs */ 0);
1261 /// \brief Build a new initializer list expression.
1263 /// By default, performs semantic analysis to build the new expression.
1264 /// Subclasses may override this routine to provide different behavior.
1265 OwningExprResult RebuildInitList(SourceLocation LBraceLoc,
1267 SourceLocation RBraceLoc,
1268 QualType ResultTy) {
1269 OwningExprResult Result
1270 = SemaRef.ActOnInitList(LBraceLoc, move(Inits), RBraceLoc);
1271 if (Result.isInvalid() || ResultTy->isDependentType())
1272 return move(Result);
1274 // Patch in the result type we were given, which may have been computed
1275 // when the initial InitListExpr was built.
1276 InitListExpr *ILE = cast<InitListExpr>((Expr *)Result.get());
1277 ILE->setType(ResultTy);
1278 return move(Result);
1281 /// \brief Build a new designated initializer expression.
1283 /// By default, performs semantic analysis to build the new expression.
1284 /// Subclasses may override this routine to provide different behavior.
1285 OwningExprResult RebuildDesignatedInitExpr(Designation &Desig,
1286 MultiExprArg ArrayExprs,
1287 SourceLocation EqualOrColonLoc,
1290 OwningExprResult Result
1291 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
1293 if (Result.isInvalid())
1294 return SemaRef.ExprError();
1296 ArrayExprs.release();
1297 return move(Result);
1300 /// \brief Build a new value-initialized expression.
1302 /// By default, builds the implicit value initialization without performing
1303 /// any semantic analysis. Subclasses may override this routine to provide
1304 /// different behavior.
1305 OwningExprResult RebuildImplicitValueInitExpr(QualType T) {
1306 return SemaRef.Owned(new (SemaRef.Context) ImplicitValueInitExpr(T));
1309 /// \brief Build a new \c va_arg expression.
1311 /// By default, performs semantic analysis to build the new expression.
1312 /// Subclasses may override this routine to provide different behavior.
1313 OwningExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc, ExprArg SubExpr,
1314 QualType T, SourceLocation RParenLoc) {
1315 return getSema().ActOnVAArg(BuiltinLoc, move(SubExpr), T.getAsOpaquePtr(),
1319 /// \brief Build a new expression list in parentheses.
1321 /// By default, performs semantic analysis to build the new expression.
1322 /// Subclasses may override this routine to provide different behavior.
1323 OwningExprResult RebuildParenListExpr(SourceLocation LParenLoc,
1324 MultiExprArg SubExprs,
1325 SourceLocation RParenLoc) {
1326 return getSema().ActOnParenOrParenListExpr(LParenLoc, RParenLoc,
1330 /// \brief Build a new address-of-label expression.
1332 /// By default, performs semantic analysis, using the name of the label
1333 /// rather than attempting to map the label statement itself.
1334 /// Subclasses may override this routine to provide different behavior.
1335 OwningExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc,
1336 SourceLocation LabelLoc,
1338 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label->getID());
1341 /// \brief Build a new GNU statement expression.
1343 /// By default, performs semantic analysis to build the new expression.
1344 /// Subclasses may override this routine to provide different behavior.
1345 OwningExprResult RebuildStmtExpr(SourceLocation LParenLoc,
1347 SourceLocation RParenLoc) {
1348 return getSema().ActOnStmtExpr(LParenLoc, move(SubStmt), RParenLoc);
1351 /// \brief Build a new __builtin_types_compatible_p expression.
1353 /// By default, performs semantic analysis to build the new expression.
1354 /// Subclasses may override this routine to provide different behavior.
1355 OwningExprResult RebuildTypesCompatibleExpr(SourceLocation BuiltinLoc,
1356 QualType T1, QualType T2,
1357 SourceLocation RParenLoc) {
1358 return getSema().ActOnTypesCompatibleExpr(BuiltinLoc,
1359 T1.getAsOpaquePtr(),
1360 T2.getAsOpaquePtr(),
1364 /// \brief Build a new __builtin_choose_expr expression.
1366 /// By default, performs semantic analysis to build the new expression.
1367 /// Subclasses may override this routine to provide different behavior.
1368 OwningExprResult RebuildChooseExpr(SourceLocation BuiltinLoc,
1369 ExprArg Cond, ExprArg LHS, ExprArg RHS,
1370 SourceLocation RParenLoc) {
1371 return SemaRef.ActOnChooseExpr(BuiltinLoc,
1372 move(Cond), move(LHS), move(RHS),
1376 /// \brief Build a new overloaded operator call expression.
1378 /// By default, performs semantic analysis to build the new expression.
1379 /// The semantic analysis provides the behavior of template instantiation,
1380 /// copying with transformations that turn what looks like an overloaded
1381 /// operator call into a use of a builtin operator, performing
1382 /// argument-dependent lookup, etc. Subclasses may override this routine to
1383 /// provide different behavior.
1384 OwningExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
1385 SourceLocation OpLoc,
1390 /// \brief Build a new C++ "named" cast expression, such as static_cast or
1391 /// reinterpret_cast.
1393 /// By default, this routine dispatches to one of the more-specific routines
1394 /// for a particular named case, e.g., RebuildCXXStaticCastExpr().
1395 /// Subclasses may override this routine to provide different behavior.
1396 OwningExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc,
1397 Stmt::StmtClass Class,
1398 SourceLocation LAngleLoc,
1399 TypeSourceInfo *TInfo,
1400 SourceLocation RAngleLoc,
1401 SourceLocation LParenLoc,
1403 SourceLocation RParenLoc) {
1405 case Stmt::CXXStaticCastExprClass:
1406 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
1407 RAngleLoc, LParenLoc,
1408 move(SubExpr), RParenLoc);
1410 case Stmt::CXXDynamicCastExprClass:
1411 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
1412 RAngleLoc, LParenLoc,
1413 move(SubExpr), RParenLoc);
1415 case Stmt::CXXReinterpretCastExprClass:
1416 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
1417 RAngleLoc, LParenLoc,
1421 case Stmt::CXXConstCastExprClass:
1422 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
1423 RAngleLoc, LParenLoc,
1424 move(SubExpr), RParenLoc);
1427 assert(false && "Invalid C++ named cast");
1431 return getSema().ExprError();
1434 /// \brief Build a new C++ static_cast expression.
1436 /// By default, performs semantic analysis to build the new expression.
1437 /// Subclasses may override this routine to provide different behavior.
1438 OwningExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc,
1439 SourceLocation LAngleLoc,
1440 TypeSourceInfo *TInfo,
1441 SourceLocation RAngleLoc,
1442 SourceLocation LParenLoc,
1444 SourceLocation RParenLoc) {
1445 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
1446 TInfo, move(SubExpr),
1447 SourceRange(LAngleLoc, RAngleLoc),
1448 SourceRange(LParenLoc, RParenLoc));
1451 /// \brief Build a new C++ dynamic_cast expression.
1453 /// By default, performs semantic analysis to build the new expression.
1454 /// Subclasses may override this routine to provide different behavior.
1455 OwningExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc,
1456 SourceLocation LAngleLoc,
1457 TypeSourceInfo *TInfo,
1458 SourceLocation RAngleLoc,
1459 SourceLocation LParenLoc,
1461 SourceLocation RParenLoc) {
1462 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
1463 TInfo, move(SubExpr),
1464 SourceRange(LAngleLoc, RAngleLoc),
1465 SourceRange(LParenLoc, RParenLoc));
1468 /// \brief Build a new C++ reinterpret_cast expression.
1470 /// By default, performs semantic analysis to build the new expression.
1471 /// Subclasses may override this routine to provide different behavior.
1472 OwningExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc,
1473 SourceLocation LAngleLoc,
1474 TypeSourceInfo *TInfo,
1475 SourceLocation RAngleLoc,
1476 SourceLocation LParenLoc,
1478 SourceLocation RParenLoc) {
1479 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
1480 TInfo, move(SubExpr),
1481 SourceRange(LAngleLoc, RAngleLoc),
1482 SourceRange(LParenLoc, RParenLoc));
1485 /// \brief Build a new C++ const_cast expression.
1487 /// By default, performs semantic analysis to build the new expression.
1488 /// Subclasses may override this routine to provide different behavior.
1489 OwningExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc,
1490 SourceLocation LAngleLoc,
1491 TypeSourceInfo *TInfo,
1492 SourceLocation RAngleLoc,
1493 SourceLocation LParenLoc,
1495 SourceLocation RParenLoc) {
1496 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
1497 TInfo, move(SubExpr),
1498 SourceRange(LAngleLoc, RAngleLoc),
1499 SourceRange(LParenLoc, RParenLoc));
1502 /// \brief Build a new C++ functional-style cast expression.
1504 /// By default, performs semantic analysis to build the new expression.
1505 /// Subclasses may override this routine to provide different behavior.
1506 OwningExprResult RebuildCXXFunctionalCastExpr(SourceRange TypeRange,
1507 TypeSourceInfo *TInfo,
1508 SourceLocation LParenLoc,
1510 SourceLocation RParenLoc) {
1511 void *Sub = SubExpr.takeAs<Expr>();
1512 return getSema().ActOnCXXTypeConstructExpr(TypeRange,
1513 TInfo->getType().getAsOpaquePtr(),
1515 Sema::MultiExprArg(getSema(), &Sub, 1),
1520 /// \brief Build a new C++ typeid(type) expression.
1522 /// By default, performs semantic analysis to build the new expression.
1523 /// Subclasses may override this routine to provide different behavior.
1524 OwningExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
1525 SourceLocation TypeidLoc,
1526 TypeSourceInfo *Operand,
1527 SourceLocation RParenLoc) {
1528 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
1532 /// \brief Build a new C++ typeid(expr) expression.
1534 /// By default, performs semantic analysis to build the new expression.
1535 /// Subclasses may override this routine to provide different behavior.
1536 OwningExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
1537 SourceLocation TypeidLoc,
1539 SourceLocation RParenLoc) {
1540 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, move(Operand),
1544 /// \brief Build a new C++ "this" expression.
1546 /// By default, builds a new "this" expression without performing any
1547 /// semantic analysis. Subclasses may override this routine to provide
1548 /// different behavior.
1549 OwningExprResult RebuildCXXThisExpr(SourceLocation ThisLoc,
1552 return getSema().Owned(
1553 new (getSema().Context) CXXThisExpr(ThisLoc, ThisType,
1557 /// \brief Build a new C++ throw expression.
1559 /// By default, performs semantic analysis to build the new expression.
1560 /// Subclasses may override this routine to provide different behavior.
1561 OwningExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, ExprArg Sub) {
1562 return getSema().ActOnCXXThrow(ThrowLoc, move(Sub));
1565 /// \brief Build a new C++ default-argument expression.
1567 /// By default, builds a new default-argument expression, which does not
1568 /// require any semantic analysis. Subclasses may override this routine to
1569 /// provide different behavior.
1570 OwningExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc,
1571 ParmVarDecl *Param) {
1572 return getSema().Owned(CXXDefaultArgExpr::Create(getSema().Context, Loc,
1576 /// \brief Build a new C++ zero-initialization expression.
1578 /// By default, performs semantic analysis to build the new expression.
1579 /// Subclasses may override this routine to provide different behavior.
1580 OwningExprResult RebuildCXXScalarValueInitExpr(SourceLocation TypeStartLoc,
1581 SourceLocation LParenLoc,
1583 SourceLocation RParenLoc) {
1584 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeStartLoc),
1585 T.getAsOpaquePtr(), LParenLoc,
1586 MultiExprArg(getSema(), 0, 0),
1590 /// \brief Build a new C++ "new" expression.
1592 /// By default, performs semantic analysis to build the new expression.
1593 /// Subclasses may override this routine to provide different behavior.
1594 OwningExprResult RebuildCXXNewExpr(SourceLocation StartLoc,
1596 SourceLocation PlacementLParen,
1597 MultiExprArg PlacementArgs,
1598 SourceLocation PlacementRParen,
1599 SourceRange TypeIdParens,
1601 SourceLocation TypeLoc,
1602 SourceRange TypeRange,
1604 SourceLocation ConstructorLParen,
1605 MultiExprArg ConstructorArgs,
1606 SourceLocation ConstructorRParen) {
1607 return getSema().BuildCXXNew(StartLoc, UseGlobal,
1609 move(PlacementArgs),
1617 move(ConstructorArgs),
1621 /// \brief Build a new C++ "delete" expression.
1623 /// By default, performs semantic analysis to build the new expression.
1624 /// Subclasses may override this routine to provide different behavior.
1625 OwningExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc,
1626 bool IsGlobalDelete,
1629 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
1633 /// \brief Build a new unary type trait expression.
1635 /// By default, performs semantic analysis to build the new expression.
1636 /// Subclasses may override this routine to provide different behavior.
1637 OwningExprResult RebuildUnaryTypeTrait(UnaryTypeTrait Trait,
1638 SourceLocation StartLoc,
1639 SourceLocation LParenLoc,
1641 SourceLocation RParenLoc) {
1642 return getSema().ActOnUnaryTypeTrait(Trait, StartLoc, LParenLoc,
1643 T.getAsOpaquePtr(), RParenLoc);
1646 /// \brief Build a new (previously unresolved) declaration reference
1649 /// By default, performs semantic analysis to build the new expression.
1650 /// Subclasses may override this routine to provide different behavior.
1651 OwningExprResult RebuildDependentScopeDeclRefExpr(NestedNameSpecifier *NNS,
1652 SourceRange QualifierRange,
1653 DeclarationName Name,
1654 SourceLocation Location,
1655 const TemplateArgumentListInfo *TemplateArgs) {
1657 SS.setRange(QualifierRange);
1658 SS.setScopeRep(NNS);
1661 return getSema().BuildQualifiedTemplateIdExpr(SS, Name, Location,
1664 return getSema().BuildQualifiedDeclarationNameExpr(SS, Name, Location);
1667 /// \brief Build a new template-id expression.
1669 /// By default, performs semantic analysis to build the new expression.
1670 /// Subclasses may override this routine to provide different behavior.
1671 OwningExprResult RebuildTemplateIdExpr(const CXXScopeSpec &SS,
1674 const TemplateArgumentListInfo &TemplateArgs) {
1675 return getSema().BuildTemplateIdExpr(SS, R, RequiresADL, TemplateArgs);
1678 /// \brief Build a new object-construction expression.
1680 /// By default, performs semantic analysis to build the new expression.
1681 /// Subclasses may override this routine to provide different behavior.
1682 OwningExprResult RebuildCXXConstructExpr(QualType T,
1684 CXXConstructorDecl *Constructor,
1686 MultiExprArg Args) {
1687 ASTOwningVector<&ActionBase::DeleteExpr> ConvertedArgs(SemaRef);
1688 if (getSema().CompleteConstructorCall(Constructor, move(Args), Loc,
1690 return getSema().ExprError();
1692 return getSema().BuildCXXConstructExpr(Loc, T, Constructor, IsElidable,
1693 move_arg(ConvertedArgs));
1696 /// \brief Build a new object-construction expression.
1698 /// By default, performs semantic analysis to build the new expression.
1699 /// Subclasses may override this routine to provide different behavior.
1700 OwningExprResult RebuildCXXTemporaryObjectExpr(SourceLocation TypeBeginLoc,
1702 SourceLocation LParenLoc,
1704 SourceLocation *Commas,
1705 SourceLocation RParenLoc) {
1706 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeBeginLoc),
1714 /// \brief Build a new object-construction expression.
1716 /// By default, performs semantic analysis to build the new expression.
1717 /// Subclasses may override this routine to provide different behavior.
1718 OwningExprResult RebuildCXXUnresolvedConstructExpr(SourceLocation TypeBeginLoc,
1720 SourceLocation LParenLoc,
1722 SourceLocation *Commas,
1723 SourceLocation RParenLoc) {
1724 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeBeginLoc,
1725 /*FIXME*/LParenLoc),
1733 /// \brief Build a new member reference expression.
1735 /// By default, performs semantic analysis to build the new expression.
1736 /// Subclasses may override this routine to provide different behavior.
1737 OwningExprResult RebuildCXXDependentScopeMemberExpr(ExprArg BaseE,
1740 SourceLocation OperatorLoc,
1741 NestedNameSpecifier *Qualifier,
1742 SourceRange QualifierRange,
1743 NamedDecl *FirstQualifierInScope,
1744 DeclarationName Name,
1745 SourceLocation MemberLoc,
1746 const TemplateArgumentListInfo *TemplateArgs) {
1748 SS.setRange(QualifierRange);
1749 SS.setScopeRep(Qualifier);
1751 return SemaRef.BuildMemberReferenceExpr(move(BaseE), BaseType,
1752 OperatorLoc, IsArrow,
1753 SS, FirstQualifierInScope,
1754 Name, MemberLoc, TemplateArgs);
1757 /// \brief Build a new member reference expression.
1759 /// By default, performs semantic analysis to build the new expression.
1760 /// Subclasses may override this routine to provide different behavior.
1761 OwningExprResult RebuildUnresolvedMemberExpr(ExprArg BaseE,
1763 SourceLocation OperatorLoc,
1765 NestedNameSpecifier *Qualifier,
1766 SourceRange QualifierRange,
1767 NamedDecl *FirstQualifierInScope,
1769 const TemplateArgumentListInfo *TemplateArgs) {
1771 SS.setRange(QualifierRange);
1772 SS.setScopeRep(Qualifier);
1774 return SemaRef.BuildMemberReferenceExpr(move(BaseE), BaseType,
1775 OperatorLoc, IsArrow,
1776 SS, FirstQualifierInScope,
1780 /// \brief Build a new Objective-C @encode expression.
1782 /// By default, performs semantic analysis to build the new expression.
1783 /// Subclasses may override this routine to provide different behavior.
1784 OwningExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc,
1785 TypeSourceInfo *EncodeTypeInfo,
1786 SourceLocation RParenLoc) {
1787 return SemaRef.Owned(SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo,
1791 /// \brief Build a new Objective-C class message.
1792 OwningExprResult RebuildObjCMessageExpr(TypeSourceInfo *ReceiverTypeInfo,
1794 ObjCMethodDecl *Method,
1795 SourceLocation LBracLoc,
1797 SourceLocation RBracLoc) {
1798 return SemaRef.BuildClassMessage(ReceiverTypeInfo,
1799 ReceiverTypeInfo->getType(),
1800 /*SuperLoc=*/SourceLocation(),
1801 Sel, Method, LBracLoc, RBracLoc,
1805 /// \brief Build a new Objective-C instance message.
1806 OwningExprResult RebuildObjCMessageExpr(ExprArg Receiver,
1808 ObjCMethodDecl *Method,
1809 SourceLocation LBracLoc,
1811 SourceLocation RBracLoc) {
1812 QualType ReceiverType = static_cast<Expr *>(Receiver.get())->getType();
1813 return SemaRef.BuildInstanceMessage(move(Receiver),
1815 /*SuperLoc=*/SourceLocation(),
1816 Sel, Method, LBracLoc, RBracLoc,
1820 /// \brief Build a new Objective-C ivar reference expression.
1822 /// By default, performs semantic analysis to build the new expression.
1823 /// Subclasses may override this routine to provide different behavior.
1824 OwningExprResult RebuildObjCIvarRefExpr(ExprArg BaseArg, ObjCIvarDecl *Ivar,
1825 SourceLocation IvarLoc,
1826 bool IsArrow, bool IsFreeIvar) {
1827 // FIXME: We lose track of the IsFreeIvar bit.
1829 Expr *Base = BaseArg.takeAs<Expr>();
1830 LookupResult R(getSema(), Ivar->getDeclName(), IvarLoc,
1831 Sema::LookupMemberName);
1832 OwningExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow,
1836 if (Result.isInvalid())
1837 return getSema().ExprError();
1840 return move(Result);
1842 return getSema().BuildMemberReferenceExpr(getSema().Owned(Base),
1844 /*FIXME:*/IvarLoc, IsArrow, SS,
1845 /*FirstQualifierInScope=*/0,
1847 /*TemplateArgs=*/0);
1850 /// \brief Build a new Objective-C property reference expression.
1852 /// By default, performs semantic analysis to build the new expression.
1853 /// Subclasses may override this routine to provide different behavior.
1854 OwningExprResult RebuildObjCPropertyRefExpr(ExprArg BaseArg,
1855 ObjCPropertyDecl *Property,
1856 SourceLocation PropertyLoc) {
1858 Expr *Base = BaseArg.takeAs<Expr>();
1859 LookupResult R(getSema(), Property->getDeclName(), PropertyLoc,
1860 Sema::LookupMemberName);
1861 bool IsArrow = false;
1862 OwningExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow,
1863 /*FIME:*/PropertyLoc,
1866 if (Result.isInvalid())
1867 return getSema().ExprError();
1870 return move(Result);
1872 return getSema().BuildMemberReferenceExpr(getSema().Owned(Base),
1874 /*FIXME:*/PropertyLoc, IsArrow,
1876 /*FirstQualifierInScope=*/0,
1878 /*TemplateArgs=*/0);
1881 /// \brief Build a new Objective-C implicit setter/getter reference
1884 /// By default, performs semantic analysis to build the new expression.
1885 /// Subclasses may override this routine to provide different behavior.
1886 OwningExprResult RebuildObjCImplicitSetterGetterRefExpr(
1887 ObjCMethodDecl *Getter,
1889 ObjCMethodDecl *Setter,
1890 SourceLocation NameLoc,
1892 // Since these expressions can only be value-dependent, we do not need to
1893 // perform semantic analysis again.
1894 return getSema().Owned(
1895 new (getSema().Context) ObjCImplicitSetterGetterRefExpr(Getter, T,
1898 Base.takeAs<Expr>()));
1901 /// \brief Build a new Objective-C "isa" expression.
1903 /// By default, performs semantic analysis to build the new expression.
1904 /// Subclasses may override this routine to provide different behavior.
1905 OwningExprResult RebuildObjCIsaExpr(ExprArg BaseArg, SourceLocation IsaLoc,
1908 Expr *Base = BaseArg.takeAs<Expr>();
1909 LookupResult R(getSema(), &getSema().Context.Idents.get("isa"), IsaLoc,
1910 Sema::LookupMemberName);
1911 OwningExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow,
1915 if (Result.isInvalid())
1916 return getSema().ExprError();
1919 return move(Result);
1921 return getSema().BuildMemberReferenceExpr(getSema().Owned(Base),
1923 /*FIXME:*/IsaLoc, IsArrow, SS,
1924 /*FirstQualifierInScope=*/0,
1926 /*TemplateArgs=*/0);
1929 /// \brief Build a new shuffle vector expression.
1931 /// By default, performs semantic analysis to build the new expression.
1932 /// Subclasses may override this routine to provide different behavior.
1933 OwningExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc,
1934 MultiExprArg SubExprs,
1935 SourceLocation RParenLoc) {
1936 // Find the declaration for __builtin_shufflevector
1937 const IdentifierInfo &Name
1938 = SemaRef.Context.Idents.get("__builtin_shufflevector");
1939 TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl();
1940 DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name));
1941 assert(Lookup.first != Lookup.second && "No __builtin_shufflevector?");
1943 // Build a reference to the __builtin_shufflevector builtin
1944 FunctionDecl *Builtin = cast<FunctionDecl>(*Lookup.first);
1946 = new (SemaRef.Context) DeclRefExpr(Builtin, Builtin->getType(),
1948 SemaRef.UsualUnaryConversions(Callee);
1950 // Build the CallExpr
1951 unsigned NumSubExprs = SubExprs.size();
1952 Expr **Subs = (Expr **)SubExprs.release();
1953 CallExpr *TheCall = new (SemaRef.Context) CallExpr(SemaRef.Context, Callee,
1955 Builtin->getCallResultType(),
1957 OwningExprResult OwnedCall(SemaRef.Owned(TheCall));
1959 // Type-check the __builtin_shufflevector expression.
1960 OwningExprResult Result = SemaRef.SemaBuiltinShuffleVector(TheCall);
1961 if (Result.isInvalid())
1962 return SemaRef.ExprError();
1964 OwnedCall.release();
1965 return move(Result);
1969 template<typename Derived>
1970 Sema::OwningStmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) {
1972 return SemaRef.Owned(S);
1974 switch (S->getStmtClass()) {
1975 case Stmt::NoStmtClass: break;
1977 // Transform individual statement nodes
1978 #define STMT(Node, Parent) \
1979 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
1980 #define EXPR(Node, Parent)
1981 #include "clang/AST/StmtNodes.inc"
1983 // Transform expressions by calling TransformExpr.
1984 #define STMT(Node, Parent)
1985 #define ABSTRACT_STMT(Stmt)
1986 #define EXPR(Node, Parent) case Stmt::Node##Class:
1987 #include "clang/AST/StmtNodes.inc"
1989 Sema::OwningExprResult E = getDerived().TransformExpr(cast<Expr>(S));
1991 return getSema().StmtError();
1993 return getSema().ActOnExprStmt(getSema().MakeFullExpr(E));
1997 return SemaRef.Owned(S->Retain());
2001 template<typename Derived>
2002 Sema::OwningExprResult TreeTransform<Derived>::TransformExpr(Expr *E) {
2004 return SemaRef.Owned(E);
2006 switch (E->getStmtClass()) {
2007 case Stmt::NoStmtClass: break;
2008 #define STMT(Node, Parent) case Stmt::Node##Class: break;
2009 #define ABSTRACT_STMT(Stmt)
2010 #define EXPR(Node, Parent) \
2011 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
2012 #include "clang/AST/StmtNodes.inc"
2015 return SemaRef.Owned(E->Retain());
2018 template<typename Derived>
2019 NestedNameSpecifier *
2020 TreeTransform<Derived>::TransformNestedNameSpecifier(NestedNameSpecifier *NNS,
2022 QualType ObjectType,
2023 NamedDecl *FirstQualifierInScope) {
2027 // Transform the prefix of this nested name specifier.
2028 NestedNameSpecifier *Prefix = NNS->getPrefix();
2030 Prefix = getDerived().TransformNestedNameSpecifier(Prefix, Range,
2032 FirstQualifierInScope);
2036 // Clear out the object type and the first qualifier in scope; they only
2037 // apply to the first element in the nested-name-specifier.
2038 ObjectType = QualType();
2039 FirstQualifierInScope = 0;
2042 switch (NNS->getKind()) {
2043 case NestedNameSpecifier::Identifier:
2044 assert((Prefix || !ObjectType.isNull()) &&
2045 "Identifier nested-name-specifier with no prefix or object type");
2046 if (!getDerived().AlwaysRebuild() && Prefix == NNS->getPrefix() &&
2047 ObjectType.isNull())
2050 return getDerived().RebuildNestedNameSpecifier(Prefix, Range,
2051 *NNS->getAsIdentifier(),
2053 FirstQualifierInScope);
2055 case NestedNameSpecifier::Namespace: {
2057 = cast_or_null<NamespaceDecl>(
2058 getDerived().TransformDecl(Range.getBegin(),
2059 NNS->getAsNamespace()));
2060 if (!getDerived().AlwaysRebuild() &&
2061 Prefix == NNS->getPrefix() &&
2062 NS == NNS->getAsNamespace())
2065 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, NS);
2068 case NestedNameSpecifier::Global:
2069 // There is no meaningful transformation that one could perform on the
2073 case NestedNameSpecifier::TypeSpecWithTemplate:
2074 case NestedNameSpecifier::TypeSpec: {
2075 TemporaryBase Rebase(*this, Range.getBegin(), DeclarationName());
2076 QualType T = getDerived().TransformType(QualType(NNS->getAsType(), 0),
2081 if (!getDerived().AlwaysRebuild() &&
2082 Prefix == NNS->getPrefix() &&
2083 T == QualType(NNS->getAsType(), 0))
2086 return getDerived().RebuildNestedNameSpecifier(Prefix, Range,
2087 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate,
2092 // Required to silence a GCC warning
2096 template<typename Derived>
2098 TreeTransform<Derived>::TransformDeclarationName(DeclarationName Name,
2100 QualType ObjectType) {
2104 switch (Name.getNameKind()) {
2105 case DeclarationName::Identifier:
2106 case DeclarationName::ObjCZeroArgSelector:
2107 case DeclarationName::ObjCOneArgSelector:
2108 case DeclarationName::ObjCMultiArgSelector:
2109 case DeclarationName::CXXOperatorName:
2110 case DeclarationName::CXXLiteralOperatorName:
2111 case DeclarationName::CXXUsingDirective:
2114 case DeclarationName::CXXConstructorName:
2115 case DeclarationName::CXXDestructorName:
2116 case DeclarationName::CXXConversionFunctionName: {
2117 TemporaryBase Rebase(*this, Loc, Name);
2118 QualType T = getDerived().TransformType(Name.getCXXNameType(),
2121 return DeclarationName();
2123 return SemaRef.Context.DeclarationNames.getCXXSpecialName(
2125 SemaRef.Context.getCanonicalType(T));
2129 return DeclarationName();
2132 template<typename Derived>
2134 TreeTransform<Derived>::TransformTemplateName(TemplateName Name,
2135 QualType ObjectType) {
2136 SourceLocation Loc = getDerived().getBaseLocation();
2138 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) {
2139 NestedNameSpecifier *NNS
2140 = getDerived().TransformNestedNameSpecifier(QTN->getQualifier(),
2141 /*FIXME:*/SourceRange(getDerived().getBaseLocation()),
2144 return TemplateName();
2146 if (TemplateDecl *Template = QTN->getTemplateDecl()) {
2147 TemplateDecl *TransTemplate
2148 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Loc, Template));
2150 return TemplateName();
2152 if (!getDerived().AlwaysRebuild() &&
2153 NNS == QTN->getQualifier() &&
2154 TransTemplate == Template)
2157 return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(),
2161 // These should be getting filtered out before they make it into the AST.
2162 assert(false && "overloaded template name survived to here");
2165 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) {
2166 NestedNameSpecifier *NNS
2167 = getDerived().TransformNestedNameSpecifier(DTN->getQualifier(),
2168 /*FIXME:*/SourceRange(getDerived().getBaseLocation()),
2170 if (!NNS && DTN->getQualifier())
2171 return TemplateName();
2173 if (!getDerived().AlwaysRebuild() &&
2174 NNS == DTN->getQualifier() &&
2175 ObjectType.isNull())
2178 if (DTN->isIdentifier())
2179 return getDerived().RebuildTemplateName(NNS, *DTN->getIdentifier(),
2182 return getDerived().RebuildTemplateName(NNS, DTN->getOperator(),
2186 if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
2187 TemplateDecl *TransTemplate
2188 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Loc, Template));
2190 return TemplateName();
2192 if (!getDerived().AlwaysRebuild() &&
2193 TransTemplate == Template)
2196 return TemplateName(TransTemplate);
2199 // These should be getting filtered out before they reach the AST.
2200 assert(false && "overloaded function decl survived to here");
2201 return TemplateName();
2204 template<typename Derived>
2205 void TreeTransform<Derived>::InventTemplateArgumentLoc(
2206 const TemplateArgument &Arg,
2207 TemplateArgumentLoc &Output) {
2208 SourceLocation Loc = getDerived().getBaseLocation();
2209 switch (Arg.getKind()) {
2210 case TemplateArgument::Null:
2211 llvm_unreachable("null template argument in TreeTransform");
2214 case TemplateArgument::Type:
2215 Output = TemplateArgumentLoc(Arg,
2216 SemaRef.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc));
2220 case TemplateArgument::Template:
2221 Output = TemplateArgumentLoc(Arg, SourceRange(), Loc);
2224 case TemplateArgument::Expression:
2225 Output = TemplateArgumentLoc(Arg, Arg.getAsExpr());
2228 case TemplateArgument::Declaration:
2229 case TemplateArgument::Integral:
2230 case TemplateArgument::Pack:
2231 Output = TemplateArgumentLoc(Arg, TemplateArgumentLocInfo());
2236 template<typename Derived>
2237 bool TreeTransform<Derived>::TransformTemplateArgument(
2238 const TemplateArgumentLoc &Input,
2239 TemplateArgumentLoc &Output) {
2240 const TemplateArgument &Arg = Input.getArgument();
2241 switch (Arg.getKind()) {
2242 case TemplateArgument::Null:
2243 case TemplateArgument::Integral:
2247 case TemplateArgument::Type: {
2248 TypeSourceInfo *DI = Input.getTypeSourceInfo();
2250 DI = InventTypeSourceInfo(Input.getArgument().getAsType());
2252 DI = getDerived().TransformType(DI);
2253 if (!DI) return true;
2255 Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
2259 case TemplateArgument::Declaration: {
2260 // FIXME: we should never have to transform one of these.
2261 DeclarationName Name;
2262 if (NamedDecl *ND = dyn_cast<NamedDecl>(Arg.getAsDecl()))
2263 Name = ND->getDeclName();
2264 TemporaryBase Rebase(*this, Input.getLocation(), Name);
2265 Decl *D = getDerived().TransformDecl(Input.getLocation(), Arg.getAsDecl());
2266 if (!D) return true;
2268 Expr *SourceExpr = Input.getSourceDeclExpression();
2270 EnterExpressionEvaluationContext Unevaluated(getSema(),
2271 Action::Unevaluated);
2272 Sema::OwningExprResult E = getDerived().TransformExpr(SourceExpr);
2276 SourceExpr = E.takeAs<Expr>();
2277 SourceExpr->Retain();
2281 Output = TemplateArgumentLoc(TemplateArgument(D), SourceExpr);
2285 case TemplateArgument::Template: {
2286 TemporaryBase Rebase(*this, Input.getLocation(), DeclarationName());
2287 TemplateName Template
2288 = getDerived().TransformTemplateName(Arg.getAsTemplate());
2289 if (Template.isNull())
2292 Output = TemplateArgumentLoc(TemplateArgument(Template),
2293 Input.getTemplateQualifierRange(),
2294 Input.getTemplateNameLoc());
2298 case TemplateArgument::Expression: {
2299 // Template argument expressions are not potentially evaluated.
2300 EnterExpressionEvaluationContext Unevaluated(getSema(),
2301 Action::Unevaluated);
2303 Expr *InputExpr = Input.getSourceExpression();
2304 if (!InputExpr) InputExpr = Input.getArgument().getAsExpr();
2306 Sema::OwningExprResult E
2307 = getDerived().TransformExpr(InputExpr);
2308 if (E.isInvalid()) return true;
2310 Expr *ETaken = E.takeAs<Expr>();
2312 Output = TemplateArgumentLoc(TemplateArgument(ETaken), ETaken);
2316 case TemplateArgument::Pack: {
2317 llvm::SmallVector<TemplateArgument, 4> TransformedArgs;
2318 TransformedArgs.reserve(Arg.pack_size());
2319 for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
2320 AEnd = Arg.pack_end();
2323 // FIXME: preserve source information here when we start
2324 // caring about parameter packs.
2326 TemplateArgumentLoc InputArg;
2327 TemplateArgumentLoc OutputArg;
2328 getDerived().InventTemplateArgumentLoc(*A, InputArg);
2329 if (getDerived().TransformTemplateArgument(InputArg, OutputArg))
2332 TransformedArgs.push_back(OutputArg.getArgument());
2334 TemplateArgument Result;
2335 Result.setArgumentPack(TransformedArgs.data(), TransformedArgs.size(),
2337 Output = TemplateArgumentLoc(Result, Input.getLocInfo());
2342 // Work around bogus GCC warning
2346 //===----------------------------------------------------------------------===//
2347 // Type transformation
2348 //===----------------------------------------------------------------------===//
2350 template<typename Derived>
2351 QualType TreeTransform<Derived>::TransformType(QualType T,
2352 QualType ObjectType) {
2353 if (getDerived().AlreadyTransformed(T))
2356 // Temporary workaround. All of these transformations should
2357 // eventually turn into transformations on TypeLocs.
2358 TypeSourceInfo *DI = getSema().Context.CreateTypeSourceInfo(T);
2359 DI->getTypeLoc().initialize(getDerived().getBaseLocation());
2361 TypeSourceInfo *NewDI = getDerived().TransformType(DI, ObjectType);
2366 return NewDI->getType();
2369 template<typename Derived>
2370 TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *DI,
2371 QualType ObjectType) {
2372 if (getDerived().AlreadyTransformed(DI->getType()))
2377 TypeLoc TL = DI->getTypeLoc();
2378 TLB.reserve(TL.getFullDataSize());
2380 QualType Result = getDerived().TransformType(TLB, TL, ObjectType);
2381 if (Result.isNull())
2384 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
2387 template<typename Derived>
2389 TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T,
2390 QualType ObjectType) {
2391 switch (T.getTypeLocClass()) {
2392 #define ABSTRACT_TYPELOC(CLASS, PARENT)
2393 #define TYPELOC(CLASS, PARENT) \
2394 case TypeLoc::CLASS: \
2395 return getDerived().Transform##CLASS##Type(TLB, cast<CLASS##TypeLoc>(T), \
2397 #include "clang/AST/TypeLocNodes.def"
2400 llvm_unreachable("unhandled type loc!");
2404 /// FIXME: By default, this routine adds type qualifiers only to types
2405 /// that can have qualifiers, and silently suppresses those qualifiers
2406 /// that are not permitted (e.g., qualifiers on reference or function
2407 /// types). This is the right thing for template instantiation, but
2408 /// probably not for other clients.
2409 template<typename Derived>
2411 TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB,
2413 QualType ObjectType) {
2414 Qualifiers Quals = T.getType().getLocalQualifiers();
2416 QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc(),
2418 if (Result.isNull())
2421 // Silently suppress qualifiers if the result type can't be qualified.
2422 // FIXME: this is the right thing for template instantiation, but
2423 // probably not for other clients.
2424 if (Result->isFunctionType() || Result->isReferenceType())
2427 if (!Quals.empty()) {
2428 Result = SemaRef.BuildQualifiedType(Result, T.getBeginLoc(), Quals);
2429 TLB.push<QualifiedTypeLoc>(Result);
2430 // No location information to preserve.
2436 template <class TyLoc> static inline
2437 QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) {
2438 TyLoc NewT = TLB.push<TyLoc>(T.getType());
2439 NewT.setNameLoc(T.getNameLoc());
2443 template<typename Derived>
2444 QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
2446 QualType ObjectType) {
2447 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType());
2448 NewT.setBuiltinLoc(T.getBuiltinLoc());
2449 if (T.needsExtraLocalData())
2450 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs();
2454 template<typename Derived>
2455 QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
2457 QualType ObjectType) {
2459 return TransformTypeSpecType(TLB, T);
2462 template<typename Derived>
2463 QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
2465 QualType ObjectType) {
2466 QualType PointeeType
2467 = getDerived().TransformType(TLB, TL.getPointeeLoc());
2468 if (PointeeType.isNull())
2471 QualType Result = TL.getType();
2472 if (PointeeType->getAs<ObjCObjectType>()) {
2473 // A dependent pointer type 'T *' has is being transformed such
2474 // that an Objective-C class type is being replaced for 'T'. The
2475 // resulting pointer type is an ObjCObjectPointerType, not a
2477 Result = SemaRef.Context.getObjCObjectPointerType(PointeeType);
2479 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
2480 NewT.setStarLoc(TL.getStarLoc());
2484 if (getDerived().AlwaysRebuild() ||
2485 PointeeType != TL.getPointeeLoc().getType()) {
2486 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
2487 if (Result.isNull())
2491 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result);
2492 NewT.setSigilLoc(TL.getSigilLoc());
2496 template<typename Derived>
2498 TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
2499 BlockPointerTypeLoc TL,
2500 QualType ObjectType) {
2501 QualType PointeeType
2502 = getDerived().TransformType(TLB, TL.getPointeeLoc());
2503 if (PointeeType.isNull())
2506 QualType Result = TL.getType();
2507 if (getDerived().AlwaysRebuild() ||
2508 PointeeType != TL.getPointeeLoc().getType()) {
2509 Result = getDerived().RebuildBlockPointerType(PointeeType,
2511 if (Result.isNull())
2515 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result);
2516 NewT.setSigilLoc(TL.getSigilLoc());
2520 /// Transforms a reference type. Note that somewhat paradoxically we
2521 /// don't care whether the type itself is an l-value type or an r-value
2522 /// type; we only care if the type was *written* as an l-value type
2523 /// or an r-value type.
2524 template<typename Derived>
2526 TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB,
2527 ReferenceTypeLoc TL,
2528 QualType ObjectType) {
2529 const ReferenceType *T = TL.getTypePtr();
2531 // Note that this works with the pointee-as-written.
2532 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
2533 if (PointeeType.isNull())
2536 QualType Result = TL.getType();
2537 if (getDerived().AlwaysRebuild() ||
2538 PointeeType != T->getPointeeTypeAsWritten()) {
2539 Result = getDerived().RebuildReferenceType(PointeeType,
2540 T->isSpelledAsLValue(),
2542 if (Result.isNull())
2546 // r-value references can be rebuilt as l-value references.
2547 ReferenceTypeLoc NewTL;
2548 if (isa<LValueReferenceType>(Result))
2549 NewTL = TLB.push<LValueReferenceTypeLoc>(Result);
2551 NewTL = TLB.push<RValueReferenceTypeLoc>(Result);
2552 NewTL.setSigilLoc(TL.getSigilLoc());
2557 template<typename Derived>
2559 TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB,
2560 LValueReferenceTypeLoc TL,
2561 QualType ObjectType) {
2562 return TransformReferenceType(TLB, TL, ObjectType);
2565 template<typename Derived>
2567 TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
2568 RValueReferenceTypeLoc TL,
2569 QualType ObjectType) {
2570 return TransformReferenceType(TLB, TL, ObjectType);
2573 template<typename Derived>
2575 TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
2576 MemberPointerTypeLoc TL,
2577 QualType ObjectType) {
2578 MemberPointerType *T = TL.getTypePtr();
2580 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
2581 if (PointeeType.isNull())
2584 // TODO: preserve source information for this.
2586 = getDerived().TransformType(QualType(T->getClass(), 0));
2587 if (ClassType.isNull())
2590 QualType Result = TL.getType();
2591 if (getDerived().AlwaysRebuild() ||
2592 PointeeType != T->getPointeeType() ||
2593 ClassType != QualType(T->getClass(), 0)) {
2594 Result = getDerived().RebuildMemberPointerType(PointeeType, ClassType,
2596 if (Result.isNull())
2600 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
2601 NewTL.setSigilLoc(TL.getSigilLoc());
2606 template<typename Derived>
2608 TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
2609 ConstantArrayTypeLoc TL,
2610 QualType ObjectType) {
2611 ConstantArrayType *T = TL.getTypePtr();
2612 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
2613 if (ElementType.isNull())
2616 QualType Result = TL.getType();
2617 if (getDerived().AlwaysRebuild() ||
2618 ElementType != T->getElementType()) {
2619 Result = getDerived().RebuildConstantArrayType(ElementType,
2620 T->getSizeModifier(),
2622 T->getIndexTypeCVRQualifiers(),
2623 TL.getBracketsRange());
2624 if (Result.isNull())
2628 ConstantArrayTypeLoc NewTL = TLB.push<ConstantArrayTypeLoc>(Result);
2629 NewTL.setLBracketLoc(TL.getLBracketLoc());
2630 NewTL.setRBracketLoc(TL.getRBracketLoc());
2632 Expr *Size = TL.getSizeExpr();
2634 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2635 Size = getDerived().TransformExpr(Size).template takeAs<Expr>();
2637 NewTL.setSizeExpr(Size);
2642 template<typename Derived>
2643 QualType TreeTransform<Derived>::TransformIncompleteArrayType(
2644 TypeLocBuilder &TLB,
2645 IncompleteArrayTypeLoc TL,
2646 QualType ObjectType) {
2647 IncompleteArrayType *T = TL.getTypePtr();
2648 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
2649 if (ElementType.isNull())
2652 QualType Result = TL.getType();
2653 if (getDerived().AlwaysRebuild() ||
2654 ElementType != T->getElementType()) {
2655 Result = getDerived().RebuildIncompleteArrayType(ElementType,
2656 T->getSizeModifier(),
2657 T->getIndexTypeCVRQualifiers(),
2658 TL.getBracketsRange());
2659 if (Result.isNull())
2663 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
2664 NewTL.setLBracketLoc(TL.getLBracketLoc());
2665 NewTL.setRBracketLoc(TL.getRBracketLoc());
2666 NewTL.setSizeExpr(0);
2671 template<typename Derived>
2673 TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
2674 VariableArrayTypeLoc TL,
2675 QualType ObjectType) {
2676 VariableArrayType *T = TL.getTypePtr();
2677 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
2678 if (ElementType.isNull())
2681 // Array bounds are not potentially evaluated contexts
2682 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2684 Sema::OwningExprResult SizeResult
2685 = getDerived().TransformExpr(T->getSizeExpr());
2686 if (SizeResult.isInvalid())
2689 Expr *Size = static_cast<Expr*>(SizeResult.get());
2691 QualType Result = TL.getType();
2692 if (getDerived().AlwaysRebuild() ||
2693 ElementType != T->getElementType() ||
2694 Size != T->getSizeExpr()) {
2695 Result = getDerived().RebuildVariableArrayType(ElementType,
2696 T->getSizeModifier(),
2698 T->getIndexTypeCVRQualifiers(),
2699 TL.getBracketsRange());
2700 if (Result.isNull())
2703 else SizeResult.take();
2705 VariableArrayTypeLoc NewTL = TLB.push<VariableArrayTypeLoc>(Result);
2706 NewTL.setLBracketLoc(TL.getLBracketLoc());
2707 NewTL.setRBracketLoc(TL.getRBracketLoc());
2708 NewTL.setSizeExpr(Size);
2713 template<typename Derived>
2715 TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
2716 DependentSizedArrayTypeLoc TL,
2717 QualType ObjectType) {
2718 DependentSizedArrayType *T = TL.getTypePtr();
2719 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
2720 if (ElementType.isNull())
2723 // Array bounds are not potentially evaluated contexts
2724 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2726 Sema::OwningExprResult SizeResult
2727 = getDerived().TransformExpr(T->getSizeExpr());
2728 if (SizeResult.isInvalid())
2731 Expr *Size = static_cast<Expr*>(SizeResult.get());
2733 QualType Result = TL.getType();
2734 if (getDerived().AlwaysRebuild() ||
2735 ElementType != T->getElementType() ||
2736 Size != T->getSizeExpr()) {
2737 Result = getDerived().RebuildDependentSizedArrayType(ElementType,
2738 T->getSizeModifier(),
2740 T->getIndexTypeCVRQualifiers(),
2741 TL.getBracketsRange());
2742 if (Result.isNull())
2745 else SizeResult.take();
2747 // We might have any sort of array type now, but fortunately they
2748 // all have the same location layout.
2749 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
2750 NewTL.setLBracketLoc(TL.getLBracketLoc());
2751 NewTL.setRBracketLoc(TL.getRBracketLoc());
2752 NewTL.setSizeExpr(Size);
2757 template<typename Derived>
2758 QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
2759 TypeLocBuilder &TLB,
2760 DependentSizedExtVectorTypeLoc TL,
2761 QualType ObjectType) {
2762 DependentSizedExtVectorType *T = TL.getTypePtr();
2764 // FIXME: ext vector locs should be nested
2765 QualType ElementType = getDerived().TransformType(T->getElementType());
2766 if (ElementType.isNull())
2769 // Vector sizes are not potentially evaluated contexts
2770 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2772 Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
2773 if (Size.isInvalid())
2776 QualType Result = TL.getType();
2777 if (getDerived().AlwaysRebuild() ||
2778 ElementType != T->getElementType() ||
2779 Size.get() != T->getSizeExpr()) {
2780 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
2782 T->getAttributeLoc());
2783 if (Result.isNull())
2788 // Result might be dependent or not.
2789 if (isa<DependentSizedExtVectorType>(Result)) {
2790 DependentSizedExtVectorTypeLoc NewTL
2791 = TLB.push<DependentSizedExtVectorTypeLoc>(Result);
2792 NewTL.setNameLoc(TL.getNameLoc());
2794 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
2795 NewTL.setNameLoc(TL.getNameLoc());
2801 template<typename Derived>
2802 QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
2804 QualType ObjectType) {
2805 VectorType *T = TL.getTypePtr();
2806 QualType ElementType = getDerived().TransformType(T->getElementType());
2807 if (ElementType.isNull())
2810 QualType Result = TL.getType();
2811 if (getDerived().AlwaysRebuild() ||
2812 ElementType != T->getElementType()) {
2813 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(),
2814 T->getAltiVecSpecific());
2815 if (Result.isNull())
2819 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
2820 NewTL.setNameLoc(TL.getNameLoc());
2825 template<typename Derived>
2826 QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
2827 ExtVectorTypeLoc TL,
2828 QualType ObjectType) {
2829 VectorType *T = TL.getTypePtr();
2830 QualType ElementType = getDerived().TransformType(T->getElementType());
2831 if (ElementType.isNull())
2834 QualType Result = TL.getType();
2835 if (getDerived().AlwaysRebuild() ||
2836 ElementType != T->getElementType()) {
2837 Result = getDerived().RebuildExtVectorType(ElementType,
2838 T->getNumElements(),
2839 /*FIXME*/ SourceLocation());
2840 if (Result.isNull())
2844 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
2845 NewTL.setNameLoc(TL.getNameLoc());
2850 template<typename Derived>
2852 TreeTransform<Derived>::TransformFunctionTypeParam(ParmVarDecl *OldParm) {
2853 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
2854 TypeSourceInfo *NewDI = getDerived().TransformType(OldDI);
2861 return ParmVarDecl::Create(SemaRef.Context,
2862 OldParm->getDeclContext(),
2863 OldParm->getLocation(),
2864 OldParm->getIdentifier(),
2867 OldParm->getStorageClass(),
2868 OldParm->getStorageClassAsWritten(),
2872 template<typename Derived>
2873 bool TreeTransform<Derived>::
2874 TransformFunctionTypeParams(FunctionProtoTypeLoc TL,
2875 llvm::SmallVectorImpl<QualType> &PTypes,
2876 llvm::SmallVectorImpl<ParmVarDecl*> &PVars) {
2877 FunctionProtoType *T = TL.getTypePtr();
2879 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
2880 ParmVarDecl *OldParm = TL.getArg(i);
2883 ParmVarDecl *NewParm;
2886 NewParm = getDerived().TransformFunctionTypeParam(OldParm);
2889 NewType = NewParm->getType();
2891 // Deal with the possibility that we don't have a parameter
2892 // declaration for this parameter.
2896 QualType OldType = T->getArgType(i);
2897 NewType = getDerived().TransformType(OldType);
2898 if (NewType.isNull())
2902 PTypes.push_back(NewType);
2903 PVars.push_back(NewParm);
2909 template<typename Derived>
2911 TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB,
2912 FunctionProtoTypeLoc TL,
2913 QualType ObjectType) {
2914 // Transform the parameters. We do this first for the benefit of template
2915 // instantiations, so that the ParmVarDecls get/ placed into the template
2916 // instantiation scope before we transform the function type.
2917 llvm::SmallVector<QualType, 4> ParamTypes;
2918 llvm::SmallVector<ParmVarDecl*, 4> ParamDecls;
2919 if (getDerived().TransformFunctionTypeParams(TL, ParamTypes, ParamDecls))
2922 FunctionProtoType *T = TL.getTypePtr();
2923 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc());
2924 if (ResultType.isNull())
2927 QualType Result = TL.getType();
2928 if (getDerived().AlwaysRebuild() ||
2929 ResultType != T->getResultType() ||
2930 !std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) {
2931 Result = getDerived().RebuildFunctionProtoType(ResultType,
2936 if (Result.isNull())
2940 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result);
2941 NewTL.setLParenLoc(TL.getLParenLoc());
2942 NewTL.setRParenLoc(TL.getRParenLoc());
2943 for (unsigned i = 0, e = NewTL.getNumArgs(); i != e; ++i)
2944 NewTL.setArg(i, ParamDecls[i]);
2949 template<typename Derived>
2950 QualType TreeTransform<Derived>::TransformFunctionNoProtoType(
2951 TypeLocBuilder &TLB,
2952 FunctionNoProtoTypeLoc TL,
2953 QualType ObjectType) {
2954 FunctionNoProtoType *T = TL.getTypePtr();
2955 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc());
2956 if (ResultType.isNull())
2959 QualType Result = TL.getType();
2960 if (getDerived().AlwaysRebuild() ||
2961 ResultType != T->getResultType())
2962 Result = getDerived().RebuildFunctionNoProtoType(ResultType);
2964 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result);
2965 NewTL.setLParenLoc(TL.getLParenLoc());
2966 NewTL.setRParenLoc(TL.getRParenLoc());
2971 template<typename Derived> QualType
2972 TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB,
2973 UnresolvedUsingTypeLoc TL,
2974 QualType ObjectType) {
2975 UnresolvedUsingType *T = TL.getTypePtr();
2976 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl());
2980 QualType Result = TL.getType();
2981 if (getDerived().AlwaysRebuild() || D != T->getDecl()) {
2982 Result = getDerived().RebuildUnresolvedUsingType(D);
2983 if (Result.isNull())
2987 // We might get an arbitrary type spec type back. We should at
2988 // least always get a type spec type, though.
2989 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result);
2990 NewTL.setNameLoc(TL.getNameLoc());
2995 template<typename Derived>
2996 QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
2998 QualType ObjectType) {
2999 TypedefType *T = TL.getTypePtr();
3000 TypedefDecl *Typedef
3001 = cast_or_null<TypedefDecl>(getDerived().TransformDecl(TL.getNameLoc(),
3006 QualType Result = TL.getType();
3007 if (getDerived().AlwaysRebuild() ||
3008 Typedef != T->getDecl()) {
3009 Result = getDerived().RebuildTypedefType(Typedef);
3010 if (Result.isNull())
3014 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result);
3015 NewTL.setNameLoc(TL.getNameLoc());
3020 template<typename Derived>
3021 QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
3022 TypeOfExprTypeLoc TL,
3023 QualType ObjectType) {
3024 // typeof expressions are not potentially evaluated contexts
3025 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
3027 Sema::OwningExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
3031 QualType Result = TL.getType();
3032 if (getDerived().AlwaysRebuild() ||
3033 E.get() != TL.getUnderlyingExpr()) {
3034 Result = getDerived().RebuildTypeOfExprType(move(E));
3035 if (Result.isNull())
3040 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result);
3041 NewTL.setTypeofLoc(TL.getTypeofLoc());
3042 NewTL.setLParenLoc(TL.getLParenLoc());
3043 NewTL.setRParenLoc(TL.getRParenLoc());
3048 template<typename Derived>
3049 QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
3051 QualType ObjectType) {
3052 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo();
3053 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);
3057 QualType Result = TL.getType();
3058 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {
3059 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType());
3060 if (Result.isNull())
3064 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result);
3065 NewTL.setTypeofLoc(TL.getTypeofLoc());
3066 NewTL.setLParenLoc(TL.getLParenLoc());
3067 NewTL.setRParenLoc(TL.getRParenLoc());
3068 NewTL.setUnderlyingTInfo(New_Under_TI);
3073 template<typename Derived>
3074 QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
3076 QualType ObjectType) {
3077 DecltypeType *T = TL.getTypePtr();
3079 // decltype expressions are not potentially evaluated contexts
3080 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
3082 Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
3086 QualType Result = TL.getType();
3087 if (getDerived().AlwaysRebuild() ||
3088 E.get() != T->getUnderlyingExpr()) {
3089 Result = getDerived().RebuildDecltypeType(move(E));
3090 if (Result.isNull())
3095 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
3096 NewTL.setNameLoc(TL.getNameLoc());
3101 template<typename Derived>
3102 QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,
3104 QualType ObjectType) {
3105 RecordType *T = TL.getTypePtr();
3107 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(),
3112 QualType Result = TL.getType();
3113 if (getDerived().AlwaysRebuild() ||
3114 Record != T->getDecl()) {
3115 Result = getDerived().RebuildRecordType(Record);
3116 if (Result.isNull())
3120 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
3121 NewTL.setNameLoc(TL.getNameLoc());
3126 template<typename Derived>
3127 QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
3129 QualType ObjectType) {
3130 EnumType *T = TL.getTypePtr();
3132 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(),
3137 QualType Result = TL.getType();
3138 if (getDerived().AlwaysRebuild() ||
3139 Enum != T->getDecl()) {
3140 Result = getDerived().RebuildEnumType(Enum);
3141 if (Result.isNull())
3145 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result);
3146 NewTL.setNameLoc(TL.getNameLoc());
3151 template<typename Derived>
3152 QualType TreeTransform<Derived>::TransformInjectedClassNameType(
3153 TypeLocBuilder &TLB,
3154 InjectedClassNameTypeLoc TL,
3155 QualType ObjectType) {
3156 Decl *D = getDerived().TransformDecl(TL.getNameLoc(),
3157 TL.getTypePtr()->getDecl());
3158 if (!D) return QualType();
3160 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D));
3161 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc());
3166 template<typename Derived>
3167 QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
3168 TypeLocBuilder &TLB,
3169 TemplateTypeParmTypeLoc TL,
3170 QualType ObjectType) {
3171 return TransformTypeSpecType(TLB, TL);
3174 template<typename Derived>
3175 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
3176 TypeLocBuilder &TLB,
3177 SubstTemplateTypeParmTypeLoc TL,
3178 QualType ObjectType) {
3179 return TransformTypeSpecType(TLB, TL);
3182 template<typename Derived>
3183 QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
3184 const TemplateSpecializationType *TST,
3185 QualType ObjectType) {
3186 // FIXME: this entire method is a temporary workaround; callers
3187 // should be rewritten to provide real type locs.
3189 // Fake up a TemplateSpecializationTypeLoc.
3191 TemplateSpecializationTypeLoc TL
3192 = TLB.push<TemplateSpecializationTypeLoc>(QualType(TST, 0));
3194 SourceLocation BaseLoc = getDerived().getBaseLocation();
3196 TL.setTemplateNameLoc(BaseLoc);
3197 TL.setLAngleLoc(BaseLoc);
3198 TL.setRAngleLoc(BaseLoc);
3199 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
3200 const TemplateArgument &TA = TST->getArg(i);
3201 TemplateArgumentLoc TAL;
3202 getDerived().InventTemplateArgumentLoc(TA, TAL);
3203 TL.setArgLocInfo(i, TAL.getLocInfo());
3206 TypeLocBuilder IgnoredTLB;
3207 return TransformTemplateSpecializationType(IgnoredTLB, TL, ObjectType);
3210 template<typename Derived>
3211 QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
3212 TypeLocBuilder &TLB,
3213 TemplateSpecializationTypeLoc TL,
3214 QualType ObjectType) {
3215 const TemplateSpecializationType *T = TL.getTypePtr();
3217 TemplateName Template
3218 = getDerived().TransformTemplateName(T->getTemplateName(), ObjectType);
3219 if (Template.isNull())
3222 TemplateArgumentListInfo NewTemplateArgs;
3223 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
3224 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
3226 for (unsigned i = 0, e = T->getNumArgs(); i != e; ++i) {
3227 TemplateArgumentLoc Loc;
3228 if (getDerived().TransformTemplateArgument(TL.getArgLoc(i), Loc))
3230 NewTemplateArgs.addArgument(Loc);
3233 // FIXME: maybe don't rebuild if all the template arguments are the same.
3236 getDerived().RebuildTemplateSpecializationType(Template,
3237 TL.getTemplateNameLoc(),
3240 if (!Result.isNull()) {
3241 TemplateSpecializationTypeLoc NewTL
3242 = TLB.push<TemplateSpecializationTypeLoc>(Result);
3243 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
3244 NewTL.setLAngleLoc(TL.getLAngleLoc());
3245 NewTL.setRAngleLoc(TL.getRAngleLoc());
3246 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
3247 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
3253 template<typename Derived>
3255 TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB,
3256 ElaboratedTypeLoc TL,
3257 QualType ObjectType) {
3258 ElaboratedType *T = TL.getTypePtr();
3260 NestedNameSpecifier *NNS = 0;
3261 // NOTE: the qualifier in an ElaboratedType is optional.
3262 if (T->getQualifier() != 0) {
3263 NNS = getDerived().TransformNestedNameSpecifier(T->getQualifier(),
3264 TL.getQualifierRange(),
3271 // FIXME: this test is meant to workaround a problem (failing assertion)
3272 // occurring if directly executing the code in the else branch.
3273 if (isa<TemplateSpecializationTypeLoc>(TL.getNamedTypeLoc())) {
3274 TemplateSpecializationTypeLoc OldNamedTL
3275 = cast<TemplateSpecializationTypeLoc>(TL.getNamedTypeLoc());
3276 const TemplateSpecializationType* OldTST
3277 = OldNamedTL.getType()->template getAs<TemplateSpecializationType>();
3278 NamedT = TransformTemplateSpecializationType(OldTST, ObjectType);
3279 if (NamedT.isNull())
3281 TemplateSpecializationTypeLoc NewNamedTL
3282 = TLB.push<TemplateSpecializationTypeLoc>(NamedT);
3283 NewNamedTL.copy(OldNamedTL);
3286 NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc());
3287 if (NamedT.isNull())
3291 QualType Result = TL.getType();
3292 if (getDerived().AlwaysRebuild() ||
3293 NNS != T->getQualifier() ||
3294 NamedT != T->getNamedType()) {
3295 Result = getDerived().RebuildElaboratedType(T->getKeyword(), NNS, NamedT);
3296 if (Result.isNull())
3300 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
3301 NewTL.setKeywordLoc(TL.getKeywordLoc());
3302 NewTL.setQualifierRange(TL.getQualifierRange());
3307 template<typename Derived>
3308 QualType TreeTransform<Derived>::TransformDependentNameType(TypeLocBuilder &TLB,
3309 DependentNameTypeLoc TL,
3310 QualType ObjectType) {
3311 DependentNameType *T = TL.getTypePtr();
3313 NestedNameSpecifier *NNS
3314 = getDerived().TransformNestedNameSpecifier(T->getQualifier(),
3315 TL.getQualifierRange(),
3321 = getDerived().RebuildDependentNameType(T->getKeyword(), NNS,
3324 TL.getQualifierRange(),
3326 if (Result.isNull())
3329 if (const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) {
3330 QualType NamedT = ElabT->getNamedType();
3331 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc());
3333 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
3334 NewTL.setKeywordLoc(TL.getKeywordLoc());
3335 NewTL.setQualifierRange(TL.getQualifierRange());
3337 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result);
3338 NewTL.setKeywordLoc(TL.getKeywordLoc());
3339 NewTL.setQualifierRange(TL.getQualifierRange());
3340 NewTL.setNameLoc(TL.getNameLoc());
3345 template<typename Derived>
3346 QualType TreeTransform<Derived>::
3347 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
3348 DependentTemplateSpecializationTypeLoc TL,
3349 QualType ObjectType) {
3350 DependentTemplateSpecializationType *T = TL.getTypePtr();
3352 NestedNameSpecifier *NNS
3353 = getDerived().TransformNestedNameSpecifier(T->getQualifier(),
3354 TL.getQualifierRange(),
3359 TemplateArgumentListInfo NewTemplateArgs;
3360 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
3361 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
3363 for (unsigned I = 0, E = T->getNumArgs(); I != E; ++I) {
3364 TemplateArgumentLoc Loc;
3365 if (getDerived().TransformTemplateArgument(TL.getArgLoc(I), Loc))
3367 NewTemplateArgs.addArgument(Loc);
3370 QualType Result = getDerived().RebuildDependentTemplateSpecializationType(
3376 if (Result.isNull())
3379 if (const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) {
3380 QualType NamedT = ElabT->getNamedType();
3382 // Copy information relevant to the template specialization.
3383 TemplateSpecializationTypeLoc NamedTL
3384 = TLB.push<TemplateSpecializationTypeLoc>(NamedT);
3385 NamedTL.setLAngleLoc(TL.getLAngleLoc());
3386 NamedTL.setRAngleLoc(TL.getRAngleLoc());
3387 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
3388 NamedTL.setArgLocInfo(I, TL.getArgLocInfo(I));
3390 // Copy information relevant to the elaborated type.
3391 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
3392 NewTL.setKeywordLoc(TL.getKeywordLoc());
3393 NewTL.setQualifierRange(TL.getQualifierRange());
3395 TypeLoc NewTL(Result, TL.getOpaqueData());
3396 TLB.pushFullCopy(NewTL);
3401 template<typename Derived>
3403 TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
3404 ObjCInterfaceTypeLoc TL,
3405 QualType ObjectType) {
3406 // ObjCInterfaceType is never dependent.
3407 TLB.pushFullCopy(TL);
3408 return TL.getType();
3411 template<typename Derived>
3413 TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
3414 ObjCObjectTypeLoc TL,
3415 QualType ObjectType) {
3416 // ObjCObjectType is never dependent.
3417 TLB.pushFullCopy(TL);
3418 return TL.getType();
3421 template<typename Derived>
3423 TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
3424 ObjCObjectPointerTypeLoc TL,
3425 QualType ObjectType) {
3426 // ObjCObjectPointerType is never dependent.
3427 TLB.pushFullCopy(TL);
3428 return TL.getType();
3431 //===----------------------------------------------------------------------===//
3432 // Statement transformation
3433 //===----------------------------------------------------------------------===//
3434 template<typename Derived>
3435 Sema::OwningStmtResult
3436 TreeTransform<Derived>::TransformNullStmt(NullStmt *S) {
3437 return SemaRef.Owned(S->Retain());
3440 template<typename Derived>
3441 Sema::OwningStmtResult
3442 TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) {
3443 return getDerived().TransformCompoundStmt(S, false);
3446 template<typename Derived>
3447 Sema::OwningStmtResult
3448 TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S,
3450 bool SubStmtChanged = false;
3451 ASTOwningVector<&ActionBase::DeleteStmt> Statements(getSema());
3452 for (CompoundStmt::body_iterator B = S->body_begin(), BEnd = S->body_end();
3454 OwningStmtResult Result = getDerived().TransformStmt(*B);
3455 if (Result.isInvalid())
3456 return getSema().StmtError();
3458 SubStmtChanged = SubStmtChanged || Result.get() != *B;
3459 Statements.push_back(Result.takeAs<Stmt>());
3462 if (!getDerived().AlwaysRebuild() &&
3464 return SemaRef.Owned(S->Retain());
3466 return getDerived().RebuildCompoundStmt(S->getLBracLoc(),
3467 move_arg(Statements),
3472 template<typename Derived>
3473 Sema::OwningStmtResult
3474 TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
3475 OwningExprResult LHS(SemaRef), RHS(SemaRef);
3477 // The case value expressions are not potentially evaluated.
3478 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
3480 // Transform the left-hand case value.
3481 LHS = getDerived().TransformExpr(S->getLHS());
3482 if (LHS.isInvalid())
3483 return SemaRef.StmtError();
3485 // Transform the right-hand case value (for the GNU case-range extension).
3486 RHS = getDerived().TransformExpr(S->getRHS());
3487 if (RHS.isInvalid())
3488 return SemaRef.StmtError();
3491 // Build the case statement.
3492 // Case statements are always rebuilt so that they will attached to their
3493 // transformed switch statement.
3494 OwningStmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
3496 S->getEllipsisLoc(),
3499 if (Case.isInvalid())
3500 return SemaRef.StmtError();
3502 // Transform the statement following the case
3503 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
3504 if (SubStmt.isInvalid())
3505 return SemaRef.StmtError();
3507 // Attach the body to the case statement
3508 return getDerived().RebuildCaseStmtBody(move(Case), move(SubStmt));
3511 template<typename Derived>
3512 Sema::OwningStmtResult
3513 TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
3514 // Transform the statement following the default case
3515 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
3516 if (SubStmt.isInvalid())
3517 return SemaRef.StmtError();
3519 // Default statements are always rebuilt
3520 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
3524 template<typename Derived>
3525 Sema::OwningStmtResult
3526 TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) {
3527 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
3528 if (SubStmt.isInvalid())
3529 return SemaRef.StmtError();
3531 // FIXME: Pass the real colon location in.
3532 SourceLocation ColonLoc = SemaRef.PP.getLocForEndOfToken(S->getIdentLoc());
3533 return getDerived().RebuildLabelStmt(S->getIdentLoc(), S->getID(), ColonLoc,
3537 template<typename Derived>
3538 Sema::OwningStmtResult
3539 TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
3540 // Transform the condition
3541 OwningExprResult Cond(SemaRef);
3542 VarDecl *ConditionVar = 0;
3543 if (S->getConditionVariable()) {
3545 = cast_or_null<VarDecl>(
3546 getDerived().TransformDefinition(
3547 S->getConditionVariable()->getLocation(),
3548 S->getConditionVariable()));
3550 return SemaRef.StmtError();
3552 Cond = getDerived().TransformExpr(S->getCond());
3554 if (Cond.isInvalid())
3555 return SemaRef.StmtError();
3557 // Convert the condition to a boolean value.
3559 OwningExprResult CondE = getSema().ActOnBooleanCondition(0,
3562 if (CondE.isInvalid())
3563 return getSema().StmtError();
3569 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond));
3570 if (!S->getConditionVariable() && S->getCond() && !FullCond->get())
3571 return SemaRef.StmtError();
3573 // Transform the "then" branch.
3574 OwningStmtResult Then = getDerived().TransformStmt(S->getThen());
3575 if (Then.isInvalid())
3576 return SemaRef.StmtError();
3578 // Transform the "else" branch.
3579 OwningStmtResult Else = getDerived().TransformStmt(S->getElse());
3580 if (Else.isInvalid())
3581 return SemaRef.StmtError();
3583 if (!getDerived().AlwaysRebuild() &&
3584 FullCond->get() == S->getCond() &&
3585 ConditionVar == S->getConditionVariable() &&
3586 Then.get() == S->getThen() &&
3587 Else.get() == S->getElse())
3588 return SemaRef.Owned(S->Retain());
3590 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar,
3592 S->getElseLoc(), move(Else));
3595 template<typename Derived>
3596 Sema::OwningStmtResult
3597 TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
3598 // Transform the condition.
3599 OwningExprResult Cond(SemaRef);
3600 VarDecl *ConditionVar = 0;
3601 if (S->getConditionVariable()) {
3603 = cast_or_null<VarDecl>(
3604 getDerived().TransformDefinition(
3605 S->getConditionVariable()->getLocation(),
3606 S->getConditionVariable()));
3608 return SemaRef.StmtError();
3610 Cond = getDerived().TransformExpr(S->getCond());
3612 if (Cond.isInvalid())
3613 return SemaRef.StmtError();
3616 // Rebuild the switch statement.
3617 OwningStmtResult Switch
3618 = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), move(Cond),
3620 if (Switch.isInvalid())
3621 return SemaRef.StmtError();
3623 // Transform the body of the switch statement.
3624 OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3625 if (Body.isInvalid())
3626 return SemaRef.StmtError();
3628 // Complete the switch statement.
3629 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), move(Switch),
3633 template<typename Derived>
3634 Sema::OwningStmtResult
3635 TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
3636 // Transform the condition
3637 OwningExprResult Cond(SemaRef);
3638 VarDecl *ConditionVar = 0;
3639 if (S->getConditionVariable()) {
3641 = cast_or_null<VarDecl>(
3642 getDerived().TransformDefinition(
3643 S->getConditionVariable()->getLocation(),
3644 S->getConditionVariable()));
3646 return SemaRef.StmtError();
3648 Cond = getDerived().TransformExpr(S->getCond());
3650 if (Cond.isInvalid())
3651 return SemaRef.StmtError();
3654 // Convert the condition to a boolean value.
3655 OwningExprResult CondE = getSema().ActOnBooleanCondition(0,
3658 if (CondE.isInvalid())
3659 return getSema().StmtError();
3664 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond));
3665 if (!S->getConditionVariable() && S->getCond() && !FullCond->get())
3666 return SemaRef.StmtError();
3668 // Transform the body
3669 OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3670 if (Body.isInvalid())
3671 return SemaRef.StmtError();
3673 if (!getDerived().AlwaysRebuild() &&
3674 FullCond->get() == S->getCond() &&
3675 ConditionVar == S->getConditionVariable() &&
3676 Body.get() == S->getBody())
3677 return SemaRef.Owned(S->Retain());
3679 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond,
3680 ConditionVar, move(Body));
3683 template<typename Derived>
3684 Sema::OwningStmtResult
3685 TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
3686 // Transform the body
3687 OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3688 if (Body.isInvalid())
3689 return SemaRef.StmtError();
3691 // Transform the condition
3692 OwningExprResult Cond = getDerived().TransformExpr(S->getCond());
3693 if (Cond.isInvalid())
3694 return SemaRef.StmtError();
3696 if (!getDerived().AlwaysRebuild() &&
3697 Cond.get() == S->getCond() &&
3698 Body.get() == S->getBody())
3699 return SemaRef.Owned(S->Retain());
3701 return getDerived().RebuildDoStmt(S->getDoLoc(), move(Body), S->getWhileLoc(),
3702 /*FIXME:*/S->getWhileLoc(), move(Cond),
3706 template<typename Derived>
3707 Sema::OwningStmtResult
3708 TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
3709 // Transform the initialization statement
3710 OwningStmtResult Init = getDerived().TransformStmt(S->getInit());
3711 if (Init.isInvalid())
3712 return SemaRef.StmtError();
3714 // Transform the condition
3715 OwningExprResult Cond(SemaRef);
3716 VarDecl *ConditionVar = 0;
3717 if (S->getConditionVariable()) {
3719 = cast_or_null<VarDecl>(
3720 getDerived().TransformDefinition(
3721 S->getConditionVariable()->getLocation(),
3722 S->getConditionVariable()));
3724 return SemaRef.StmtError();
3726 Cond = getDerived().TransformExpr(S->getCond());
3728 if (Cond.isInvalid())
3729 return SemaRef.StmtError();
3732 // Convert the condition to a boolean value.
3733 OwningExprResult CondE = getSema().ActOnBooleanCondition(0,
3736 if (CondE.isInvalid())
3737 return getSema().StmtError();
3743 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond));
3744 if (!S->getConditionVariable() && S->getCond() && !FullCond->get())
3745 return SemaRef.StmtError();
3747 // Transform the increment
3748 OwningExprResult Inc = getDerived().TransformExpr(S->getInc());
3749 if (Inc.isInvalid())
3750 return SemaRef.StmtError();
3752 Sema::FullExprArg FullInc(getSema().MakeFullExpr(Inc));
3753 if (S->getInc() && !FullInc->get())
3754 return SemaRef.StmtError();
3756 // Transform the body
3757 OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3758 if (Body.isInvalid())
3759 return SemaRef.StmtError();
3761 if (!getDerived().AlwaysRebuild() &&
3762 Init.get() == S->getInit() &&
3763 FullCond->get() == S->getCond() &&
3764 Inc.get() == S->getInc() &&
3765 Body.get() == S->getBody())
3766 return SemaRef.Owned(S->Retain());
3768 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
3769 move(Init), FullCond, ConditionVar,
3770 FullInc, S->getRParenLoc(), move(Body));
3773 template<typename Derived>
3774 Sema::OwningStmtResult
3775 TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
3776 // Goto statements must always be rebuilt, to resolve the label.
3777 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
3781 template<typename Derived>
3782 Sema::OwningStmtResult
3783 TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
3784 OwningExprResult Target = getDerived().TransformExpr(S->getTarget());
3785 if (Target.isInvalid())
3786 return SemaRef.StmtError();
3788 if (!getDerived().AlwaysRebuild() &&
3789 Target.get() == S->getTarget())
3790 return SemaRef.Owned(S->Retain());
3792 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
3796 template<typename Derived>
3797 Sema::OwningStmtResult
3798 TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
3799 return SemaRef.Owned(S->Retain());
3802 template<typename Derived>
3803 Sema::OwningStmtResult
3804 TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
3805 return SemaRef.Owned(S->Retain());
3808 template<typename Derived>
3809 Sema::OwningStmtResult
3810 TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
3811 Sema::OwningExprResult Result = getDerived().TransformExpr(S->getRetValue());
3812 if (Result.isInvalid())
3813 return SemaRef.StmtError();
3815 // FIXME: We always rebuild the return statement because there is no way
3816 // to tell whether the return type of the function has changed.
3817 return getDerived().RebuildReturnStmt(S->getReturnLoc(), move(Result));
3820 template<typename Derived>
3821 Sema::OwningStmtResult
3822 TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
3823 bool DeclChanged = false;
3824 llvm::SmallVector<Decl *, 4> Decls;
3825 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end();
3827 Decl *Transformed = getDerived().TransformDefinition((*D)->getLocation(),
3830 return SemaRef.StmtError();
3832 if (Transformed != *D)
3835 Decls.push_back(Transformed);
3838 if (!getDerived().AlwaysRebuild() && !DeclChanged)
3839 return SemaRef.Owned(S->Retain());
3841 return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(),
3842 S->getStartLoc(), S->getEndLoc());
3845 template<typename Derived>
3846 Sema::OwningStmtResult
3847 TreeTransform<Derived>::TransformSwitchCase(SwitchCase *S) {
3848 assert(false && "SwitchCase is abstract and cannot be transformed");
3849 return SemaRef.Owned(S->Retain());
3852 template<typename Derived>
3853 Sema::OwningStmtResult
3854 TreeTransform<Derived>::TransformAsmStmt(AsmStmt *S) {
3856 ASTOwningVector<&ActionBase::DeleteExpr> Constraints(getSema());
3857 ASTOwningVector<&ActionBase::DeleteExpr> Exprs(getSema());
3858 llvm::SmallVector<IdentifierInfo *, 4> Names;
3860 OwningExprResult AsmString(SemaRef);
3861 ASTOwningVector<&ActionBase::DeleteExpr> Clobbers(getSema());
3863 bool ExprsChanged = false;
3865 // Go through the outputs.
3866 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) {
3867 Names.push_back(S->getOutputIdentifier(I));
3869 // No need to transform the constraint literal.
3870 Constraints.push_back(S->getOutputConstraintLiteral(I)->Retain());
3872 // Transform the output expr.
3873 Expr *OutputExpr = S->getOutputExpr(I);
3874 OwningExprResult Result = getDerived().TransformExpr(OutputExpr);
3875 if (Result.isInvalid())
3876 return SemaRef.StmtError();
3878 ExprsChanged |= Result.get() != OutputExpr;
3880 Exprs.push_back(Result.takeAs<Expr>());
3883 // Go through the inputs.
3884 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) {
3885 Names.push_back(S->getInputIdentifier(I));
3887 // No need to transform the constraint literal.
3888 Constraints.push_back(S->getInputConstraintLiteral(I)->Retain());
3890 // Transform the input expr.
3891 Expr *InputExpr = S->getInputExpr(I);
3892 OwningExprResult Result = getDerived().TransformExpr(InputExpr);
3893 if (Result.isInvalid())
3894 return SemaRef.StmtError();
3896 ExprsChanged |= Result.get() != InputExpr;
3898 Exprs.push_back(Result.takeAs<Expr>());
3901 if (!getDerived().AlwaysRebuild() && !ExprsChanged)
3902 return SemaRef.Owned(S->Retain());
3904 // Go through the clobbers.
3905 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I)
3906 Clobbers.push_back(S->getClobber(I)->Retain());
3908 // No need to transform the asm string literal.
3909 AsmString = SemaRef.Owned(S->getAsmString());
3911 return getDerived().RebuildAsmStmt(S->getAsmLoc(),
3917 move_arg(Constraints),
3926 template<typename Derived>
3927 Sema::OwningStmtResult
3928 TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
3929 // Transform the body of the @try.
3930 OwningStmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
3931 if (TryBody.isInvalid())
3932 return SemaRef.StmtError();
3934 // Transform the @catch statements (if present).
3935 bool AnyCatchChanged = false;
3936 ASTOwningVector<&ActionBase::DeleteStmt> CatchStmts(SemaRef);
3937 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
3938 OwningStmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I));
3939 if (Catch.isInvalid())
3940 return SemaRef.StmtError();
3941 if (Catch.get() != S->getCatchStmt(I))
3942 AnyCatchChanged = true;
3943 CatchStmts.push_back(Catch.release());
3946 // Transform the @finally statement (if present).
3947 OwningStmtResult Finally(SemaRef);
3948 if (S->getFinallyStmt()) {
3949 Finally = getDerived().TransformStmt(S->getFinallyStmt());
3950 if (Finally.isInvalid())
3951 return SemaRef.StmtError();
3954 // If nothing changed, just retain this statement.
3955 if (!getDerived().AlwaysRebuild() &&
3956 TryBody.get() == S->getTryBody() &&
3958 Finally.get() == S->getFinallyStmt())
3959 return SemaRef.Owned(S->Retain());
3961 // Build a new statement.
3962 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), move(TryBody),
3963 move_arg(CatchStmts), move(Finally));
3966 template<typename Derived>
3967 Sema::OwningStmtResult
3968 TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
3969 // Transform the @catch parameter, if there is one.
3971 if (VarDecl *FromVar = S->getCatchParamDecl()) {
3972 TypeSourceInfo *TSInfo = 0;
3973 if (FromVar->getTypeSourceInfo()) {
3974 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
3976 return SemaRef.StmtError();
3981 T = TSInfo->getType();
3983 T = getDerived().TransformType(FromVar->getType());
3985 return SemaRef.StmtError();
3988 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T);
3990 return SemaRef.StmtError();
3993 OwningStmtResult Body = getDerived().TransformStmt(S->getCatchBody());
3994 if (Body.isInvalid())
3995 return SemaRef.StmtError();
3997 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
4002 template<typename Derived>
4003 Sema::OwningStmtResult
4004 TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
4005 // Transform the body.
4006 OwningStmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
4007 if (Body.isInvalid())
4008 return SemaRef.StmtError();
4010 // If nothing changed, just retain this statement.
4011 if (!getDerived().AlwaysRebuild() &&
4012 Body.get() == S->getFinallyBody())
4013 return SemaRef.Owned(S->Retain());
4015 // Build a new statement.
4016 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
4020 template<typename Derived>
4021 Sema::OwningStmtResult
4022 TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
4023 OwningExprResult Operand(SemaRef);
4024 if (S->getThrowExpr()) {
4025 Operand = getDerived().TransformExpr(S->getThrowExpr());
4026 if (Operand.isInvalid())
4027 return getSema().StmtError();
4030 if (!getDerived().AlwaysRebuild() &&
4031 Operand.get() == S->getThrowExpr())
4032 return getSema().Owned(S->Retain());
4034 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), move(Operand));
4037 template<typename Derived>
4038 Sema::OwningStmtResult
4039 TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
4040 ObjCAtSynchronizedStmt *S) {
4041 // Transform the object we are locking.
4042 OwningExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
4043 if (Object.isInvalid())
4044 return SemaRef.StmtError();
4046 // Transform the body.
4047 OwningStmtResult Body = getDerived().TransformStmt(S->getSynchBody());
4048 if (Body.isInvalid())
4049 return SemaRef.StmtError();
4051 // If nothing change, just retain the current statement.
4052 if (!getDerived().AlwaysRebuild() &&
4053 Object.get() == S->getSynchExpr() &&
4054 Body.get() == S->getSynchBody())
4055 return SemaRef.Owned(S->Retain());
4057 // Build a new statement.
4058 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
4059 move(Object), move(Body));
4062 template<typename Derived>
4063 Sema::OwningStmtResult
4064 TreeTransform<Derived>::TransformObjCForCollectionStmt(
4065 ObjCForCollectionStmt *S) {
4066 // Transform the element statement.
4067 OwningStmtResult Element = getDerived().TransformStmt(S->getElement());
4068 if (Element.isInvalid())
4069 return SemaRef.StmtError();
4071 // Transform the collection expression.
4072 OwningExprResult Collection = getDerived().TransformExpr(S->getCollection());
4073 if (Collection.isInvalid())
4074 return SemaRef.StmtError();
4076 // Transform the body.
4077 OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
4078 if (Body.isInvalid())
4079 return SemaRef.StmtError();
4081 // If nothing changed, just retain this statement.
4082 if (!getDerived().AlwaysRebuild() &&
4083 Element.get() == S->getElement() &&
4084 Collection.get() == S->getCollection() &&
4085 Body.get() == S->getBody())
4086 return SemaRef.Owned(S->Retain());
4088 // Build a new statement.
4089 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
4090 /*FIXME:*/S->getForLoc(),
4098 template<typename Derived>
4099 Sema::OwningStmtResult
4100 TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
4101 // Transform the exception declaration, if any.
4103 if (S->getExceptionDecl()) {
4104 VarDecl *ExceptionDecl = S->getExceptionDecl();
4105 TemporaryBase Rebase(*this, ExceptionDecl->getLocation(),
4106 ExceptionDecl->getDeclName());
4108 QualType T = getDerived().TransformType(ExceptionDecl->getType());
4110 return SemaRef.StmtError();
4112 Var = getDerived().RebuildExceptionDecl(ExceptionDecl,
4114 ExceptionDecl->getTypeSourceInfo(),
4115 ExceptionDecl->getIdentifier(),
4116 ExceptionDecl->getLocation(),
4117 /*FIXME: Inaccurate*/
4118 SourceRange(ExceptionDecl->getLocation()));
4119 if (!Var || Var->isInvalidDecl()) {
4121 Var->Destroy(SemaRef.Context);
4122 return SemaRef.StmtError();
4126 // Transform the actual exception handler.
4127 OwningStmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
4128 if (Handler.isInvalid()) {
4130 Var->Destroy(SemaRef.Context);
4131 return SemaRef.StmtError();
4134 if (!getDerived().AlwaysRebuild() &&
4136 Handler.get() == S->getHandlerBlock())
4137 return SemaRef.Owned(S->Retain());
4139 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(),
4144 template<typename Derived>
4145 Sema::OwningStmtResult
4146 TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
4147 // Transform the try block itself.
4148 OwningStmtResult TryBlock
4149 = getDerived().TransformCompoundStmt(S->getTryBlock());
4150 if (TryBlock.isInvalid())
4151 return SemaRef.StmtError();
4153 // Transform the handlers.
4154 bool HandlerChanged = false;
4155 ASTOwningVector<&ActionBase::DeleteStmt> Handlers(SemaRef);
4156 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) {
4157 OwningStmtResult Handler
4158 = getDerived().TransformCXXCatchStmt(S->getHandler(I));
4159 if (Handler.isInvalid())
4160 return SemaRef.StmtError();
4162 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I);
4163 Handlers.push_back(Handler.takeAs<Stmt>());
4166 if (!getDerived().AlwaysRebuild() &&
4167 TryBlock.get() == S->getTryBlock() &&
4169 return SemaRef.Owned(S->Retain());
4171 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), move(TryBlock),
4172 move_arg(Handlers));
4175 //===----------------------------------------------------------------------===//
4176 // Expression transformation
4177 //===----------------------------------------------------------------------===//
4178 template<typename Derived>
4179 Sema::OwningExprResult
4180 TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) {
4181 return SemaRef.Owned(E->Retain());
4184 template<typename Derived>
4185 Sema::OwningExprResult
4186 TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) {
4187 NestedNameSpecifier *Qualifier = 0;
4188 if (E->getQualifier()) {
4189 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
4190 E->getQualifierRange());
4192 return SemaRef.ExprError();
4196 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
4199 return SemaRef.ExprError();
4201 if (!getDerived().AlwaysRebuild() &&
4202 Qualifier == E->getQualifier() &&
4203 ND == E->getDecl() &&
4204 !E->hasExplicitTemplateArgumentList()) {
4206 // Mark it referenced in the new context regardless.
4207 // FIXME: this is a bit instantiation-specific.
4208 SemaRef.MarkDeclarationReferenced(E->getLocation(), ND);
4210 return SemaRef.Owned(E->Retain());
4213 TemplateArgumentListInfo TransArgs, *TemplateArgs = 0;
4214 if (E->hasExplicitTemplateArgumentList()) {
4215 TemplateArgs = &TransArgs;
4216 TransArgs.setLAngleLoc(E->getLAngleLoc());
4217 TransArgs.setRAngleLoc(E->getRAngleLoc());
4218 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
4219 TemplateArgumentLoc Loc;
4220 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc))
4221 return SemaRef.ExprError();
4222 TransArgs.addArgument(Loc);
4226 return getDerived().RebuildDeclRefExpr(Qualifier, E->getQualifierRange(),
4227 ND, E->getLocation(), TemplateArgs);
4230 template<typename Derived>
4231 Sema::OwningExprResult
4232 TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) {
4233 return SemaRef.Owned(E->Retain());
4236 template<typename Derived>
4237 Sema::OwningExprResult
4238 TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) {
4239 return SemaRef.Owned(E->Retain());
4242 template<typename Derived>
4243 Sema::OwningExprResult
4244 TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) {
4245 return SemaRef.Owned(E->Retain());
4248 template<typename Derived>
4249 Sema::OwningExprResult
4250 TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) {
4251 return SemaRef.Owned(E->Retain());
4254 template<typename Derived>
4255 Sema::OwningExprResult
4256 TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) {
4257 return SemaRef.Owned(E->Retain());
4260 template<typename Derived>
4261 Sema::OwningExprResult
4262 TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
4263 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
4264 if (SubExpr.isInvalid())
4265 return SemaRef.ExprError();
4267 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
4268 return SemaRef.Owned(E->Retain());
4270 return getDerived().RebuildParenExpr(move(SubExpr), E->getLParen(),
4274 template<typename Derived>
4275 Sema::OwningExprResult
4276 TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) {
4277 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
4278 if (SubExpr.isInvalid())
4279 return SemaRef.ExprError();
4281 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
4282 return SemaRef.Owned(E->Retain());
4284 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(),
4289 template<typename Derived>
4290 Sema::OwningExprResult
4291 TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) {
4292 // Transform the type.
4293 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
4295 return getSema().ExprError();
4297 // Transform all of the components into components similar to what the
4299 // FIXME: It would be slightly more efficient in the non-dependent case to
4300 // just map FieldDecls, rather than requiring the rebuilder to look for
4301 // the fields again. However, __builtin_offsetof is rare enough in
4302 // template code that we don't care.
4303 bool ExprChanged = false;
4304 typedef Action::OffsetOfComponent Component;
4305 typedef OffsetOfExpr::OffsetOfNode Node;
4306 llvm::SmallVector<Component, 4> Components;
4307 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
4308 const Node &ON = E->getComponent(I);
4310 Comp.isBrackets = true;
4311 Comp.LocStart = ON.getRange().getBegin();
4312 Comp.LocEnd = ON.getRange().getEnd();
4313 switch (ON.getKind()) {
4315 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex());
4316 OwningExprResult Index = getDerived().TransformExpr(FromIndex);
4317 if (Index.isInvalid())
4318 return getSema().ExprError();
4320 ExprChanged = ExprChanged || Index.get() != FromIndex;
4321 Comp.isBrackets = true;
4322 Comp.U.E = Index.takeAs<Expr>(); // FIXME: leaked
4327 case Node::Identifier:
4328 Comp.isBrackets = false;
4329 Comp.U.IdentInfo = ON.getFieldName();
4330 if (!Comp.U.IdentInfo)
4336 // Will be recomputed during the rebuild.
4340 Components.push_back(Comp);
4343 // If nothing changed, retain the existing expression.
4344 if (!getDerived().AlwaysRebuild() &&
4345 Type == E->getTypeSourceInfo() &&
4347 return SemaRef.Owned(E->Retain());
4349 // Build a new offsetof expression.
4350 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type,
4351 Components.data(), Components.size(),
4355 template<typename Derived>
4356 Sema::OwningExprResult
4357 TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
4358 if (E->isArgumentType()) {
4359 TypeSourceInfo *OldT = E->getArgumentTypeInfo();
4361 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
4363 return SemaRef.ExprError();
4365 if (!getDerived().AlwaysRebuild() && OldT == NewT)
4366 return SemaRef.Owned(E->Retain());
4368 return getDerived().RebuildSizeOfAlignOf(NewT, E->getOperatorLoc(),
4370 E->getSourceRange());
4373 Sema::OwningExprResult SubExpr(SemaRef);
4375 // C++0x [expr.sizeof]p1:
4376 // The operand is either an expression, which is an unevaluated operand
4378 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
4380 SubExpr = getDerived().TransformExpr(E->getArgumentExpr());
4381 if (SubExpr.isInvalid())
4382 return SemaRef.ExprError();
4384 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
4385 return SemaRef.Owned(E->Retain());
4388 return getDerived().RebuildSizeOfAlignOf(move(SubExpr), E->getOperatorLoc(),
4390 E->getSourceRange());
4393 template<typename Derived>
4394 Sema::OwningExprResult
4395 TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
4396 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS());
4397 if (LHS.isInvalid())
4398 return SemaRef.ExprError();
4400 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS());
4401 if (RHS.isInvalid())
4402 return SemaRef.ExprError();
4405 if (!getDerived().AlwaysRebuild() &&
4406 LHS.get() == E->getLHS() &&
4407 RHS.get() == E->getRHS())
4408 return SemaRef.Owned(E->Retain());
4410 return getDerived().RebuildArraySubscriptExpr(move(LHS),
4411 /*FIXME:*/E->getLHS()->getLocStart(),
4413 E->getRBracketLoc());
4416 template<typename Derived>
4417 Sema::OwningExprResult
4418 TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
4419 // Transform the callee.
4420 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee());
4421 if (Callee.isInvalid())
4422 return SemaRef.ExprError();
4424 // Transform arguments.
4425 bool ArgChanged = false;
4426 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
4427 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs;
4428 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
4429 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I));
4430 if (Arg.isInvalid())
4431 return SemaRef.ExprError();
4433 // FIXME: Wrong source location information for the ','.
4434 FakeCommaLocs.push_back(
4435 SemaRef.PP.getLocForEndOfToken(E->getArg(I)->getSourceRange().getEnd()));
4437 ArgChanged = ArgChanged || Arg.get() != E->getArg(I);
4438 Args.push_back(Arg.takeAs<Expr>());
4441 if (!getDerived().AlwaysRebuild() &&
4442 Callee.get() == E->getCallee() &&
4444 return SemaRef.Owned(E->Retain());
4446 // FIXME: Wrong source location information for the '('.
4447 SourceLocation FakeLParenLoc
4448 = ((Expr *)Callee.get())->getSourceRange().getBegin();
4449 return getDerived().RebuildCallExpr(move(Callee), FakeLParenLoc,
4451 FakeCommaLocs.data(),
4455 template<typename Derived>
4456 Sema::OwningExprResult
4457 TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
4458 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
4459 if (Base.isInvalid())
4460 return SemaRef.ExprError();
4462 NestedNameSpecifier *Qualifier = 0;
4463 if (E->hasQualifier()) {
4465 = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
4466 E->getQualifierRange());
4468 return SemaRef.ExprError();
4472 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
4473 E->getMemberDecl()));
4475 return SemaRef.ExprError();
4477 NamedDecl *FoundDecl = E->getFoundDecl();
4478 if (FoundDecl == E->getMemberDecl()) {
4481 FoundDecl = cast_or_null<NamedDecl>(
4482 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl));
4484 return SemaRef.ExprError();
4487 if (!getDerived().AlwaysRebuild() &&
4488 Base.get() == E->getBase() &&
4489 Qualifier == E->getQualifier() &&
4490 Member == E->getMemberDecl() &&
4491 FoundDecl == E->getFoundDecl() &&
4492 !E->hasExplicitTemplateArgumentList()) {
4494 // Mark it referenced in the new context regardless.
4495 // FIXME: this is a bit instantiation-specific.
4496 SemaRef.MarkDeclarationReferenced(E->getMemberLoc(), Member);
4497 return SemaRef.Owned(E->Retain());
4500 TemplateArgumentListInfo TransArgs;
4501 if (E->hasExplicitTemplateArgumentList()) {
4502 TransArgs.setLAngleLoc(E->getLAngleLoc());
4503 TransArgs.setRAngleLoc(E->getRAngleLoc());
4504 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
4505 TemplateArgumentLoc Loc;
4506 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc))
4507 return SemaRef.ExprError();
4508 TransArgs.addArgument(Loc);
4512 // FIXME: Bogus source location for the operator
4513 SourceLocation FakeOperatorLoc
4514 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd());
4516 // FIXME: to do this check properly, we will need to preserve the
4517 // first-qualifier-in-scope here, just in case we had a dependent
4518 // base (and therefore couldn't do the check) and a
4519 // nested-name-qualifier (and therefore could do the lookup).
4520 NamedDecl *FirstQualifierInScope = 0;
4522 return getDerived().RebuildMemberExpr(move(Base), FakeOperatorLoc,
4525 E->getQualifierRange(),
4529 (E->hasExplicitTemplateArgumentList()
4531 FirstQualifierInScope);
4534 template<typename Derived>
4535 Sema::OwningExprResult
4536 TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
4537 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS());
4538 if (LHS.isInvalid())
4539 return SemaRef.ExprError();
4541 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS());
4542 if (RHS.isInvalid())
4543 return SemaRef.ExprError();
4545 if (!getDerived().AlwaysRebuild() &&
4546 LHS.get() == E->getLHS() &&
4547 RHS.get() == E->getRHS())
4548 return SemaRef.Owned(E->Retain());
4550 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
4551 move(LHS), move(RHS));
4554 template<typename Derived>
4555 Sema::OwningExprResult
4556 TreeTransform<Derived>::TransformCompoundAssignOperator(
4557 CompoundAssignOperator *E) {
4558 return getDerived().TransformBinaryOperator(E);
4561 template<typename Derived>
4562 Sema::OwningExprResult
4563 TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) {
4564 OwningExprResult Cond = getDerived().TransformExpr(E->getCond());
4565 if (Cond.isInvalid())
4566 return SemaRef.ExprError();
4568 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS());
4569 if (LHS.isInvalid())
4570 return SemaRef.ExprError();
4572 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS());
4573 if (RHS.isInvalid())
4574 return SemaRef.ExprError();
4576 if (!getDerived().AlwaysRebuild() &&
4577 Cond.get() == E->getCond() &&
4578 LHS.get() == E->getLHS() &&
4579 RHS.get() == E->getRHS())
4580 return SemaRef.Owned(E->Retain());
4582 return getDerived().RebuildConditionalOperator(move(Cond),
4583 E->getQuestionLoc(),
4589 template<typename Derived>
4590 Sema::OwningExprResult
4591 TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) {
4592 // Implicit casts are eliminated during transformation, since they
4593 // will be recomputed by semantic analysis after transformation.
4594 return getDerived().TransformExpr(E->getSubExprAsWritten());
4597 template<typename Derived>
4598 Sema::OwningExprResult
4599 TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
4600 TypeSourceInfo *OldT;
4601 TypeSourceInfo *NewT;
4603 // FIXME: Source location isn't quite accurate.
4604 SourceLocation TypeStartLoc
4605 = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc());
4606 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName());
4608 OldT = E->getTypeInfoAsWritten();
4609 NewT = getDerived().TransformType(OldT);
4611 return SemaRef.ExprError();
4614 OwningExprResult SubExpr
4615 = getDerived().TransformExpr(E->getSubExprAsWritten());
4616 if (SubExpr.isInvalid())
4617 return SemaRef.ExprError();
4619 if (!getDerived().AlwaysRebuild() &&
4621 SubExpr.get() == E->getSubExpr())
4622 return SemaRef.Owned(E->Retain());
4624 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
4630 template<typename Derived>
4631 Sema::OwningExprResult
4632 TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) {
4633 TypeSourceInfo *OldT = E->getTypeSourceInfo();
4634 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
4636 return SemaRef.ExprError();
4638 OwningExprResult Init = getDerived().TransformExpr(E->getInitializer());
4639 if (Init.isInvalid())
4640 return SemaRef.ExprError();
4642 if (!getDerived().AlwaysRebuild() &&
4644 Init.get() == E->getInitializer())
4645 return SemaRef.Owned(E->Retain());
4647 // Note: the expression type doesn't necessarily match the
4648 // type-as-written, but that's okay, because it should always be
4649 // derivable from the initializer.
4651 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT,
4652 /*FIXME:*/E->getInitializer()->getLocEnd(),
4656 template<typename Derived>
4657 Sema::OwningExprResult
4658 TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) {
4659 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
4660 if (Base.isInvalid())
4661 return SemaRef.ExprError();
4663 if (!getDerived().AlwaysRebuild() &&
4664 Base.get() == E->getBase())
4665 return SemaRef.Owned(E->Retain());
4667 // FIXME: Bad source location
4668 SourceLocation FakeOperatorLoc
4669 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd());
4670 return getDerived().RebuildExtVectorElementExpr(move(Base), FakeOperatorLoc,
4671 E->getAccessorLoc(),
4675 template<typename Derived>
4676 Sema::OwningExprResult
4677 TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) {
4678 bool InitChanged = false;
4680 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef);
4681 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) {
4682 OwningExprResult Init = getDerived().TransformExpr(E->getInit(I));
4683 if (Init.isInvalid())
4684 return SemaRef.ExprError();
4686 InitChanged = InitChanged || Init.get() != E->getInit(I);
4687 Inits.push_back(Init.takeAs<Expr>());
4690 if (!getDerived().AlwaysRebuild() && !InitChanged)
4691 return SemaRef.Owned(E->Retain());
4693 return getDerived().RebuildInitList(E->getLBraceLoc(), move_arg(Inits),
4694 E->getRBraceLoc(), E->getType());
4697 template<typename Derived>
4698 Sema::OwningExprResult
4699 TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) {
4702 // transform the initializer value
4703 OwningExprResult Init = getDerived().TransformExpr(E->getInit());
4704 if (Init.isInvalid())
4705 return SemaRef.ExprError();
4707 // transform the designators.
4708 ASTOwningVector<&ActionBase::DeleteExpr, 4> ArrayExprs(SemaRef);
4709 bool ExprChanged = false;
4710 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(),
4711 DEnd = E->designators_end();
4713 if (D->isFieldDesignator()) {
4714 Desig.AddDesignator(Designator::getField(D->getFieldName(),
4720 if (D->isArrayDesignator()) {
4721 OwningExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D));
4722 if (Index.isInvalid())
4723 return SemaRef.ExprError();
4725 Desig.AddDesignator(Designator::getArray(Index.get(),
4726 D->getLBracketLoc()));
4728 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D);
4729 ArrayExprs.push_back(Index.release());
4733 assert(D->isArrayRangeDesignator() && "New kind of designator?");
4734 OwningExprResult Start
4735 = getDerived().TransformExpr(E->getArrayRangeStart(*D));
4736 if (Start.isInvalid())
4737 return SemaRef.ExprError();
4739 OwningExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D));
4740 if (End.isInvalid())
4741 return SemaRef.ExprError();
4743 Desig.AddDesignator(Designator::getArrayRange(Start.get(),
4745 D->getLBracketLoc(),
4746 D->getEllipsisLoc()));
4748 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) ||
4749 End.get() != E->getArrayRangeEnd(*D);
4751 ArrayExprs.push_back(Start.release());
4752 ArrayExprs.push_back(End.release());
4755 if (!getDerived().AlwaysRebuild() &&
4756 Init.get() == E->getInit() &&
4758 return SemaRef.Owned(E->Retain());
4760 return getDerived().RebuildDesignatedInitExpr(Desig, move_arg(ArrayExprs),
4761 E->getEqualOrColonLoc(),
4762 E->usesGNUSyntax(), move(Init));
4765 template<typename Derived>
4766 Sema::OwningExprResult
4767 TreeTransform<Derived>::TransformImplicitValueInitExpr(
4768 ImplicitValueInitExpr *E) {
4769 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName());
4771 // FIXME: Will we ever have proper type location here? Will we actually
4772 // need to transform the type?
4773 QualType T = getDerived().TransformType(E->getType());
4775 return SemaRef.ExprError();
4777 if (!getDerived().AlwaysRebuild() &&
4779 return SemaRef.Owned(E->Retain());
4781 return getDerived().RebuildImplicitValueInitExpr(T);
4784 template<typename Derived>
4785 Sema::OwningExprResult
4786 TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) {
4787 // FIXME: Do we want the type as written?
4791 // FIXME: Source location isn't quite accurate.
4792 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName());
4793 T = getDerived().TransformType(E->getType());
4795 return SemaRef.ExprError();
4798 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
4799 if (SubExpr.isInvalid())
4800 return SemaRef.ExprError();
4802 if (!getDerived().AlwaysRebuild() &&
4803 T == E->getType() &&
4804 SubExpr.get() == E->getSubExpr())
4805 return SemaRef.Owned(E->Retain());
4807 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), move(SubExpr),
4808 T, E->getRParenLoc());
4811 template<typename Derived>
4812 Sema::OwningExprResult
4813 TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) {
4814 bool ArgumentChanged = false;
4815 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef);
4816 for (unsigned I = 0, N = E->getNumExprs(); I != N; ++I) {
4817 OwningExprResult Init = getDerived().TransformExpr(E->getExpr(I));
4818 if (Init.isInvalid())
4819 return SemaRef.ExprError();
4821 ArgumentChanged = ArgumentChanged || Init.get() != E->getExpr(I);
4822 Inits.push_back(Init.takeAs<Expr>());
4825 return getDerived().RebuildParenListExpr(E->getLParenLoc(),
4830 /// \brief Transform an address-of-label expression.
4832 /// By default, the transformation of an address-of-label expression always
4833 /// rebuilds the expression, so that the label identifier can be resolved to
4834 /// the corresponding label statement by semantic analysis.
4835 template<typename Derived>
4836 Sema::OwningExprResult
4837 TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) {
4838 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
4842 template<typename Derived>
4843 Sema::OwningExprResult
4844 TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) {
4845 OwningStmtResult SubStmt
4846 = getDerived().TransformCompoundStmt(E->getSubStmt(), true);
4847 if (SubStmt.isInvalid())
4848 return SemaRef.ExprError();
4850 if (!getDerived().AlwaysRebuild() &&
4851 SubStmt.get() == E->getSubStmt())
4852 return SemaRef.Owned(E->Retain());
4854 return getDerived().RebuildStmtExpr(E->getLParenLoc(),
4859 template<typename Derived>
4860 Sema::OwningExprResult
4861 TreeTransform<Derived>::TransformTypesCompatibleExpr(TypesCompatibleExpr *E) {
4864 // FIXME: Source location isn't quite accurate.
4865 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName());
4867 T1 = getDerived().TransformType(E->getArgType1());
4869 return SemaRef.ExprError();
4871 T2 = getDerived().TransformType(E->getArgType2());
4873 return SemaRef.ExprError();
4876 if (!getDerived().AlwaysRebuild() &&
4877 T1 == E->getArgType1() &&
4878 T2 == E->getArgType2())
4879 return SemaRef.Owned(E->Retain());
4881 return getDerived().RebuildTypesCompatibleExpr(E->getBuiltinLoc(),
4882 T1, T2, E->getRParenLoc());
4885 template<typename Derived>
4886 Sema::OwningExprResult
4887 TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) {
4888 OwningExprResult Cond = getDerived().TransformExpr(E->getCond());
4889 if (Cond.isInvalid())
4890 return SemaRef.ExprError();
4892 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS());
4893 if (LHS.isInvalid())
4894 return SemaRef.ExprError();
4896 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS());
4897 if (RHS.isInvalid())
4898 return SemaRef.ExprError();
4900 if (!getDerived().AlwaysRebuild() &&
4901 Cond.get() == E->getCond() &&
4902 LHS.get() == E->getLHS() &&
4903 RHS.get() == E->getRHS())
4904 return SemaRef.Owned(E->Retain());
4906 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(),
4907 move(Cond), move(LHS), move(RHS),
4911 template<typename Derived>
4912 Sema::OwningExprResult
4913 TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) {
4914 return SemaRef.Owned(E->Retain());
4917 template<typename Derived>
4918 Sema::OwningExprResult
4919 TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
4920 switch (E->getOperator()) {
4924 case OO_Array_Delete:
4925 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr");
4926 return SemaRef.ExprError();
4929 // This is a call to an object's operator().
4930 assert(E->getNumArgs() >= 1 && "Object call is missing arguments");
4932 // Transform the object itself.
4933 OwningExprResult Object = getDerived().TransformExpr(E->getArg(0));
4934 if (Object.isInvalid())
4935 return SemaRef.ExprError();
4937 // FIXME: Poor location information
4938 SourceLocation FakeLParenLoc
4939 = SemaRef.PP.getLocForEndOfToken(
4940 static_cast<Expr *>(Object.get())->getLocEnd());
4942 // Transform the call arguments.
4943 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
4944 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs;
4945 for (unsigned I = 1, N = E->getNumArgs(); I != N; ++I) {
4946 if (getDerived().DropCallArgument(E->getArg(I)))
4949 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I));
4950 if (Arg.isInvalid())
4951 return SemaRef.ExprError();
4953 // FIXME: Poor source location information.
4954 SourceLocation FakeCommaLoc
4955 = SemaRef.PP.getLocForEndOfToken(
4956 static_cast<Expr *>(Arg.get())->getLocEnd());
4957 FakeCommaLocs.push_back(FakeCommaLoc);
4958 Args.push_back(Arg.release());
4961 return getDerived().RebuildCallExpr(move(Object), FakeLParenLoc,
4963 FakeCommaLocs.data(),
4967 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4969 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
4970 #include "clang/Basic/OperatorKinds.def"
4975 case OO_Conditional:
4976 llvm_unreachable("conditional operator is not actually overloadable");
4977 return SemaRef.ExprError();
4980 case NUM_OVERLOADED_OPERATORS:
4981 llvm_unreachable("not an overloaded operator?");
4982 return SemaRef.ExprError();
4985 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee());
4986 if (Callee.isInvalid())
4987 return SemaRef.ExprError();
4989 OwningExprResult First = getDerived().TransformExpr(E->getArg(0));
4990 if (First.isInvalid())
4991 return SemaRef.ExprError();
4993 OwningExprResult Second(SemaRef);
4994 if (E->getNumArgs() == 2) {
4995 Second = getDerived().TransformExpr(E->getArg(1));
4996 if (Second.isInvalid())
4997 return SemaRef.ExprError();
5000 if (!getDerived().AlwaysRebuild() &&
5001 Callee.get() == E->getCallee() &&
5002 First.get() == E->getArg(0) &&
5003 (E->getNumArgs() != 2 || Second.get() == E->getArg(1)))
5004 return SemaRef.Owned(E->Retain());
5006 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(),
5007 E->getOperatorLoc(),
5013 template<typename Derived>
5014 Sema::OwningExprResult
5015 TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) {
5016 return getDerived().TransformCallExpr(E);
5019 template<typename Derived>
5020 Sema::OwningExprResult
5021 TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) {
5022 TypeSourceInfo *OldT;
5023 TypeSourceInfo *NewT;
5025 // FIXME: Source location isn't quite accurate.
5026 SourceLocation TypeStartLoc
5027 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc());
5028 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName());
5030 OldT = E->getTypeInfoAsWritten();
5031 NewT = getDerived().TransformType(OldT);
5033 return SemaRef.ExprError();
5036 OwningExprResult SubExpr
5037 = getDerived().TransformExpr(E->getSubExprAsWritten());
5038 if (SubExpr.isInvalid())
5039 return SemaRef.ExprError();
5041 if (!getDerived().AlwaysRebuild() &&
5043 SubExpr.get() == E->getSubExpr())
5044 return SemaRef.Owned(E->Retain());
5046 // FIXME: Poor source location information here.
5047 SourceLocation FakeLAngleLoc
5048 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc());
5049 SourceLocation FakeRAngleLoc = E->getSubExpr()->getSourceRange().getBegin();
5050 SourceLocation FakeRParenLoc
5051 = SemaRef.PP.getLocForEndOfToken(
5052 E->getSubExpr()->getSourceRange().getEnd());
5053 return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(),
5063 template<typename Derived>
5064 Sema::OwningExprResult
5065 TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) {
5066 return getDerived().TransformCXXNamedCastExpr(E);
5069 template<typename Derived>
5070 Sema::OwningExprResult
5071 TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
5072 return getDerived().TransformCXXNamedCastExpr(E);
5075 template<typename Derived>
5076 Sema::OwningExprResult
5077 TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
5078 CXXReinterpretCastExpr *E) {
5079 return getDerived().TransformCXXNamedCastExpr(E);
5082 template<typename Derived>
5083 Sema::OwningExprResult
5084 TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) {
5085 return getDerived().TransformCXXNamedCastExpr(E);
5088 template<typename Derived>
5089 Sema::OwningExprResult
5090 TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
5091 CXXFunctionalCastExpr *E) {
5092 TypeSourceInfo *OldT;
5093 TypeSourceInfo *NewT;
5095 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
5097 OldT = E->getTypeInfoAsWritten();
5098 NewT = getDerived().TransformType(OldT);
5100 return SemaRef.ExprError();
5103 OwningExprResult SubExpr
5104 = getDerived().TransformExpr(E->getSubExprAsWritten());
5105 if (SubExpr.isInvalid())
5106 return SemaRef.ExprError();
5108 if (!getDerived().AlwaysRebuild() &&
5110 SubExpr.get() == E->getSubExpr())
5111 return SemaRef.Owned(E->Retain());
5113 // FIXME: The end of the type's source range is wrong
5114 return getDerived().RebuildCXXFunctionalCastExpr(
5115 /*FIXME:*/SourceRange(E->getTypeBeginLoc()),
5117 /*FIXME:*/E->getSubExpr()->getLocStart(),
5122 template<typename Derived>
5123 Sema::OwningExprResult
5124 TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) {
5125 if (E->isTypeOperand()) {
5126 TypeSourceInfo *TInfo
5127 = getDerived().TransformType(E->getTypeOperandSourceInfo());
5129 return SemaRef.ExprError();
5131 if (!getDerived().AlwaysRebuild() &&
5132 TInfo == E->getTypeOperandSourceInfo())
5133 return SemaRef.Owned(E->Retain());
5135 return getDerived().RebuildCXXTypeidExpr(E->getType(),
5141 // We don't know whether the expression is potentially evaluated until
5142 // after we perform semantic analysis, so the expression is potentially
5143 // potentially evaluated.
5144 EnterExpressionEvaluationContext Unevaluated(SemaRef,
5145 Action::PotentiallyPotentiallyEvaluated);
5147 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
5148 if (SubExpr.isInvalid())
5149 return SemaRef.ExprError();
5151 if (!getDerived().AlwaysRebuild() &&
5152 SubExpr.get() == E->getExprOperand())
5153 return SemaRef.Owned(E->Retain());
5155 return getDerived().RebuildCXXTypeidExpr(E->getType(),
5161 template<typename Derived>
5162 Sema::OwningExprResult
5163 TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
5164 return SemaRef.Owned(E->Retain());
5167 template<typename Derived>
5168 Sema::OwningExprResult
5169 TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
5170 CXXNullPtrLiteralExpr *E) {
5171 return SemaRef.Owned(E->Retain());
5174 template<typename Derived>
5175 Sema::OwningExprResult
5176 TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) {
5177 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName());
5179 QualType T = getDerived().TransformType(E->getType());
5181 return SemaRef.ExprError();
5183 if (!getDerived().AlwaysRebuild() &&
5185 return SemaRef.Owned(E->Retain());
5187 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit());
5190 template<typename Derived>
5191 Sema::OwningExprResult
5192 TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) {
5193 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
5194 if (SubExpr.isInvalid())
5195 return SemaRef.ExprError();
5197 if (!getDerived().AlwaysRebuild() &&
5198 SubExpr.get() == E->getSubExpr())
5199 return SemaRef.Owned(E->Retain());
5201 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), move(SubExpr));
5204 template<typename Derived>
5205 Sema::OwningExprResult
5206 TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
5208 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(),
5211 return SemaRef.ExprError();
5213 if (!getDerived().AlwaysRebuild() &&
5214 Param == E->getParam())
5215 return SemaRef.Owned(E->Retain());
5217 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param);
5220 template<typename Derived>
5221 Sema::OwningExprResult
5222 TreeTransform<Derived>::TransformCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
5223 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
5225 QualType T = getDerived().TransformType(E->getType());
5227 return SemaRef.ExprError();
5229 if (!getDerived().AlwaysRebuild() &&
5231 return SemaRef.Owned(E->Retain());
5233 return getDerived().RebuildCXXScalarValueInitExpr(E->getTypeBeginLoc(),
5234 /*FIXME:*/E->getTypeBeginLoc(),
5239 template<typename Derived>
5240 Sema::OwningExprResult
5241 TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) {
5242 // Transform the type that we're allocating
5243 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName());
5244 QualType AllocType = getDerived().TransformType(E->getAllocatedType());
5245 if (AllocType.isNull())
5246 return SemaRef.ExprError();
5248 // Transform the size of the array we're allocating (if any).
5249 OwningExprResult ArraySize = getDerived().TransformExpr(E->getArraySize());
5250 if (ArraySize.isInvalid())
5251 return SemaRef.ExprError();
5253 // Transform the placement arguments (if any).
5254 bool ArgumentChanged = false;
5255 ASTOwningVector<&ActionBase::DeleteExpr> PlacementArgs(SemaRef);
5256 for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) {
5257 OwningExprResult Arg = getDerived().TransformExpr(E->getPlacementArg(I));
5258 if (Arg.isInvalid())
5259 return SemaRef.ExprError();
5261 ArgumentChanged = ArgumentChanged || Arg.get() != E->getPlacementArg(I);
5262 PlacementArgs.push_back(Arg.take());
5265 // transform the constructor arguments (if any).
5266 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(SemaRef);
5267 for (unsigned I = 0, N = E->getNumConstructorArgs(); I != N; ++I) {
5268 if (getDerived().DropCallArgument(E->getConstructorArg(I)))
5271 OwningExprResult Arg = getDerived().TransformExpr(E->getConstructorArg(I));
5272 if (Arg.isInvalid())
5273 return SemaRef.ExprError();
5275 ArgumentChanged = ArgumentChanged || Arg.get() != E->getConstructorArg(I);
5276 ConstructorArgs.push_back(Arg.take());
5279 // Transform constructor, new operator, and delete operator.
5280 CXXConstructorDecl *Constructor = 0;
5281 if (E->getConstructor()) {
5282 Constructor = cast_or_null<CXXConstructorDecl>(
5283 getDerived().TransformDecl(E->getLocStart(),
5284 E->getConstructor()));
5286 return SemaRef.ExprError();
5289 FunctionDecl *OperatorNew = 0;
5290 if (E->getOperatorNew()) {
5291 OperatorNew = cast_or_null<FunctionDecl>(
5292 getDerived().TransformDecl(E->getLocStart(),
5293 E->getOperatorNew()));
5295 return SemaRef.ExprError();
5298 FunctionDecl *OperatorDelete = 0;
5299 if (E->getOperatorDelete()) {
5300 OperatorDelete = cast_or_null<FunctionDecl>(
5301 getDerived().TransformDecl(E->getLocStart(),
5302 E->getOperatorDelete()));
5303 if (!OperatorDelete)
5304 return SemaRef.ExprError();
5307 if (!getDerived().AlwaysRebuild() &&
5308 AllocType == E->getAllocatedType() &&
5309 ArraySize.get() == E->getArraySize() &&
5310 Constructor == E->getConstructor() &&
5311 OperatorNew == E->getOperatorNew() &&
5312 OperatorDelete == E->getOperatorDelete() &&
5314 // Mark any declarations we need as referenced.
5315 // FIXME: instantiation-specific.
5317 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor);
5319 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorNew);
5321 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorDelete);
5322 return SemaRef.Owned(E->Retain());
5325 if (!ArraySize.get()) {
5326 // If no array size was specified, but the new expression was
5327 // instantiated with an array type (e.g., "new T" where T is
5328 // instantiated with "int[4]"), extract the outer bound from the
5329 // array type as our array size. We do this with constant and
5330 // dependently-sized array types.
5331 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType);
5334 } else if (const ConstantArrayType *ConsArrayT
5335 = dyn_cast<ConstantArrayType>(ArrayT)) {
5337 = SemaRef.Owned(new (SemaRef.Context) IntegerLiteral(
5338 ConsArrayT->getSize(),
5339 SemaRef.Context.getSizeType(),
5340 /*FIXME:*/E->getLocStart()));
5341 AllocType = ConsArrayT->getElementType();
5342 } else if (const DependentSizedArrayType *DepArrayT
5343 = dyn_cast<DependentSizedArrayType>(ArrayT)) {
5344 if (DepArrayT->getSizeExpr()) {
5345 ArraySize = SemaRef.Owned(DepArrayT->getSizeExpr()->Retain());
5346 AllocType = DepArrayT->getElementType();
5350 return getDerived().RebuildCXXNewExpr(E->getLocStart(),
5352 /*FIXME:*/E->getLocStart(),
5353 move_arg(PlacementArgs),
5354 /*FIXME:*/E->getLocStart(),
5355 E->getTypeIdParens(),
5357 /*FIXME:*/E->getLocStart(),
5358 /*FIXME:*/SourceRange(),
5360 /*FIXME:*/E->getLocStart(),
5361 move_arg(ConstructorArgs),
5365 template<typename Derived>
5366 Sema::OwningExprResult
5367 TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) {
5368 OwningExprResult Operand = getDerived().TransformExpr(E->getArgument());
5369 if (Operand.isInvalid())
5370 return SemaRef.ExprError();
5372 // Transform the delete operator, if known.
5373 FunctionDecl *OperatorDelete = 0;
5374 if (E->getOperatorDelete()) {
5375 OperatorDelete = cast_or_null<FunctionDecl>(
5376 getDerived().TransformDecl(E->getLocStart(),
5377 E->getOperatorDelete()));
5378 if (!OperatorDelete)
5379 return SemaRef.ExprError();
5382 if (!getDerived().AlwaysRebuild() &&
5383 Operand.get() == E->getArgument() &&
5384 OperatorDelete == E->getOperatorDelete()) {
5385 // Mark any declarations we need as referenced.
5386 // FIXME: instantiation-specific.
5388 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorDelete);
5389 return SemaRef.Owned(E->Retain());
5392 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(),
5393 E->isGlobalDelete(),
5398 template<typename Derived>
5399 Sema::OwningExprResult
5400 TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
5401 CXXPseudoDestructorExpr *E) {
5402 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
5403 if (Base.isInvalid())
5404 return SemaRef.ExprError();
5406 Sema::TypeTy *ObjectTypePtr = 0;
5407 bool MayBePseudoDestructor = false;
5408 Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base),
5409 E->getOperatorLoc(),
5410 E->isArrow()? tok::arrow : tok::period,
5412 MayBePseudoDestructor);
5413 if (Base.isInvalid())
5414 return SemaRef.ExprError();
5416 QualType ObjectType = QualType::getFromOpaquePtr(ObjectTypePtr);
5417 NestedNameSpecifier *Qualifier
5418 = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
5419 E->getQualifierRange(),
5421 if (E->getQualifier() && !Qualifier)
5422 return SemaRef.ExprError();
5424 PseudoDestructorTypeStorage Destroyed;
5425 if (E->getDestroyedTypeInfo()) {
5426 TypeSourceInfo *DestroyedTypeInfo
5427 = getDerived().TransformType(E->getDestroyedTypeInfo(), ObjectType);
5428 if (!DestroyedTypeInfo)
5429 return SemaRef.ExprError();
5430 Destroyed = DestroyedTypeInfo;
5431 } else if (ObjectType->isDependentType()) {
5432 // We aren't likely to be able to resolve the identifier down to a type
5433 // now anyway, so just retain the identifier.
5434 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(),
5435 E->getDestroyedTypeLoc());
5437 // Look for a destructor known with the given name.
5440 SS.setScopeRep(Qualifier);
5441 SS.setRange(E->getQualifierRange());
5444 Sema::TypeTy *T = SemaRef.getDestructorName(E->getTildeLoc(),
5445 *E->getDestroyedTypeIdentifier(),
5446 E->getDestroyedTypeLoc(),
5451 return SemaRef.ExprError();
5454 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T),
5455 E->getDestroyedTypeLoc());
5458 TypeSourceInfo *ScopeTypeInfo = 0;
5459 if (E->getScopeTypeInfo()) {
5460 ScopeTypeInfo = getDerived().TransformType(E->getScopeTypeInfo(),
5463 return SemaRef.ExprError();
5466 return getDerived().RebuildCXXPseudoDestructorExpr(move(Base),
5467 E->getOperatorLoc(),
5470 E->getQualifierRange(),
5472 E->getColonColonLoc(),
5477 template<typename Derived>
5478 Sema::OwningExprResult
5479 TreeTransform<Derived>::TransformUnresolvedLookupExpr(
5480 UnresolvedLookupExpr *Old) {
5481 TemporaryBase Rebase(*this, Old->getNameLoc(), DeclarationName());
5483 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(),
5484 Sema::LookupOrdinaryName);
5486 // Transform all the decls.
5487 for (UnresolvedLookupExpr::decls_iterator I = Old->decls_begin(),
5488 E = Old->decls_end(); I != E; ++I) {
5489 NamedDecl *InstD = static_cast<NamedDecl*>(
5490 getDerived().TransformDecl(Old->getNameLoc(),
5493 // Silently ignore these if a UsingShadowDecl instantiated to nothing.
5494 // This can happen because of dependent hiding.
5495 if (isa<UsingShadowDecl>(*I))
5498 return SemaRef.ExprError();
5501 // Expand using declarations.
5502 if (isa<UsingDecl>(InstD)) {
5503 UsingDecl *UD = cast<UsingDecl>(InstD);
5504 for (UsingDecl::shadow_iterator I = UD->shadow_begin(),
5505 E = UD->shadow_end(); I != E; ++I)
5513 // Resolve a kind, but don't do any further analysis. If it's
5514 // ambiguous, the callee needs to deal with it.
5517 // Rebuild the nested-name qualifier, if present.
5519 NestedNameSpecifier *Qualifier = 0;
5520 if (Old->getQualifier()) {
5521 Qualifier = getDerived().TransformNestedNameSpecifier(Old->getQualifier(),
5522 Old->getQualifierRange());
5524 return SemaRef.ExprError();
5526 SS.setScopeRep(Qualifier);
5527 SS.setRange(Old->getQualifierRange());
5530 if (Old->getNamingClass()) {
5531 CXXRecordDecl *NamingClass
5532 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
5534 Old->getNamingClass()));
5536 return SemaRef.ExprError();
5538 R.setNamingClass(NamingClass);
5541 // If we have no template arguments, it's a normal declaration name.
5542 if (!Old->hasExplicitTemplateArgs())
5543 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL());
5545 // If we have template arguments, rebuild them, then rebuild the
5546 // templateid expression.
5547 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc());
5548 for (unsigned I = 0, N = Old->getNumTemplateArgs(); I != N; ++I) {
5549 TemplateArgumentLoc Loc;
5550 if (getDerived().TransformTemplateArgument(Old->getTemplateArgs()[I], Loc))
5551 return SemaRef.ExprError();
5552 TransArgs.addArgument(Loc);
5555 return getDerived().RebuildTemplateIdExpr(SS, R, Old->requiresADL(),
5559 template<typename Derived>
5560 Sema::OwningExprResult
5561 TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
5562 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName());
5564 QualType T = getDerived().TransformType(E->getQueriedType());
5566 return SemaRef.ExprError();
5568 if (!getDerived().AlwaysRebuild() &&
5569 T == E->getQueriedType())
5570 return SemaRef.Owned(E->Retain());
5572 // FIXME: Bad location information
5573 SourceLocation FakeLParenLoc
5574 = SemaRef.PP.getLocForEndOfToken(E->getLocStart());
5576 return getDerived().RebuildUnaryTypeTrait(E->getTrait(),
5578 /*FIXME:*/FakeLParenLoc,
5583 template<typename Derived>
5584 Sema::OwningExprResult
5585 TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
5586 DependentScopeDeclRefExpr *E) {
5587 NestedNameSpecifier *NNS
5588 = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
5589 E->getQualifierRange());
5591 return SemaRef.ExprError();
5593 DeclarationName Name
5594 = getDerived().TransformDeclarationName(E->getDeclName(), E->getLocation());
5596 return SemaRef.ExprError();
5598 if (!E->hasExplicitTemplateArgs()) {
5599 if (!getDerived().AlwaysRebuild() &&
5600 NNS == E->getQualifier() &&
5601 Name == E->getDeclName())
5602 return SemaRef.Owned(E->Retain());
5604 return getDerived().RebuildDependentScopeDeclRefExpr(NNS,
5605 E->getQualifierRange(),
5606 Name, E->getLocation(),
5607 /*TemplateArgs*/ 0);
5610 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
5611 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
5612 TemplateArgumentLoc Loc;
5613 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc))
5614 return SemaRef.ExprError();
5615 TransArgs.addArgument(Loc);
5618 return getDerived().RebuildDependentScopeDeclRefExpr(NNS,
5619 E->getQualifierRange(),
5620 Name, E->getLocation(),
5624 template<typename Derived>
5625 Sema::OwningExprResult
5626 TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) {
5627 // CXXConstructExprs are always implicit, so when we have a
5628 // 1-argument construction we just transform that argument.
5629 if (E->getNumArgs() == 1 ||
5630 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1))))
5631 return getDerived().TransformExpr(E->getArg(0));
5633 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName());
5635 QualType T = getDerived().TransformType(E->getType());
5637 return SemaRef.ExprError();
5639 CXXConstructorDecl *Constructor
5640 = cast_or_null<CXXConstructorDecl>(
5641 getDerived().TransformDecl(E->getLocStart(),
5642 E->getConstructor()));
5644 return SemaRef.ExprError();
5646 bool ArgumentChanged = false;
5647 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
5648 for (CXXConstructExpr::arg_iterator Arg = E->arg_begin(),
5649 ArgEnd = E->arg_end();
5650 Arg != ArgEnd; ++Arg) {
5651 if (getDerived().DropCallArgument(*Arg)) {
5652 ArgumentChanged = true;
5656 OwningExprResult TransArg = getDerived().TransformExpr(*Arg);
5657 if (TransArg.isInvalid())
5658 return SemaRef.ExprError();
5660 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg;
5661 Args.push_back(TransArg.takeAs<Expr>());
5664 if (!getDerived().AlwaysRebuild() &&
5665 T == E->getType() &&
5666 Constructor == E->getConstructor() &&
5668 // Mark the constructor as referenced.
5669 // FIXME: Instantiation-specific
5670 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor);
5671 return SemaRef.Owned(E->Retain());
5674 return getDerived().RebuildCXXConstructExpr(T, /*FIXME:*/E->getLocStart(),
5675 Constructor, E->isElidable(),
5679 /// \brief Transform a C++ temporary-binding expression.
5681 /// Since CXXBindTemporaryExpr nodes are implicitly generated, we just
5682 /// transform the subexpression and return that.
5683 template<typename Derived>
5684 Sema::OwningExprResult
5685 TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
5686 return getDerived().TransformExpr(E->getSubExpr());
5689 /// \brief Transform a C++ reference-binding expression.
5691 /// Since CXXBindReferenceExpr nodes are implicitly generated, we just
5692 /// transform the subexpression and return that.
5693 template<typename Derived>
5694 Sema::OwningExprResult
5695 TreeTransform<Derived>::TransformCXXBindReferenceExpr(CXXBindReferenceExpr *E) {
5696 return getDerived().TransformExpr(E->getSubExpr());
5699 /// \brief Transform a C++ expression that contains temporaries that should
5700 /// be destroyed after the expression is evaluated.
5702 /// Since CXXExprWithTemporaries nodes are implicitly generated, we
5703 /// just transform the subexpression and return that.
5704 template<typename Derived>
5705 Sema::OwningExprResult
5706 TreeTransform<Derived>::TransformCXXExprWithTemporaries(
5707 CXXExprWithTemporaries *E) {
5708 return getDerived().TransformExpr(E->getSubExpr());
5711 template<typename Derived>
5712 Sema::OwningExprResult
5713 TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
5714 CXXTemporaryObjectExpr *E) {
5715 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
5716 QualType T = getDerived().TransformType(E->getType());
5718 return SemaRef.ExprError();
5720 CXXConstructorDecl *Constructor
5721 = cast_or_null<CXXConstructorDecl>(
5722 getDerived().TransformDecl(E->getLocStart(),
5723 E->getConstructor()));
5725 return SemaRef.ExprError();
5727 bool ArgumentChanged = false;
5728 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
5729 Args.reserve(E->getNumArgs());
5730 for (CXXTemporaryObjectExpr::arg_iterator Arg = E->arg_begin(),
5731 ArgEnd = E->arg_end();
5732 Arg != ArgEnd; ++Arg) {
5733 if (getDerived().DropCallArgument(*Arg)) {
5734 ArgumentChanged = true;
5738 OwningExprResult TransArg = getDerived().TransformExpr(*Arg);
5739 if (TransArg.isInvalid())
5740 return SemaRef.ExprError();
5742 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg;
5743 Args.push_back((Expr *)TransArg.release());
5746 if (!getDerived().AlwaysRebuild() &&
5747 T == E->getType() &&
5748 Constructor == E->getConstructor() &&
5750 // FIXME: Instantiation-specific
5751 SemaRef.MarkDeclarationReferenced(E->getTypeBeginLoc(), Constructor);
5752 return SemaRef.MaybeBindToTemporary(E->Retain());
5755 // FIXME: Bogus location information
5756 SourceLocation CommaLoc;
5757 if (Args.size() > 1) {
5758 Expr *First = (Expr *)Args[0];
5760 = SemaRef.PP.getLocForEndOfToken(First->getSourceRange().getEnd());
5762 return getDerived().RebuildCXXTemporaryObjectExpr(E->getTypeBeginLoc(),
5764 /*FIXME:*/E->getTypeBeginLoc(),
5770 template<typename Derived>
5771 Sema::OwningExprResult
5772 TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
5773 CXXUnresolvedConstructExpr *E) {
5774 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
5775 QualType T = getDerived().TransformType(E->getTypeAsWritten());
5777 return SemaRef.ExprError();
5779 bool ArgumentChanged = false;
5780 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
5781 llvm::SmallVector<SourceLocation, 8> FakeCommaLocs;
5782 for (CXXUnresolvedConstructExpr::arg_iterator Arg = E->arg_begin(),
5783 ArgEnd = E->arg_end();
5784 Arg != ArgEnd; ++Arg) {
5785 OwningExprResult TransArg = getDerived().TransformExpr(*Arg);
5786 if (TransArg.isInvalid())
5787 return SemaRef.ExprError();
5789 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg;
5790 FakeCommaLocs.push_back(
5791 SemaRef.PP.getLocForEndOfToken((*Arg)->getLocEnd()));
5792 Args.push_back(TransArg.takeAs<Expr>());
5795 if (!getDerived().AlwaysRebuild() &&
5796 T == E->getTypeAsWritten() &&
5798 return SemaRef.Owned(E->Retain());
5800 // FIXME: we're faking the locations of the commas
5801 return getDerived().RebuildCXXUnresolvedConstructExpr(E->getTypeBeginLoc(),
5805 FakeCommaLocs.data(),
5809 template<typename Derived>
5810 Sema::OwningExprResult
5811 TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
5812 CXXDependentScopeMemberExpr *E) {
5813 // Transform the base of the expression.
5814 OwningExprResult Base(SemaRef, (Expr*) 0);
5817 QualType ObjectType;
5818 if (!E->isImplicitAccess()) {
5819 OldBase = E->getBase();
5820 Base = getDerived().TransformExpr(OldBase);
5821 if (Base.isInvalid())
5822 return SemaRef.ExprError();
5824 // Start the member reference and compute the object's type.
5825 Sema::TypeTy *ObjectTy = 0;
5826 bool MayBePseudoDestructor = false;
5827 Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base),
5828 E->getOperatorLoc(),
5829 E->isArrow()? tok::arrow : tok::period,
5831 MayBePseudoDestructor);
5832 if (Base.isInvalid())
5833 return SemaRef.ExprError();
5835 ObjectType = QualType::getFromOpaquePtr(ObjectTy);
5836 BaseType = ((Expr*) Base.get())->getType();
5839 BaseType = getDerived().TransformType(E->getBaseType());
5840 ObjectType = BaseType->getAs<PointerType>()->getPointeeType();
5843 // Transform the first part of the nested-name-specifier that qualifies
5845 NamedDecl *FirstQualifierInScope
5846 = getDerived().TransformFirstQualifierInScope(
5847 E->getFirstQualifierFoundInScope(),
5848 E->getQualifierRange().getBegin());
5850 NestedNameSpecifier *Qualifier = 0;
5851 if (E->getQualifier()) {
5852 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
5853 E->getQualifierRange(),
5855 FirstQualifierInScope);
5857 return SemaRef.ExprError();
5860 DeclarationName Name
5861 = getDerived().TransformDeclarationName(E->getMember(), E->getMemberLoc(),
5864 return SemaRef.ExprError();
5866 if (!E->hasExplicitTemplateArgs()) {
5867 // This is a reference to a member without an explicitly-specified
5868 // template argument list. Optimize for this common case.
5869 if (!getDerived().AlwaysRebuild() &&
5870 Base.get() == OldBase &&
5871 BaseType == E->getBaseType() &&
5872 Qualifier == E->getQualifier() &&
5873 Name == E->getMember() &&
5874 FirstQualifierInScope == E->getFirstQualifierFoundInScope())
5875 return SemaRef.Owned(E->Retain());
5877 return getDerived().RebuildCXXDependentScopeMemberExpr(move(Base),
5880 E->getOperatorLoc(),
5882 E->getQualifierRange(),
5883 FirstQualifierInScope,
5886 /*TemplateArgs*/ 0);
5889 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
5890 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
5891 TemplateArgumentLoc Loc;
5892 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc))
5893 return SemaRef.ExprError();
5894 TransArgs.addArgument(Loc);
5897 return getDerived().RebuildCXXDependentScopeMemberExpr(move(Base),
5900 E->getOperatorLoc(),
5902 E->getQualifierRange(),
5903 FirstQualifierInScope,
5909 template<typename Derived>
5910 Sema::OwningExprResult
5911 TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) {
5912 // Transform the base of the expression.
5913 OwningExprResult Base(SemaRef, (Expr*) 0);
5915 if (!Old->isImplicitAccess()) {
5916 Base = getDerived().TransformExpr(Old->getBase());
5917 if (Base.isInvalid())
5918 return SemaRef.ExprError();
5919 BaseType = ((Expr*) Base.get())->getType();
5921 BaseType = getDerived().TransformType(Old->getBaseType());
5924 NestedNameSpecifier *Qualifier = 0;
5925 if (Old->getQualifier()) {
5927 = getDerived().TransformNestedNameSpecifier(Old->getQualifier(),
5928 Old->getQualifierRange());
5930 return SemaRef.ExprError();
5933 LookupResult R(SemaRef, Old->getMemberName(), Old->getMemberLoc(),
5934 Sema::LookupOrdinaryName);
5936 // Transform all the decls.
5937 for (UnresolvedMemberExpr::decls_iterator I = Old->decls_begin(),
5938 E = Old->decls_end(); I != E; ++I) {
5939 NamedDecl *InstD = static_cast<NamedDecl*>(
5940 getDerived().TransformDecl(Old->getMemberLoc(),
5943 // Silently ignore these if a UsingShadowDecl instantiated to nothing.
5944 // This can happen because of dependent hiding.
5945 if (isa<UsingShadowDecl>(*I))
5948 return SemaRef.ExprError();
5951 // Expand using declarations.
5952 if (isa<UsingDecl>(InstD)) {
5953 UsingDecl *UD = cast<UsingDecl>(InstD);
5954 for (UsingDecl::shadow_iterator I = UD->shadow_begin(),
5955 E = UD->shadow_end(); I != E; ++I)
5965 // Determine the naming class.
5966 if (Old->getNamingClass()) {
5967 CXXRecordDecl *NamingClass
5968 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
5969 Old->getMemberLoc(),
5970 Old->getNamingClass()));
5972 return SemaRef.ExprError();
5974 R.setNamingClass(NamingClass);
5977 TemplateArgumentListInfo TransArgs;
5978 if (Old->hasExplicitTemplateArgs()) {
5979 TransArgs.setLAngleLoc(Old->getLAngleLoc());
5980 TransArgs.setRAngleLoc(Old->getRAngleLoc());
5981 for (unsigned I = 0, N = Old->getNumTemplateArgs(); I != N; ++I) {
5982 TemplateArgumentLoc Loc;
5983 if (getDerived().TransformTemplateArgument(Old->getTemplateArgs()[I],
5985 return SemaRef.ExprError();
5986 TransArgs.addArgument(Loc);
5990 // FIXME: to do this check properly, we will need to preserve the
5991 // first-qualifier-in-scope here, just in case we had a dependent
5992 // base (and therefore couldn't do the check) and a
5993 // nested-name-qualifier (and therefore could do the lookup).
5994 NamedDecl *FirstQualifierInScope = 0;
5996 return getDerived().RebuildUnresolvedMemberExpr(move(Base),
5998 Old->getOperatorLoc(),
6001 Old->getQualifierRange(),
6002 FirstQualifierInScope,
6004 (Old->hasExplicitTemplateArgs()
6008 template<typename Derived>
6009 Sema::OwningExprResult
6010 TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) {
6011 return SemaRef.Owned(E->Retain());
6014 template<typename Derived>
6015 Sema::OwningExprResult
6016 TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) {
6017 TypeSourceInfo *EncodedTypeInfo
6018 = getDerived().TransformType(E->getEncodedTypeSourceInfo());
6019 if (!EncodedTypeInfo)
6020 return SemaRef.ExprError();
6022 if (!getDerived().AlwaysRebuild() &&
6023 EncodedTypeInfo == E->getEncodedTypeSourceInfo())
6024 return SemaRef.Owned(E->Retain());
6026 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(),
6031 template<typename Derived>
6032 Sema::OwningExprResult
6033 TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) {
6034 // Transform arguments.
6035 bool ArgChanged = false;
6036 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
6037 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
6038 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I));
6039 if (Arg.isInvalid())
6040 return SemaRef.ExprError();
6042 ArgChanged = ArgChanged || Arg.get() != E->getArg(I);
6043 Args.push_back(Arg.takeAs<Expr>());
6046 if (E->getReceiverKind() == ObjCMessageExpr::Class) {
6047 // Class message: transform the receiver type.
6048 TypeSourceInfo *ReceiverTypeInfo
6049 = getDerived().TransformType(E->getClassReceiverTypeInfo());
6050 if (!ReceiverTypeInfo)
6051 return SemaRef.ExprError();
6053 // If nothing changed, just retain the existing message send.
6054 if (!getDerived().AlwaysRebuild() &&
6055 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged)
6056 return SemaRef.Owned(E->Retain());
6058 // Build a new class message send.
6059 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo,
6067 // Instance message: transform the receiver
6068 assert(E->getReceiverKind() == ObjCMessageExpr::Instance &&
6069 "Only class and instance messages may be instantiated");
6070 OwningExprResult Receiver
6071 = getDerived().TransformExpr(E->getInstanceReceiver());
6072 if (Receiver.isInvalid())
6073 return SemaRef.ExprError();
6075 // If nothing changed, just retain the existing message send.
6076 if (!getDerived().AlwaysRebuild() &&
6077 Receiver.get() == E->getInstanceReceiver() && !ArgChanged)
6078 return SemaRef.Owned(E->Retain());
6080 // Build a new instance message send.
6081 return getDerived().RebuildObjCMessageExpr(move(Receiver),
6089 template<typename Derived>
6090 Sema::OwningExprResult
6091 TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) {
6092 return SemaRef.Owned(E->Retain());
6095 template<typename Derived>
6096 Sema::OwningExprResult
6097 TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) {
6098 return SemaRef.Owned(E->Retain());
6101 template<typename Derived>
6102 Sema::OwningExprResult
6103 TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) {
6104 // Transform the base expression.
6105 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
6106 if (Base.isInvalid())
6107 return SemaRef.ExprError();
6109 // We don't need to transform the ivar; it will never change.
6111 // If nothing changed, just retain the existing expression.
6112 if (!getDerived().AlwaysRebuild() &&
6113 Base.get() == E->getBase())
6114 return SemaRef.Owned(E->Retain());
6116 return getDerived().RebuildObjCIvarRefExpr(move(Base), E->getDecl(),
6118 E->isArrow(), E->isFreeIvar());
6121 template<typename Derived>
6122 Sema::OwningExprResult
6123 TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
6124 // Transform the base expression.
6125 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
6126 if (Base.isInvalid())
6127 return SemaRef.ExprError();
6129 // We don't need to transform the property; it will never change.
6131 // If nothing changed, just retain the existing expression.
6132 if (!getDerived().AlwaysRebuild() &&
6133 Base.get() == E->getBase())
6134 return SemaRef.Owned(E->Retain());
6136 return getDerived().RebuildObjCPropertyRefExpr(move(Base), E->getProperty(),
6140 template<typename Derived>
6141 Sema::OwningExprResult
6142 TreeTransform<Derived>::TransformObjCImplicitSetterGetterRefExpr(
6143 ObjCImplicitSetterGetterRefExpr *E) {
6144 // If this implicit setter/getter refers to class methods, it cannot have any
6145 // dependent parts. Just retain the existing declaration.
6146 if (E->getInterfaceDecl())
6147 return SemaRef.Owned(E->Retain());
6149 // Transform the base expression.
6150 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
6151 if (Base.isInvalid())
6152 return SemaRef.ExprError();
6154 // We don't need to transform the getters/setters; they will never change.
6156 // If nothing changed, just retain the existing expression.
6157 if (!getDerived().AlwaysRebuild() &&
6158 Base.get() == E->getBase())
6159 return SemaRef.Owned(E->Retain());
6161 return getDerived().RebuildObjCImplicitSetterGetterRefExpr(
6162 E->getGetterMethod(),
6164 E->getSetterMethod(),
6170 template<typename Derived>
6171 Sema::OwningExprResult
6172 TreeTransform<Derived>::TransformObjCSuperExpr(ObjCSuperExpr *E) {
6173 // Can never occur in a dependent context.
6174 return SemaRef.Owned(E->Retain());
6177 template<typename Derived>
6178 Sema::OwningExprResult
6179 TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) {
6180 // Transform the base expression.
6181 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
6182 if (Base.isInvalid())
6183 return SemaRef.ExprError();
6185 // If nothing changed, just retain the existing expression.
6186 if (!getDerived().AlwaysRebuild() &&
6187 Base.get() == E->getBase())
6188 return SemaRef.Owned(E->Retain());
6190 return getDerived().RebuildObjCIsaExpr(move(Base), E->getIsaMemberLoc(),
6194 template<typename Derived>
6195 Sema::OwningExprResult
6196 TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) {
6197 bool ArgumentChanged = false;
6198 ASTOwningVector<&ActionBase::DeleteExpr> SubExprs(SemaRef);
6199 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) {
6200 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExpr(I));
6201 if (SubExpr.isInvalid())
6202 return SemaRef.ExprError();
6204 ArgumentChanged = ArgumentChanged || SubExpr.get() != E->getExpr(I);
6205 SubExprs.push_back(SubExpr.takeAs<Expr>());
6208 if (!getDerived().AlwaysRebuild() &&
6210 return SemaRef.Owned(E->Retain());
6212 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(),
6217 template<typename Derived>
6218 Sema::OwningExprResult
6219 TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) {
6220 SourceLocation CaretLoc(E->getExprLoc());
6222 SemaRef.ActOnBlockStart(CaretLoc, /*Scope=*/0);
6223 BlockScopeInfo *CurBlock = SemaRef.getCurBlock();
6224 CurBlock->TheDecl->setIsVariadic(E->getBlockDecl()->isVariadic());
6225 llvm::SmallVector<ParmVarDecl*, 4> Params;
6226 llvm::SmallVector<QualType, 4> ParamTypes;
6228 // Parameter substitution.
6229 const BlockDecl *BD = E->getBlockDecl();
6230 for (BlockDecl::param_const_iterator P = BD->param_begin(),
6231 EN = BD->param_end(); P != EN; ++P) {
6232 ParmVarDecl *OldParm = (*P);
6233 ParmVarDecl *NewParm = getDerived().TransformFunctionTypeParam(OldParm);
6234 QualType NewType = NewParm->getType();
6235 Params.push_back(NewParm);
6236 ParamTypes.push_back(NewParm->getType());
6239 const FunctionType *BExprFunctionType = E->getFunctionType();
6240 QualType BExprResultType = BExprFunctionType->getResultType();
6241 if (!BExprResultType.isNull()) {
6242 if (!BExprResultType->isDependentType())
6243 CurBlock->ReturnType = BExprResultType;
6244 else if (BExprResultType != SemaRef.Context.DependentTy)
6245 CurBlock->ReturnType = getDerived().TransformType(BExprResultType);
6248 // Transform the body
6249 OwningStmtResult Body = getDerived().TransformStmt(E->getBody());
6250 if (Body.isInvalid())
6251 return SemaRef.ExprError();
6252 // Set the parameters on the block decl.
6253 if (!Params.empty())
6254 CurBlock->TheDecl->setParams(Params.data(), Params.size());
6256 QualType FunctionType = getDerived().RebuildFunctionProtoType(
6257 CurBlock->ReturnType,
6263 CurBlock->FunctionType = FunctionType;
6264 return SemaRef.ActOnBlockStmtExpr(CaretLoc, move(Body), /*Scope=*/0);
6267 template<typename Derived>
6268 Sema::OwningExprResult
6269 TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E) {
6270 NestedNameSpecifier *Qualifier = 0;
6273 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
6276 return SemaRef.ExprError();
6278 if (!getDerived().AlwaysRebuild() &&
6279 ND == E->getDecl()) {
6280 // Mark it referenced in the new context regardless.
6281 // FIXME: this is a bit instantiation-specific.
6282 SemaRef.MarkDeclarationReferenced(E->getLocation(), ND);
6284 return SemaRef.Owned(E->Retain());
6287 return getDerived().RebuildDeclRefExpr(Qualifier, SourceLocation(),
6288 ND, E->getLocation(), 0);
6291 //===----------------------------------------------------------------------===//
6292 // Type reconstruction
6293 //===----------------------------------------------------------------------===//
6295 template<typename Derived>
6296 QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType,
6297 SourceLocation Star) {
6298 return SemaRef.BuildPointerType(PointeeType, Star,
6299 getDerived().getBaseEntity());
6302 template<typename Derived>
6303 QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType,
6304 SourceLocation Star) {
6305 return SemaRef.BuildBlockPointerType(PointeeType, Star,
6306 getDerived().getBaseEntity());
6309 template<typename Derived>
6311 TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType,
6312 bool WrittenAsLValue,
6313 SourceLocation Sigil) {
6314 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue,
6315 Sigil, getDerived().getBaseEntity());
6318 template<typename Derived>
6320 TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType,
6322 SourceLocation Sigil) {
6323 return SemaRef.BuildMemberPointerType(PointeeType, ClassType,
6324 Sigil, getDerived().getBaseEntity());
6327 template<typename Derived>
6329 TreeTransform<Derived>::RebuildArrayType(QualType ElementType,
6330 ArrayType::ArraySizeModifier SizeMod,
6331 const llvm::APInt *Size,
6333 unsigned IndexTypeQuals,
6334 SourceRange BracketsRange) {
6335 if (SizeExpr || !Size)
6336 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr,
6337 IndexTypeQuals, BracketsRange,
6338 getDerived().getBaseEntity());
6340 QualType Types[] = {
6341 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy,
6342 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy,
6343 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty
6345 const unsigned NumTypes = sizeof(Types) / sizeof(QualType);
6347 for (unsigned I = 0; I != NumTypes; ++I)
6348 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) {
6349 SizeType = Types[I];
6353 IntegerLiteral ArraySize(*Size, SizeType, /*FIXME*/BracketsRange.getBegin());
6354 return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize,
6355 IndexTypeQuals, BracketsRange,
6356 getDerived().getBaseEntity());
6359 template<typename Derived>
6361 TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType,
6362 ArrayType::ArraySizeModifier SizeMod,
6363 const llvm::APInt &Size,
6364 unsigned IndexTypeQuals,
6365 SourceRange BracketsRange) {
6366 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0,
6367 IndexTypeQuals, BracketsRange);
6370 template<typename Derived>
6372 TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType,
6373 ArrayType::ArraySizeModifier SizeMod,
6374 unsigned IndexTypeQuals,
6375 SourceRange BracketsRange) {
6376 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0,
6377 IndexTypeQuals, BracketsRange);
6380 template<typename Derived>
6382 TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType,
6383 ArrayType::ArraySizeModifier SizeMod,
6385 unsigned IndexTypeQuals,
6386 SourceRange BracketsRange) {
6387 return getDerived().RebuildArrayType(ElementType, SizeMod, 0,
6388 SizeExpr.takeAs<Expr>(),
6389 IndexTypeQuals, BracketsRange);
6392 template<typename Derived>
6394 TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType,
6395 ArrayType::ArraySizeModifier SizeMod,
6397 unsigned IndexTypeQuals,
6398 SourceRange BracketsRange) {
6399 return getDerived().RebuildArrayType(ElementType, SizeMod, 0,
6400 SizeExpr.takeAs<Expr>(),
6401 IndexTypeQuals, BracketsRange);
6404 template<typename Derived>
6405 QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType,
6406 unsigned NumElements,
6407 VectorType::AltiVecSpecific AltiVecSpec) {
6408 // FIXME: semantic checking!
6409 return SemaRef.Context.getVectorType(ElementType, NumElements, AltiVecSpec);
6412 template<typename Derived>
6413 QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType,
6414 unsigned NumElements,
6415 SourceLocation AttributeLoc) {
6416 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
6418 IntegerLiteral *VectorSize
6419 = new (SemaRef.Context) IntegerLiteral(numElements, SemaRef.Context.IntTy,
6421 return SemaRef.BuildExtVectorType(ElementType, SemaRef.Owned(VectorSize),
6425 template<typename Derived>
6427 TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType,
6429 SourceLocation AttributeLoc) {
6430 return SemaRef.BuildExtVectorType(ElementType, move(SizeExpr), AttributeLoc);
6433 template<typename Derived>
6434 QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T,
6435 QualType *ParamTypes,
6436 unsigned NumParamTypes,
6439 return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic,
6441 getDerived().getBaseLocation(),
6442 getDerived().getBaseEntity());
6445 template<typename Derived>
6446 QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) {
6447 return SemaRef.Context.getFunctionNoProtoType(T);
6450 template<typename Derived>
6451 QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(Decl *D) {
6452 assert(D && "no decl found");
6453 if (D->isInvalidDecl()) return QualType();
6455 // FIXME: Doesn't account for ObjCInterfaceDecl!
6457 if (isa<UsingDecl>(D)) {
6458 UsingDecl *Using = cast<UsingDecl>(D);
6459 assert(Using->isTypeName() &&
6460 "UnresolvedUsingTypenameDecl transformed to non-typename using");
6462 // A valid resolved using typename decl points to exactly one type decl.
6463 assert(++Using->shadow_begin() == Using->shadow_end());
6464 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl());
6467 assert(isa<UnresolvedUsingTypenameDecl>(D) &&
6468 "UnresolvedUsingTypenameDecl transformed to non-using decl");
6469 Ty = cast<UnresolvedUsingTypenameDecl>(D);
6472 return SemaRef.Context.getTypeDeclType(Ty);
6475 template<typename Derived>
6476 QualType TreeTransform<Derived>::RebuildTypeOfExprType(ExprArg E) {
6477 return SemaRef.BuildTypeofExprType(E.takeAs<Expr>());
6480 template<typename Derived>
6481 QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) {
6482 return SemaRef.Context.getTypeOfType(Underlying);
6485 template<typename Derived>
6486 QualType TreeTransform<Derived>::RebuildDecltypeType(ExprArg E) {
6487 return SemaRef.BuildDecltypeType(E.takeAs<Expr>());
6490 template<typename Derived>
6491 QualType TreeTransform<Derived>::RebuildTemplateSpecializationType(
6492 TemplateName Template,
6493 SourceLocation TemplateNameLoc,
6494 const TemplateArgumentListInfo &TemplateArgs) {
6495 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
6498 template<typename Derived>
6499 NestedNameSpecifier *
6500 TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
6503 QualType ObjectType,
6504 NamedDecl *FirstQualifierInScope) {
6506 // FIXME: The source location information is all wrong.
6508 SS.setScopeRep(Prefix);
6509 return static_cast<NestedNameSpecifier *>(
6510 SemaRef.BuildCXXNestedNameSpecifier(0, SS, Range.getEnd(),
6513 FirstQualifierInScope,
6517 template<typename Derived>
6518 NestedNameSpecifier *
6519 TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
6521 NamespaceDecl *NS) {
6522 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, NS);
6525 template<typename Derived>
6526 NestedNameSpecifier *
6527 TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
6531 if (T->isDependentType() || T->isRecordType() ||
6532 (SemaRef.getLangOptions().CPlusPlus0x && T->isEnumeralType())) {
6533 assert(!T.hasLocalQualifiers() && "Can't get cv-qualifiers here");
6534 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, TemplateKW,
6538 SemaRef.Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T;
6542 template<typename Derived>
6544 TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier,
6546 TemplateDecl *Template) {
6547 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW,
6551 template<typename Derived>
6553 TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier,
6554 const IdentifierInfo &II,
6555 QualType ObjectType) {
6557 SS.setRange(SourceRange(getDerived().getBaseLocation()));
6558 SS.setScopeRep(Qualifier);
6560 Name.setIdentifier(&II, /*FIXME:*/getDerived().getBaseLocation());
6561 Sema::TemplateTy Template;
6562 getSema().ActOnDependentTemplateName(/*Scope=*/0,
6563 /*FIXME:*/getDerived().getBaseLocation(),
6566 ObjectType.getAsOpaquePtr(),
6567 /*EnteringContext=*/false,
6569 return Template.template getAsVal<TemplateName>();
6572 template<typename Derived>
6574 TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier,
6575 OverloadedOperatorKind Operator,
6576 QualType ObjectType) {
6578 SS.setRange(SourceRange(getDerived().getBaseLocation()));
6579 SS.setScopeRep(Qualifier);
6581 SourceLocation SymbolLocations[3]; // FIXME: Bogus location information.
6582 Name.setOperatorFunctionId(/*FIXME:*/getDerived().getBaseLocation(),
6583 Operator, SymbolLocations);
6584 Sema::TemplateTy Template;
6585 getSema().ActOnDependentTemplateName(/*Scope=*/0,
6586 /*FIXME:*/getDerived().getBaseLocation(),
6589 ObjectType.getAsOpaquePtr(),
6590 /*EnteringContext=*/false,
6592 return Template.template getAsVal<TemplateName>();
6595 template<typename Derived>
6596 Sema::OwningExprResult
6597 TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
6598 SourceLocation OpLoc,
6602 Expr *FirstExpr = (Expr *)First.get();
6603 Expr *SecondExpr = (Expr *)Second.get();
6604 Expr *CalleeExpr = ((Expr *)Callee.get())->IgnoreParenCasts();
6605 bool isPostIncDec = SecondExpr && (Op == OO_PlusPlus || Op == OO_MinusMinus);
6607 // Determine whether this should be a builtin operation.
6608 if (Op == OO_Subscript) {
6609 if (!FirstExpr->getType()->isOverloadableType() &&
6610 !SecondExpr->getType()->isOverloadableType())
6611 return getSema().CreateBuiltinArraySubscriptExpr(move(First),
6612 CalleeExpr->getLocStart(),
6613 move(Second), OpLoc);
6614 } else if (Op == OO_Arrow) {
6615 // -> is never a builtin operation.
6616 return SemaRef.BuildOverloadedArrowExpr(0, move(First), OpLoc);
6617 } else if (SecondExpr == 0 || isPostIncDec) {
6618 if (!FirstExpr->getType()->isOverloadableType()) {
6619 // The argument is not of overloadable type, so try to create a
6620 // built-in unary operation.
6621 UnaryOperator::Opcode Opc
6622 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
6624 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, move(First));
6627 if (!FirstExpr->getType()->isOverloadableType() &&
6628 !SecondExpr->getType()->isOverloadableType()) {
6629 // Neither of the arguments is an overloadable type, so try to
6630 // create a built-in binary operation.
6631 BinaryOperator::Opcode Opc = BinaryOperator::getOverloadedOpcode(Op);
6632 OwningExprResult Result
6633 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, FirstExpr, SecondExpr);
6634 if (Result.isInvalid())
6635 return SemaRef.ExprError();
6639 return move(Result);
6643 // Compute the transformed set of functions (and function templates) to be
6644 // used during overload resolution.
6645 UnresolvedSet<16> Functions;
6647 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(CalleeExpr)) {
6648 assert(ULE->requiresADL());
6650 // FIXME: Do we have to check
6651 // IsAcceptableNonMemberOperatorCandidate for each of these?
6652 Functions.append(ULE->decls_begin(), ULE->decls_end());
6654 Functions.addDecl(cast<DeclRefExpr>(CalleeExpr)->getDecl());
6657 // Add any functions found via argument-dependent lookup.
6658 Expr *Args[2] = { FirstExpr, SecondExpr };
6659 unsigned NumArgs = 1 + (SecondExpr != 0);
6661 // Create the overloaded operator invocation for unary operators.
6662 if (NumArgs == 1 || isPostIncDec) {
6663 UnaryOperator::Opcode Opc
6664 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
6665 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(First));
6668 if (Op == OO_Subscript)
6669 return SemaRef.CreateOverloadedArraySubscriptExpr(CalleeExpr->getLocStart(),
6674 // Create the overloaded operator invocation for binary operators.
6675 BinaryOperator::Opcode Opc =
6676 BinaryOperator::getOverloadedOpcode(Op);
6677 OwningExprResult Result
6678 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]);
6679 if (Result.isInvalid())
6680 return SemaRef.ExprError();
6684 return move(Result);
6687 template<typename Derived>
6688 Sema::OwningExprResult
6689 TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(ExprArg Base,
6690 SourceLocation OperatorLoc,
6692 NestedNameSpecifier *Qualifier,
6693 SourceRange QualifierRange,
6694 TypeSourceInfo *ScopeType,
6695 SourceLocation CCLoc,
6696 SourceLocation TildeLoc,
6697 PseudoDestructorTypeStorage Destroyed) {
6700 SS.setRange(QualifierRange);
6701 SS.setScopeRep(Qualifier);
6704 Expr *BaseE = (Expr *)Base.get();
6705 QualType BaseType = BaseE->getType();
6706 if (BaseE->isTypeDependent() || Destroyed.getIdentifier() ||
6707 (!isArrow && !BaseType->getAs<RecordType>()) ||
6708 (isArrow && BaseType->getAs<PointerType>() &&
6709 !BaseType->getAs<PointerType>()->getPointeeType()
6710 ->template getAs<RecordType>())){
6711 // This pseudo-destructor expression is still a pseudo-destructor.
6712 return SemaRef.BuildPseudoDestructorExpr(move(Base), OperatorLoc,
6713 isArrow? tok::arrow : tok::period,
6714 SS, ScopeType, CCLoc, TildeLoc,
6719 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo();
6720 DeclarationName Name
6721 = SemaRef.Context.DeclarationNames.getCXXDestructorName(
6722 SemaRef.Context.getCanonicalType(DestroyedType->getType()));
6724 // FIXME: the ScopeType should be tacked onto SS.
6726 return getSema().BuildMemberReferenceExpr(move(Base), BaseType,
6727 OperatorLoc, isArrow,
6728 SS, /*FIXME: FirstQualifier*/ 0,
6729 Name, Destroyed.getLocation(),
6730 /*TemplateArgs*/ 0);
6733 } // end namespace clang
6735 #endif // LLVM_CLANG_SEMA_TREETRANSFORM_H