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 bool IsAltiVec, bool IsPixel);
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 RebuildDependentNameType(ElaboratedTypeKeyword Keyword,
537 NestedNameSpecifier *NNS, QualType T) {
538 if (NNS->isDependent()) {
539 // If the name is still dependent, just build a new dependent name type.
542 if (!SemaRef.computeDeclContext(SS))
543 return SemaRef.Context.getDependentNameType(Keyword, NNS,
544 cast<TemplateSpecializationType>(T));
547 return SemaRef.Context.getElaboratedType(Keyword, NNS, T);
550 /// \brief Build a new typename type that refers to an identifier.
552 /// By default, performs semantic analysis when building the typename type
553 /// (or elaborated type). Subclasses may override this routine to provide
554 /// different behavior.
555 QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword,
556 NestedNameSpecifier *NNS,
557 const IdentifierInfo *Id,
558 SourceLocation KeywordLoc,
559 SourceRange NNSRange,
560 SourceLocation IdLoc) {
563 SS.setRange(NNSRange);
565 if (NNS->isDependent()) {
566 // If the name is still dependent, just build a new dependent name type.
567 if (!SemaRef.computeDeclContext(SS))
568 return SemaRef.Context.getDependentNameType(Keyword, NNS, Id);
571 if (Keyword == ETK_None || Keyword == ETK_Typename)
572 return SemaRef.CheckTypenameType(Keyword, NNS, *Id,
573 KeywordLoc, NNSRange, IdLoc);
575 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
577 // We had a dependent elaborated-type-specifier that has been transformed
578 // into a non-dependent elaborated-type-specifier. Find the tag we're
580 LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
581 DeclContext *DC = SemaRef.computeDeclContext(SS, false);
585 if (SemaRef.RequireCompleteDeclContext(SS, DC))
589 SemaRef.LookupQualifiedName(Result, DC);
590 switch (Result.getResultKind()) {
591 case LookupResult::NotFound:
592 case LookupResult::NotFoundInCurrentInstantiation:
595 case LookupResult::Found:
596 Tag = Result.getAsSingle<TagDecl>();
599 case LookupResult::FoundOverloaded:
600 case LookupResult::FoundUnresolvedValue:
601 llvm_unreachable("Tag lookup cannot find non-tags");
604 case LookupResult::Ambiguous:
605 // Let the LookupResult structure handle ambiguities.
610 // FIXME: Would be nice to highlight just the source range.
611 SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope)
616 if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind, IdLoc, *Id)) {
617 SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id;
618 SemaRef.Diag(Tag->getLocation(), diag::note_previous_use);
622 // Build the elaborated-type-specifier type.
623 QualType T = SemaRef.Context.getTypeDeclType(Tag);
624 return SemaRef.Context.getElaboratedType(Keyword, NNS, T);
627 /// \brief Build a new nested-name-specifier given the prefix and an
628 /// identifier that names the next step in the nested-name-specifier.
630 /// By default, performs semantic analysis when building the new
631 /// nested-name-specifier. Subclasses may override this routine to provide
632 /// different behavior.
633 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
637 NamedDecl *FirstQualifierInScope);
639 /// \brief Build a new nested-name-specifier given the prefix and the
640 /// namespace named in the next step in the nested-name-specifier.
642 /// By default, performs semantic analysis when building the new
643 /// nested-name-specifier. Subclasses may override this routine to provide
644 /// different behavior.
645 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
649 /// \brief Build a new nested-name-specifier given the prefix and the
650 /// type named in the next step in the nested-name-specifier.
652 /// By default, performs semantic analysis when building the new
653 /// nested-name-specifier. Subclasses may override this routine to provide
654 /// different behavior.
655 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
660 /// \brief Build a new template name given a nested name specifier, a flag
661 /// indicating whether the "template" keyword was provided, and the template
662 /// that the template name refers to.
664 /// By default, builds the new template name directly. Subclasses may override
665 /// this routine to provide different behavior.
666 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier,
668 TemplateDecl *Template);
670 /// \brief Build a new template name given a nested name specifier and the
671 /// name that is referred to as a template.
673 /// By default, performs semantic analysis to determine whether the name can
674 /// be resolved to a specific template, then builds the appropriate kind of
675 /// template name. Subclasses may override this routine to provide different
677 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier,
678 const IdentifierInfo &II,
679 QualType ObjectType);
681 /// \brief Build a new template name given a nested name specifier and the
682 /// overloaded operator name that is referred to as a template.
684 /// By default, performs semantic analysis to determine whether the name can
685 /// be resolved to a specific template, then builds the appropriate kind of
686 /// template name. Subclasses may override this routine to provide different
688 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier,
689 OverloadedOperatorKind Operator,
690 QualType ObjectType);
692 /// \brief Build a new compound statement.
694 /// By default, performs semantic analysis to build the new statement.
695 /// Subclasses may override this routine to provide different behavior.
696 OwningStmtResult RebuildCompoundStmt(SourceLocation LBraceLoc,
697 MultiStmtArg Statements,
698 SourceLocation RBraceLoc,
700 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, move(Statements),
704 /// \brief Build a new case statement.
706 /// By default, performs semantic analysis to build the new statement.
707 /// Subclasses may override this routine to provide different behavior.
708 OwningStmtResult RebuildCaseStmt(SourceLocation CaseLoc,
710 SourceLocation EllipsisLoc,
712 SourceLocation ColonLoc) {
713 return getSema().ActOnCaseStmt(CaseLoc, move(LHS), EllipsisLoc, move(RHS),
717 /// \brief Attach the body to a new case statement.
719 /// By default, performs semantic analysis to build the new statement.
720 /// Subclasses may override this routine to provide different behavior.
721 OwningStmtResult RebuildCaseStmtBody(StmtArg S, StmtArg Body) {
722 getSema().ActOnCaseStmtBody(S.get(), move(Body));
726 /// \brief Build a new default statement.
728 /// By default, performs semantic analysis to build the new statement.
729 /// Subclasses may override this routine to provide different behavior.
730 OwningStmtResult RebuildDefaultStmt(SourceLocation DefaultLoc,
731 SourceLocation ColonLoc,
733 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, move(SubStmt),
737 /// \brief Build a new label statement.
739 /// By default, performs semantic analysis to build the new statement.
740 /// Subclasses may override this routine to provide different behavior.
741 OwningStmtResult RebuildLabelStmt(SourceLocation IdentLoc,
743 SourceLocation ColonLoc,
745 return SemaRef.ActOnLabelStmt(IdentLoc, Id, ColonLoc, move(SubStmt));
748 /// \brief Build a new "if" statement.
750 /// By default, performs semantic analysis to build the new statement.
751 /// Subclasses may override this routine to provide different behavior.
752 OwningStmtResult RebuildIfStmt(SourceLocation IfLoc, Sema::FullExprArg Cond,
753 VarDecl *CondVar, StmtArg Then,
754 SourceLocation ElseLoc, StmtArg Else) {
755 return getSema().ActOnIfStmt(IfLoc, Cond, DeclPtrTy::make(CondVar),
756 move(Then), ElseLoc, move(Else));
759 /// \brief Start building a new switch statement.
761 /// By default, performs semantic analysis to build the new statement.
762 /// Subclasses may override this routine to provide different behavior.
763 OwningStmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc,
766 return getSema().ActOnStartOfSwitchStmt(SwitchLoc, move(Cond),
767 DeclPtrTy::make(CondVar));
770 /// \brief Attach the body to the switch statement.
772 /// By default, performs semantic analysis to build the new statement.
773 /// Subclasses may override this routine to provide different behavior.
774 OwningStmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc,
775 StmtArg Switch, StmtArg Body) {
776 return getSema().ActOnFinishSwitchStmt(SwitchLoc, move(Switch),
780 /// \brief Build a new while statement.
782 /// By default, performs semantic analysis to build the new statement.
783 /// Subclasses may override this routine to provide different behavior.
784 OwningStmtResult RebuildWhileStmt(SourceLocation WhileLoc,
785 Sema::FullExprArg Cond,
788 return getSema().ActOnWhileStmt(WhileLoc, Cond,
789 DeclPtrTy::make(CondVar), move(Body));
792 /// \brief Build a new do-while statement.
794 /// By default, performs semantic analysis to build the new statement.
795 /// Subclasses may override this routine to provide different behavior.
796 OwningStmtResult RebuildDoStmt(SourceLocation DoLoc, StmtArg Body,
797 SourceLocation WhileLoc,
798 SourceLocation LParenLoc,
800 SourceLocation RParenLoc) {
801 return getSema().ActOnDoStmt(DoLoc, move(Body), WhileLoc, LParenLoc,
802 move(Cond), RParenLoc);
805 /// \brief Build a new for statement.
807 /// By default, performs semantic analysis to build the new statement.
808 /// Subclasses may override this routine to provide different behavior.
809 OwningStmtResult RebuildForStmt(SourceLocation ForLoc,
810 SourceLocation LParenLoc,
811 StmtArg Init, Sema::FullExprArg Cond,
812 VarDecl *CondVar, Sema::FullExprArg Inc,
813 SourceLocation RParenLoc, StmtArg Body) {
814 return getSema().ActOnForStmt(ForLoc, LParenLoc, move(Init), Cond,
815 DeclPtrTy::make(CondVar),
816 Inc, RParenLoc, move(Body));
819 /// \brief Build a new goto statement.
821 /// By default, performs semantic analysis to build the new statement.
822 /// Subclasses may override this routine to provide different behavior.
823 OwningStmtResult RebuildGotoStmt(SourceLocation GotoLoc,
824 SourceLocation LabelLoc,
826 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label->getID());
829 /// \brief Build a new indirect goto statement.
831 /// By default, performs semantic analysis to build the new statement.
832 /// Subclasses may override this routine to provide different behavior.
833 OwningStmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc,
834 SourceLocation StarLoc,
836 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, move(Target));
839 /// \brief Build a new return statement.
841 /// By default, performs semantic analysis to build the new statement.
842 /// Subclasses may override this routine to provide different behavior.
843 OwningStmtResult RebuildReturnStmt(SourceLocation ReturnLoc,
846 return getSema().ActOnReturnStmt(ReturnLoc, move(Result));
849 /// \brief Build a new declaration statement.
851 /// By default, performs semantic analysis to build the new statement.
852 /// Subclasses may override this routine to provide different behavior.
853 OwningStmtResult RebuildDeclStmt(Decl **Decls, unsigned NumDecls,
854 SourceLocation StartLoc,
855 SourceLocation EndLoc) {
856 return getSema().Owned(
857 new (getSema().Context) DeclStmt(
858 DeclGroupRef::Create(getSema().Context,
863 /// \brief Build a new inline asm statement.
865 /// By default, performs semantic analysis to build the new statement.
866 /// Subclasses may override this routine to provide different behavior.
867 OwningStmtResult RebuildAsmStmt(SourceLocation AsmLoc,
872 IdentifierInfo **Names,
873 MultiExprArg Constraints,
876 MultiExprArg Clobbers,
877 SourceLocation RParenLoc,
879 return getSema().ActOnAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
880 NumInputs, Names, move(Constraints),
881 move(Exprs), move(AsmString), move(Clobbers),
885 /// \brief Build a new Objective-C @try statement.
887 /// By default, performs semantic analysis to build the new statement.
888 /// Subclasses may override this routine to provide different behavior.
889 OwningStmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc,
891 MultiStmtArg CatchStmts,
893 return getSema().ActOnObjCAtTryStmt(AtLoc, move(TryBody), move(CatchStmts),
897 /// \brief Rebuild an Objective-C exception declaration.
899 /// By default, performs semantic analysis to build the new declaration.
900 /// Subclasses may override this routine to provide different behavior.
901 VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
902 TypeSourceInfo *TInfo, QualType T) {
903 return getSema().BuildObjCExceptionDecl(TInfo, T,
904 ExceptionDecl->getIdentifier(),
905 ExceptionDecl->getLocation());
908 /// \brief Build a new Objective-C @catch statement.
910 /// By default, performs semantic analysis to build the new statement.
911 /// Subclasses may override this routine to provide different behavior.
912 OwningStmtResult RebuildObjCAtCatchStmt(SourceLocation AtLoc,
913 SourceLocation RParenLoc,
916 return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
917 Sema::DeclPtrTy::make(Var),
921 /// \brief Build a new Objective-C @finally statement.
923 /// By default, performs semantic analysis to build the new statement.
924 /// Subclasses may override this routine to provide different behavior.
925 OwningStmtResult RebuildObjCAtFinallyStmt(SourceLocation AtLoc,
927 return getSema().ActOnObjCAtFinallyStmt(AtLoc, move(Body));
930 /// \brief Build a new Objective-C @throw statement.
932 /// By default, performs semantic analysis to build the new statement.
933 /// Subclasses may override this routine to provide different behavior.
934 OwningStmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc,
936 return getSema().BuildObjCAtThrowStmt(AtLoc, move(Operand));
939 /// \brief Build a new Objective-C @synchronized statement.
941 /// By default, performs semantic analysis to build the new statement.
942 /// Subclasses may override this routine to provide different behavior.
943 OwningStmtResult RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc,
946 return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, move(Object),
950 /// \brief Build a new Objective-C fast enumeration statement.
952 /// By default, performs semantic analysis to build the new statement.
953 /// Subclasses may override this routine to provide different behavior.
954 OwningStmtResult RebuildObjCForCollectionStmt(SourceLocation ForLoc,
955 SourceLocation LParenLoc,
958 SourceLocation RParenLoc,
960 return getSema().ActOnObjCForCollectionStmt(ForLoc, LParenLoc,
967 /// \brief Build a new C++ exception declaration.
969 /// By default, performs semantic analysis to build the new decaration.
970 /// Subclasses may override this routine to provide different behavior.
971 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl, QualType T,
972 TypeSourceInfo *Declarator,
973 IdentifierInfo *Name,
975 SourceRange TypeRange) {
976 return getSema().BuildExceptionDeclaration(0, T, Declarator, Name, Loc,
980 /// \brief Build a new C++ catch statement.
982 /// By default, performs semantic analysis to build the new statement.
983 /// Subclasses may override this routine to provide different behavior.
984 OwningStmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc,
985 VarDecl *ExceptionDecl,
987 return getSema().Owned(
988 new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl,
989 Handler.takeAs<Stmt>()));
992 /// \brief Build a new C++ try statement.
994 /// By default, performs semantic analysis to build the new statement.
995 /// Subclasses may override this routine to provide different behavior.
996 OwningStmtResult RebuildCXXTryStmt(SourceLocation TryLoc,
998 MultiStmtArg Handlers) {
999 return getSema().ActOnCXXTryBlock(TryLoc, move(TryBlock), move(Handlers));
1002 /// \brief Build a new expression that references a declaration.
1004 /// By default, performs semantic analysis to build the new expression.
1005 /// Subclasses may override this routine to provide different behavior.
1006 OwningExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS,
1009 return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
1013 /// \brief Build a new expression that references a declaration.
1015 /// By default, performs semantic analysis to build the new expression.
1016 /// Subclasses may override this routine to provide different behavior.
1017 OwningExprResult RebuildDeclRefExpr(NestedNameSpecifier *Qualifier,
1018 SourceRange QualifierRange,
1019 ValueDecl *VD, SourceLocation Loc,
1020 TemplateArgumentListInfo *TemplateArgs) {
1022 SS.setScopeRep(Qualifier);
1023 SS.setRange(QualifierRange);
1025 // FIXME: loses template args.
1027 return getSema().BuildDeclarationNameExpr(SS, Loc, VD);
1030 /// \brief Build a new expression in parentheses.
1032 /// By default, performs semantic analysis to build the new expression.
1033 /// Subclasses may override this routine to provide different behavior.
1034 OwningExprResult RebuildParenExpr(ExprArg SubExpr, SourceLocation LParen,
1035 SourceLocation RParen) {
1036 return getSema().ActOnParenExpr(LParen, RParen, move(SubExpr));
1039 /// \brief Build a new pseudo-destructor expression.
1041 /// By default, performs semantic analysis to build the new expression.
1042 /// Subclasses may override this routine to provide different behavior.
1043 OwningExprResult RebuildCXXPseudoDestructorExpr(ExprArg Base,
1044 SourceLocation OperatorLoc,
1046 NestedNameSpecifier *Qualifier,
1047 SourceRange QualifierRange,
1048 TypeSourceInfo *ScopeType,
1049 SourceLocation CCLoc,
1050 SourceLocation TildeLoc,
1051 PseudoDestructorTypeStorage Destroyed);
1053 /// \brief Build a new unary operator expression.
1055 /// By default, performs semantic analysis to build the new expression.
1056 /// Subclasses may override this routine to provide different behavior.
1057 OwningExprResult RebuildUnaryOperator(SourceLocation OpLoc,
1058 UnaryOperator::Opcode Opc,
1060 return getSema().BuildUnaryOp(/*Scope=*/0, OpLoc, Opc, move(SubExpr));
1063 /// \brief Build a new builtin offsetof expression.
1065 /// By default, performs semantic analysis to build the new expression.
1066 /// Subclasses may override this routine to provide different behavior.
1067 OwningExprResult RebuildOffsetOfExpr(SourceLocation OperatorLoc,
1068 TypeSourceInfo *Type,
1069 Action::OffsetOfComponent *Components,
1070 unsigned NumComponents,
1071 SourceLocation RParenLoc) {
1072 return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
1073 NumComponents, RParenLoc);
1076 /// \brief Build a new sizeof or alignof expression with a type argument.
1078 /// By default, performs semantic analysis to build the new expression.
1079 /// Subclasses may override this routine to provide different behavior.
1080 OwningExprResult RebuildSizeOfAlignOf(TypeSourceInfo *TInfo,
1081 SourceLocation OpLoc,
1082 bool isSizeOf, SourceRange R) {
1083 return getSema().CreateSizeOfAlignOfExpr(TInfo, OpLoc, isSizeOf, R);
1086 /// \brief Build a new sizeof or alignof expression with an expression
1089 /// By default, performs semantic analysis to build the new expression.
1090 /// Subclasses may override this routine to provide different behavior.
1091 OwningExprResult RebuildSizeOfAlignOf(ExprArg SubExpr, SourceLocation OpLoc,
1092 bool isSizeOf, SourceRange R) {
1093 OwningExprResult Result
1094 = getSema().CreateSizeOfAlignOfExpr((Expr *)SubExpr.get(),
1095 OpLoc, isSizeOf, R);
1096 if (Result.isInvalid())
1097 return getSema().ExprError();
1100 return move(Result);
1103 /// \brief Build a new array subscript expression.
1105 /// By default, performs semantic analysis to build the new expression.
1106 /// Subclasses may override this routine to provide different behavior.
1107 OwningExprResult RebuildArraySubscriptExpr(ExprArg LHS,
1108 SourceLocation LBracketLoc,
1110 SourceLocation RBracketLoc) {
1111 return getSema().ActOnArraySubscriptExpr(/*Scope=*/0, move(LHS),
1112 LBracketLoc, move(RHS),
1116 /// \brief Build a new call expression.
1118 /// By default, performs semantic analysis to build the new expression.
1119 /// Subclasses may override this routine to provide different behavior.
1120 OwningExprResult RebuildCallExpr(ExprArg Callee, SourceLocation LParenLoc,
1122 SourceLocation *CommaLocs,
1123 SourceLocation RParenLoc) {
1124 return getSema().ActOnCallExpr(/*Scope=*/0, move(Callee), LParenLoc,
1125 move(Args), CommaLocs, RParenLoc);
1128 /// \brief Build a new member access expression.
1130 /// By default, performs semantic analysis to build the new expression.
1131 /// Subclasses may override this routine to provide different behavior.
1132 OwningExprResult RebuildMemberExpr(ExprArg Base, SourceLocation OpLoc,
1134 NestedNameSpecifier *Qualifier,
1135 SourceRange QualifierRange,
1136 SourceLocation MemberLoc,
1138 NamedDecl *FoundDecl,
1139 const TemplateArgumentListInfo *ExplicitTemplateArgs,
1140 NamedDecl *FirstQualifierInScope) {
1141 if (!Member->getDeclName()) {
1142 // We have a reference to an unnamed field.
1143 assert(!Qualifier && "Can't have an unnamed field with a qualifier!");
1145 Expr *BaseExpr = Base.takeAs<Expr>();
1146 if (getSema().PerformObjectMemberConversion(BaseExpr, Qualifier,
1148 return getSema().ExprError();
1151 new (getSema().Context) MemberExpr(BaseExpr, isArrow,
1153 cast<FieldDecl>(Member)->getType());
1154 return getSema().Owned(ME);
1159 SS.setRange(QualifierRange);
1160 SS.setScopeRep(Qualifier);
1163 QualType BaseType = ((Expr*) Base.get())->getType();
1165 // FIXME: this involves duplicating earlier analysis in a lot of
1166 // cases; we should avoid this when possible.
1167 LookupResult R(getSema(), Member->getDeclName(), MemberLoc,
1168 Sema::LookupMemberName);
1169 R.addDecl(FoundDecl);
1172 return getSema().BuildMemberReferenceExpr(move(Base), BaseType,
1174 SS, FirstQualifierInScope,
1175 R, ExplicitTemplateArgs);
1178 /// \brief Build a new binary operator expression.
1180 /// By default, performs semantic analysis to build the new expression.
1181 /// Subclasses may override this routine to provide different behavior.
1182 OwningExprResult RebuildBinaryOperator(SourceLocation OpLoc,
1183 BinaryOperator::Opcode Opc,
1184 ExprArg LHS, ExprArg RHS) {
1185 return getSema().BuildBinOp(/*Scope=*/0, OpLoc, Opc,
1186 LHS.takeAs<Expr>(), RHS.takeAs<Expr>());
1189 /// \brief Build a new conditional operator expression.
1191 /// By default, performs semantic analysis to build the new expression.
1192 /// Subclasses may override this routine to provide different behavior.
1193 OwningExprResult RebuildConditionalOperator(ExprArg Cond,
1194 SourceLocation QuestionLoc,
1196 SourceLocation ColonLoc,
1198 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, move(Cond),
1199 move(LHS), move(RHS));
1202 /// \brief Build a new C-style cast expression.
1204 /// By default, performs semantic analysis to build the new expression.
1205 /// Subclasses may override this routine to provide different behavior.
1206 OwningExprResult RebuildCStyleCastExpr(SourceLocation LParenLoc,
1207 TypeSourceInfo *TInfo,
1208 SourceLocation RParenLoc,
1210 return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
1214 /// \brief Build a new compound literal expression.
1216 /// By default, performs semantic analysis to build the new expression.
1217 /// Subclasses may override this routine to provide different behavior.
1218 OwningExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc,
1219 TypeSourceInfo *TInfo,
1220 SourceLocation RParenLoc,
1222 return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
1226 /// \brief Build a new extended vector element access expression.
1228 /// By default, performs semantic analysis to build the new expression.
1229 /// Subclasses may override this routine to provide different behavior.
1230 OwningExprResult RebuildExtVectorElementExpr(ExprArg Base,
1231 SourceLocation OpLoc,
1232 SourceLocation AccessorLoc,
1233 IdentifierInfo &Accessor) {
1236 QualType BaseType = ((Expr*) Base.get())->getType();
1237 return getSema().BuildMemberReferenceExpr(move(Base), BaseType,
1238 OpLoc, /*IsArrow*/ false,
1239 SS, /*FirstQualifierInScope*/ 0,
1240 DeclarationName(&Accessor),
1242 /* TemplateArgs */ 0);
1245 /// \brief Build a new initializer list expression.
1247 /// By default, performs semantic analysis to build the new expression.
1248 /// Subclasses may override this routine to provide different behavior.
1249 OwningExprResult RebuildInitList(SourceLocation LBraceLoc,
1251 SourceLocation RBraceLoc,
1252 QualType ResultTy) {
1253 OwningExprResult Result
1254 = SemaRef.ActOnInitList(LBraceLoc, move(Inits), RBraceLoc);
1255 if (Result.isInvalid() || ResultTy->isDependentType())
1256 return move(Result);
1258 // Patch in the result type we were given, which may have been computed
1259 // when the initial InitListExpr was built.
1260 InitListExpr *ILE = cast<InitListExpr>((Expr *)Result.get());
1261 ILE->setType(ResultTy);
1262 return move(Result);
1265 /// \brief Build a new designated initializer expression.
1267 /// By default, performs semantic analysis to build the new expression.
1268 /// Subclasses may override this routine to provide different behavior.
1269 OwningExprResult RebuildDesignatedInitExpr(Designation &Desig,
1270 MultiExprArg ArrayExprs,
1271 SourceLocation EqualOrColonLoc,
1274 OwningExprResult Result
1275 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
1277 if (Result.isInvalid())
1278 return SemaRef.ExprError();
1280 ArrayExprs.release();
1281 return move(Result);
1284 /// \brief Build a new value-initialized expression.
1286 /// By default, builds the implicit value initialization without performing
1287 /// any semantic analysis. Subclasses may override this routine to provide
1288 /// different behavior.
1289 OwningExprResult RebuildImplicitValueInitExpr(QualType T) {
1290 return SemaRef.Owned(new (SemaRef.Context) ImplicitValueInitExpr(T));
1293 /// \brief Build a new \c va_arg expression.
1295 /// By default, performs semantic analysis to build the new expression.
1296 /// Subclasses may override this routine to provide different behavior.
1297 OwningExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc, ExprArg SubExpr,
1298 QualType T, SourceLocation RParenLoc) {
1299 return getSema().ActOnVAArg(BuiltinLoc, move(SubExpr), T.getAsOpaquePtr(),
1303 /// \brief Build a new expression list in parentheses.
1305 /// By default, performs semantic analysis to build the new expression.
1306 /// Subclasses may override this routine to provide different behavior.
1307 OwningExprResult RebuildParenListExpr(SourceLocation LParenLoc,
1308 MultiExprArg SubExprs,
1309 SourceLocation RParenLoc) {
1310 return getSema().ActOnParenOrParenListExpr(LParenLoc, RParenLoc,
1314 /// \brief Build a new address-of-label expression.
1316 /// By default, performs semantic analysis, using the name of the label
1317 /// rather than attempting to map the label statement itself.
1318 /// Subclasses may override this routine to provide different behavior.
1319 OwningExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc,
1320 SourceLocation LabelLoc,
1322 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label->getID());
1325 /// \brief Build a new GNU statement expression.
1327 /// By default, performs semantic analysis to build the new expression.
1328 /// Subclasses may override this routine to provide different behavior.
1329 OwningExprResult RebuildStmtExpr(SourceLocation LParenLoc,
1331 SourceLocation RParenLoc) {
1332 return getSema().ActOnStmtExpr(LParenLoc, move(SubStmt), RParenLoc);
1335 /// \brief Build a new __builtin_types_compatible_p expression.
1337 /// By default, performs semantic analysis to build the new expression.
1338 /// Subclasses may override this routine to provide different behavior.
1339 OwningExprResult RebuildTypesCompatibleExpr(SourceLocation BuiltinLoc,
1340 QualType T1, QualType T2,
1341 SourceLocation RParenLoc) {
1342 return getSema().ActOnTypesCompatibleExpr(BuiltinLoc,
1343 T1.getAsOpaquePtr(),
1344 T2.getAsOpaquePtr(),
1348 /// \brief Build a new __builtin_choose_expr expression.
1350 /// By default, performs semantic analysis to build the new expression.
1351 /// Subclasses may override this routine to provide different behavior.
1352 OwningExprResult RebuildChooseExpr(SourceLocation BuiltinLoc,
1353 ExprArg Cond, ExprArg LHS, ExprArg RHS,
1354 SourceLocation RParenLoc) {
1355 return SemaRef.ActOnChooseExpr(BuiltinLoc,
1356 move(Cond), move(LHS), move(RHS),
1360 /// \brief Build a new overloaded operator call expression.
1362 /// By default, performs semantic analysis to build the new expression.
1363 /// The semantic analysis provides the behavior of template instantiation,
1364 /// copying with transformations that turn what looks like an overloaded
1365 /// operator call into a use of a builtin operator, performing
1366 /// argument-dependent lookup, etc. Subclasses may override this routine to
1367 /// provide different behavior.
1368 OwningExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
1369 SourceLocation OpLoc,
1374 /// \brief Build a new C++ "named" cast expression, such as static_cast or
1375 /// reinterpret_cast.
1377 /// By default, this routine dispatches to one of the more-specific routines
1378 /// for a particular named case, e.g., RebuildCXXStaticCastExpr().
1379 /// Subclasses may override this routine to provide different behavior.
1380 OwningExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc,
1381 Stmt::StmtClass Class,
1382 SourceLocation LAngleLoc,
1383 TypeSourceInfo *TInfo,
1384 SourceLocation RAngleLoc,
1385 SourceLocation LParenLoc,
1387 SourceLocation RParenLoc) {
1389 case Stmt::CXXStaticCastExprClass:
1390 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
1391 RAngleLoc, LParenLoc,
1392 move(SubExpr), RParenLoc);
1394 case Stmt::CXXDynamicCastExprClass:
1395 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
1396 RAngleLoc, LParenLoc,
1397 move(SubExpr), RParenLoc);
1399 case Stmt::CXXReinterpretCastExprClass:
1400 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
1401 RAngleLoc, LParenLoc,
1405 case Stmt::CXXConstCastExprClass:
1406 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
1407 RAngleLoc, LParenLoc,
1408 move(SubExpr), RParenLoc);
1411 assert(false && "Invalid C++ named cast");
1415 return getSema().ExprError();
1418 /// \brief Build a new C++ static_cast expression.
1420 /// By default, performs semantic analysis to build the new expression.
1421 /// Subclasses may override this routine to provide different behavior.
1422 OwningExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc,
1423 SourceLocation LAngleLoc,
1424 TypeSourceInfo *TInfo,
1425 SourceLocation RAngleLoc,
1426 SourceLocation LParenLoc,
1428 SourceLocation RParenLoc) {
1429 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
1430 TInfo, move(SubExpr),
1431 SourceRange(LAngleLoc, RAngleLoc),
1432 SourceRange(LParenLoc, RParenLoc));
1435 /// \brief Build a new C++ dynamic_cast expression.
1437 /// By default, performs semantic analysis to build the new expression.
1438 /// Subclasses may override this routine to provide different behavior.
1439 OwningExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc,
1440 SourceLocation LAngleLoc,
1441 TypeSourceInfo *TInfo,
1442 SourceLocation RAngleLoc,
1443 SourceLocation LParenLoc,
1445 SourceLocation RParenLoc) {
1446 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
1447 TInfo, move(SubExpr),
1448 SourceRange(LAngleLoc, RAngleLoc),
1449 SourceRange(LParenLoc, RParenLoc));
1452 /// \brief Build a new C++ reinterpret_cast expression.
1454 /// By default, performs semantic analysis to build the new expression.
1455 /// Subclasses may override this routine to provide different behavior.
1456 OwningExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc,
1457 SourceLocation LAngleLoc,
1458 TypeSourceInfo *TInfo,
1459 SourceLocation RAngleLoc,
1460 SourceLocation LParenLoc,
1462 SourceLocation RParenLoc) {
1463 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
1464 TInfo, move(SubExpr),
1465 SourceRange(LAngleLoc, RAngleLoc),
1466 SourceRange(LParenLoc, RParenLoc));
1469 /// \brief Build a new C++ const_cast expression.
1471 /// By default, performs semantic analysis to build the new expression.
1472 /// Subclasses may override this routine to provide different behavior.
1473 OwningExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc,
1474 SourceLocation LAngleLoc,
1475 TypeSourceInfo *TInfo,
1476 SourceLocation RAngleLoc,
1477 SourceLocation LParenLoc,
1479 SourceLocation RParenLoc) {
1480 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
1481 TInfo, move(SubExpr),
1482 SourceRange(LAngleLoc, RAngleLoc),
1483 SourceRange(LParenLoc, RParenLoc));
1486 /// \brief Build a new C++ functional-style cast expression.
1488 /// By default, performs semantic analysis to build the new expression.
1489 /// Subclasses may override this routine to provide different behavior.
1490 OwningExprResult RebuildCXXFunctionalCastExpr(SourceRange TypeRange,
1491 TypeSourceInfo *TInfo,
1492 SourceLocation LParenLoc,
1494 SourceLocation RParenLoc) {
1495 void *Sub = SubExpr.takeAs<Expr>();
1496 return getSema().ActOnCXXTypeConstructExpr(TypeRange,
1497 TInfo->getType().getAsOpaquePtr(),
1499 Sema::MultiExprArg(getSema(), &Sub, 1),
1504 /// \brief Build a new C++ typeid(type) expression.
1506 /// By default, performs semantic analysis to build the new expression.
1507 /// Subclasses may override this routine to provide different behavior.
1508 OwningExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
1509 SourceLocation TypeidLoc,
1510 TypeSourceInfo *Operand,
1511 SourceLocation RParenLoc) {
1512 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
1516 /// \brief Build a new C++ typeid(expr) expression.
1518 /// By default, performs semantic analysis to build the new expression.
1519 /// Subclasses may override this routine to provide different behavior.
1520 OwningExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
1521 SourceLocation TypeidLoc,
1523 SourceLocation RParenLoc) {
1524 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, move(Operand),
1528 /// \brief Build a new C++ "this" expression.
1530 /// By default, builds a new "this" expression without performing any
1531 /// semantic analysis. Subclasses may override this routine to provide
1532 /// different behavior.
1533 OwningExprResult RebuildCXXThisExpr(SourceLocation ThisLoc,
1536 return getSema().Owned(
1537 new (getSema().Context) CXXThisExpr(ThisLoc, ThisType,
1541 /// \brief Build a new C++ throw expression.
1543 /// By default, performs semantic analysis to build the new expression.
1544 /// Subclasses may override this routine to provide different behavior.
1545 OwningExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, ExprArg Sub) {
1546 return getSema().ActOnCXXThrow(ThrowLoc, move(Sub));
1549 /// \brief Build a new C++ default-argument expression.
1551 /// By default, builds a new default-argument expression, which does not
1552 /// require any semantic analysis. Subclasses may override this routine to
1553 /// provide different behavior.
1554 OwningExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc,
1555 ParmVarDecl *Param) {
1556 return getSema().Owned(CXXDefaultArgExpr::Create(getSema().Context, Loc,
1560 /// \brief Build a new C++ zero-initialization expression.
1562 /// By default, performs semantic analysis to build the new expression.
1563 /// Subclasses may override this routine to provide different behavior.
1564 OwningExprResult RebuildCXXZeroInitValueExpr(SourceLocation TypeStartLoc,
1565 SourceLocation LParenLoc,
1567 SourceLocation RParenLoc) {
1568 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeStartLoc),
1569 T.getAsOpaquePtr(), LParenLoc,
1570 MultiExprArg(getSema(), 0, 0),
1574 /// \brief Build a new C++ "new" expression.
1576 /// By default, performs semantic analysis to build the new expression.
1577 /// Subclasses may override this routine to provide different behavior.
1578 OwningExprResult RebuildCXXNewExpr(SourceLocation StartLoc,
1580 SourceLocation PlacementLParen,
1581 MultiExprArg PlacementArgs,
1582 SourceLocation PlacementRParen,
1585 SourceLocation TypeLoc,
1586 SourceRange TypeRange,
1588 SourceLocation ConstructorLParen,
1589 MultiExprArg ConstructorArgs,
1590 SourceLocation ConstructorRParen) {
1591 return getSema().BuildCXXNew(StartLoc, UseGlobal,
1593 move(PlacementArgs),
1601 move(ConstructorArgs),
1605 /// \brief Build a new C++ "delete" expression.
1607 /// By default, performs semantic analysis to build the new expression.
1608 /// Subclasses may override this routine to provide different behavior.
1609 OwningExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc,
1610 bool IsGlobalDelete,
1613 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
1617 /// \brief Build a new unary type trait expression.
1619 /// By default, performs semantic analysis to build the new expression.
1620 /// Subclasses may override this routine to provide different behavior.
1621 OwningExprResult RebuildUnaryTypeTrait(UnaryTypeTrait Trait,
1622 SourceLocation StartLoc,
1623 SourceLocation LParenLoc,
1625 SourceLocation RParenLoc) {
1626 return getSema().ActOnUnaryTypeTrait(Trait, StartLoc, LParenLoc,
1627 T.getAsOpaquePtr(), RParenLoc);
1630 /// \brief Build a new (previously unresolved) declaration reference
1633 /// By default, performs semantic analysis to build the new expression.
1634 /// Subclasses may override this routine to provide different behavior.
1635 OwningExprResult RebuildDependentScopeDeclRefExpr(NestedNameSpecifier *NNS,
1636 SourceRange QualifierRange,
1637 DeclarationName Name,
1638 SourceLocation Location,
1639 const TemplateArgumentListInfo *TemplateArgs) {
1641 SS.setRange(QualifierRange);
1642 SS.setScopeRep(NNS);
1645 return getSema().BuildQualifiedTemplateIdExpr(SS, Name, Location,
1648 return getSema().BuildQualifiedDeclarationNameExpr(SS, Name, Location);
1651 /// \brief Build a new template-id expression.
1653 /// By default, performs semantic analysis to build the new expression.
1654 /// Subclasses may override this routine to provide different behavior.
1655 OwningExprResult RebuildTemplateIdExpr(const CXXScopeSpec &SS,
1658 const TemplateArgumentListInfo &TemplateArgs) {
1659 return getSema().BuildTemplateIdExpr(SS, R, RequiresADL, TemplateArgs);
1662 /// \brief Build a new object-construction expression.
1664 /// By default, performs semantic analysis to build the new expression.
1665 /// Subclasses may override this routine to provide different behavior.
1666 OwningExprResult RebuildCXXConstructExpr(QualType T,
1668 CXXConstructorDecl *Constructor,
1670 MultiExprArg Args) {
1671 ASTOwningVector<&ActionBase::DeleteExpr> ConvertedArgs(SemaRef);
1672 if (getSema().CompleteConstructorCall(Constructor, move(Args), Loc,
1674 return getSema().ExprError();
1676 return getSema().BuildCXXConstructExpr(Loc, T, Constructor, IsElidable,
1677 move_arg(ConvertedArgs));
1680 /// \brief Build a new object-construction expression.
1682 /// By default, performs semantic analysis to build the new expression.
1683 /// Subclasses may override this routine to provide different behavior.
1684 OwningExprResult RebuildCXXTemporaryObjectExpr(SourceLocation TypeBeginLoc,
1686 SourceLocation LParenLoc,
1688 SourceLocation *Commas,
1689 SourceLocation RParenLoc) {
1690 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeBeginLoc),
1698 /// \brief Build a new object-construction expression.
1700 /// By default, performs semantic analysis to build the new expression.
1701 /// Subclasses may override this routine to provide different behavior.
1702 OwningExprResult RebuildCXXUnresolvedConstructExpr(SourceLocation TypeBeginLoc,
1704 SourceLocation LParenLoc,
1706 SourceLocation *Commas,
1707 SourceLocation RParenLoc) {
1708 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeBeginLoc,
1709 /*FIXME*/LParenLoc),
1717 /// \brief Build a new member reference expression.
1719 /// By default, performs semantic analysis to build the new expression.
1720 /// Subclasses may override this routine to provide different behavior.
1721 OwningExprResult RebuildCXXDependentScopeMemberExpr(ExprArg BaseE,
1724 SourceLocation OperatorLoc,
1725 NestedNameSpecifier *Qualifier,
1726 SourceRange QualifierRange,
1727 NamedDecl *FirstQualifierInScope,
1728 DeclarationName Name,
1729 SourceLocation MemberLoc,
1730 const TemplateArgumentListInfo *TemplateArgs) {
1732 SS.setRange(QualifierRange);
1733 SS.setScopeRep(Qualifier);
1735 return SemaRef.BuildMemberReferenceExpr(move(BaseE), BaseType,
1736 OperatorLoc, IsArrow,
1737 SS, FirstQualifierInScope,
1738 Name, MemberLoc, TemplateArgs);
1741 /// \brief Build a new member reference expression.
1743 /// By default, performs semantic analysis to build the new expression.
1744 /// Subclasses may override this routine to provide different behavior.
1745 OwningExprResult RebuildUnresolvedMemberExpr(ExprArg BaseE,
1747 SourceLocation OperatorLoc,
1749 NestedNameSpecifier *Qualifier,
1750 SourceRange QualifierRange,
1751 NamedDecl *FirstQualifierInScope,
1753 const TemplateArgumentListInfo *TemplateArgs) {
1755 SS.setRange(QualifierRange);
1756 SS.setScopeRep(Qualifier);
1758 return SemaRef.BuildMemberReferenceExpr(move(BaseE), BaseType,
1759 OperatorLoc, IsArrow,
1760 SS, FirstQualifierInScope,
1764 /// \brief Build a new Objective-C @encode expression.
1766 /// By default, performs semantic analysis to build the new expression.
1767 /// Subclasses may override this routine to provide different behavior.
1768 OwningExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc,
1769 TypeSourceInfo *EncodeTypeInfo,
1770 SourceLocation RParenLoc) {
1771 return SemaRef.Owned(SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo,
1775 /// \brief Build a new Objective-C class message.
1776 OwningExprResult RebuildObjCMessageExpr(TypeSourceInfo *ReceiverTypeInfo,
1778 ObjCMethodDecl *Method,
1779 SourceLocation LBracLoc,
1781 SourceLocation RBracLoc) {
1782 return SemaRef.BuildClassMessage(ReceiverTypeInfo,
1783 ReceiverTypeInfo->getType(),
1784 /*SuperLoc=*/SourceLocation(),
1785 Sel, Method, LBracLoc, RBracLoc,
1789 /// \brief Build a new Objective-C instance message.
1790 OwningExprResult RebuildObjCMessageExpr(ExprArg Receiver,
1792 ObjCMethodDecl *Method,
1793 SourceLocation LBracLoc,
1795 SourceLocation RBracLoc) {
1796 QualType ReceiverType = static_cast<Expr *>(Receiver.get())->getType();
1797 return SemaRef.BuildInstanceMessage(move(Receiver),
1799 /*SuperLoc=*/SourceLocation(),
1800 Sel, Method, LBracLoc, RBracLoc,
1804 /// \brief Build a new Objective-C ivar reference expression.
1806 /// By default, performs semantic analysis to build the new expression.
1807 /// Subclasses may override this routine to provide different behavior.
1808 OwningExprResult RebuildObjCIvarRefExpr(ExprArg BaseArg, ObjCIvarDecl *Ivar,
1809 SourceLocation IvarLoc,
1810 bool IsArrow, bool IsFreeIvar) {
1811 // FIXME: We lose track of the IsFreeIvar bit.
1813 Expr *Base = BaseArg.takeAs<Expr>();
1814 LookupResult R(getSema(), Ivar->getDeclName(), IvarLoc,
1815 Sema::LookupMemberName);
1816 OwningExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow,
1819 if (Result.isInvalid())
1820 return getSema().ExprError();
1823 return move(Result);
1825 return getSema().BuildMemberReferenceExpr(getSema().Owned(Base),
1827 /*FIXME:*/IvarLoc, IsArrow, SS,
1828 /*FirstQualifierInScope=*/0,
1830 /*TemplateArgs=*/0);
1833 /// \brief Build a new Objective-C property reference expression.
1835 /// By default, performs semantic analysis to build the new expression.
1836 /// Subclasses may override this routine to provide different behavior.
1837 OwningExprResult RebuildObjCPropertyRefExpr(ExprArg BaseArg,
1838 ObjCPropertyDecl *Property,
1839 SourceLocation PropertyLoc) {
1841 Expr *Base = BaseArg.takeAs<Expr>();
1842 LookupResult R(getSema(), Property->getDeclName(), PropertyLoc,
1843 Sema::LookupMemberName);
1844 bool IsArrow = false;
1845 OwningExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow,
1846 /*FIME:*/PropertyLoc,
1848 if (Result.isInvalid())
1849 return getSema().ExprError();
1852 return move(Result);
1854 return getSema().BuildMemberReferenceExpr(getSema().Owned(Base),
1856 /*FIXME:*/PropertyLoc, IsArrow,
1858 /*FirstQualifierInScope=*/0,
1860 /*TemplateArgs=*/0);
1863 /// \brief Build a new Objective-C implicit setter/getter reference
1866 /// By default, performs semantic analysis to build the new expression.
1867 /// Subclasses may override this routine to provide different behavior.
1868 OwningExprResult RebuildObjCImplicitSetterGetterRefExpr(
1869 ObjCMethodDecl *Getter,
1871 ObjCMethodDecl *Setter,
1872 SourceLocation NameLoc,
1874 // Since these expressions can only be value-dependent, we do not need to
1875 // perform semantic analysis again.
1876 return getSema().Owned(
1877 new (getSema().Context) ObjCImplicitSetterGetterRefExpr(Getter, T,
1880 Base.takeAs<Expr>()));
1883 /// \brief Build a new Objective-C "isa" expression.
1885 /// By default, performs semantic analysis to build the new expression.
1886 /// Subclasses may override this routine to provide different behavior.
1887 OwningExprResult RebuildObjCIsaExpr(ExprArg BaseArg, SourceLocation IsaLoc,
1890 Expr *Base = BaseArg.takeAs<Expr>();
1891 LookupResult R(getSema(), &getSema().Context.Idents.get("isa"), IsaLoc,
1892 Sema::LookupMemberName);
1893 OwningExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow,
1896 if (Result.isInvalid())
1897 return getSema().ExprError();
1900 return move(Result);
1902 return getSema().BuildMemberReferenceExpr(getSema().Owned(Base),
1904 /*FIXME:*/IsaLoc, IsArrow, SS,
1905 /*FirstQualifierInScope=*/0,
1907 /*TemplateArgs=*/0);
1910 /// \brief Build a new shuffle vector expression.
1912 /// By default, performs semantic analysis to build the new expression.
1913 /// Subclasses may override this routine to provide different behavior.
1914 OwningExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc,
1915 MultiExprArg SubExprs,
1916 SourceLocation RParenLoc) {
1917 // Find the declaration for __builtin_shufflevector
1918 const IdentifierInfo &Name
1919 = SemaRef.Context.Idents.get("__builtin_shufflevector");
1920 TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl();
1921 DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name));
1922 assert(Lookup.first != Lookup.second && "No __builtin_shufflevector?");
1924 // Build a reference to the __builtin_shufflevector builtin
1925 FunctionDecl *Builtin = cast<FunctionDecl>(*Lookup.first);
1927 = new (SemaRef.Context) DeclRefExpr(Builtin, Builtin->getType(),
1929 SemaRef.UsualUnaryConversions(Callee);
1931 // Build the CallExpr
1932 unsigned NumSubExprs = SubExprs.size();
1933 Expr **Subs = (Expr **)SubExprs.release();
1934 CallExpr *TheCall = new (SemaRef.Context) CallExpr(SemaRef.Context, Callee,
1936 Builtin->getResultType(),
1938 OwningExprResult OwnedCall(SemaRef.Owned(TheCall));
1940 // Type-check the __builtin_shufflevector expression.
1941 OwningExprResult Result = SemaRef.SemaBuiltinShuffleVector(TheCall);
1942 if (Result.isInvalid())
1943 return SemaRef.ExprError();
1945 OwnedCall.release();
1946 return move(Result);
1950 template<typename Derived>
1951 Sema::OwningStmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) {
1953 return SemaRef.Owned(S);
1955 switch (S->getStmtClass()) {
1956 case Stmt::NoStmtClass: break;
1958 // Transform individual statement nodes
1959 #define STMT(Node, Parent) \
1960 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
1961 #define EXPR(Node, Parent)
1962 #include "clang/AST/StmtNodes.inc"
1964 // Transform expressions by calling TransformExpr.
1965 #define STMT(Node, Parent)
1966 #define ABSTRACT_STMT(Stmt)
1967 #define EXPR(Node, Parent) case Stmt::Node##Class:
1968 #include "clang/AST/StmtNodes.inc"
1970 Sema::OwningExprResult E = getDerived().TransformExpr(cast<Expr>(S));
1972 return getSema().StmtError();
1974 return getSema().ActOnExprStmt(getSema().MakeFullExpr(E));
1978 return SemaRef.Owned(S->Retain());
1982 template<typename Derived>
1983 Sema::OwningExprResult TreeTransform<Derived>::TransformExpr(Expr *E) {
1985 return SemaRef.Owned(E);
1987 switch (E->getStmtClass()) {
1988 case Stmt::NoStmtClass: break;
1989 #define STMT(Node, Parent) case Stmt::Node##Class: break;
1990 #define ABSTRACT_STMT(Stmt)
1991 #define EXPR(Node, Parent) \
1992 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
1993 #include "clang/AST/StmtNodes.inc"
1996 return SemaRef.Owned(E->Retain());
1999 template<typename Derived>
2000 NestedNameSpecifier *
2001 TreeTransform<Derived>::TransformNestedNameSpecifier(NestedNameSpecifier *NNS,
2003 QualType ObjectType,
2004 NamedDecl *FirstQualifierInScope) {
2008 // Transform the prefix of this nested name specifier.
2009 NestedNameSpecifier *Prefix = NNS->getPrefix();
2011 Prefix = getDerived().TransformNestedNameSpecifier(Prefix, Range,
2013 FirstQualifierInScope);
2017 // Clear out the object type and the first qualifier in scope; they only
2018 // apply to the first element in the nested-name-specifier.
2019 ObjectType = QualType();
2020 FirstQualifierInScope = 0;
2023 switch (NNS->getKind()) {
2024 case NestedNameSpecifier::Identifier:
2025 assert((Prefix || !ObjectType.isNull()) &&
2026 "Identifier nested-name-specifier with no prefix or object type");
2027 if (!getDerived().AlwaysRebuild() && Prefix == NNS->getPrefix() &&
2028 ObjectType.isNull())
2031 return getDerived().RebuildNestedNameSpecifier(Prefix, Range,
2032 *NNS->getAsIdentifier(),
2034 FirstQualifierInScope);
2036 case NestedNameSpecifier::Namespace: {
2038 = cast_or_null<NamespaceDecl>(
2039 getDerived().TransformDecl(Range.getBegin(),
2040 NNS->getAsNamespace()));
2041 if (!getDerived().AlwaysRebuild() &&
2042 Prefix == NNS->getPrefix() &&
2043 NS == NNS->getAsNamespace())
2046 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, NS);
2049 case NestedNameSpecifier::Global:
2050 // There is no meaningful transformation that one could perform on the
2054 case NestedNameSpecifier::TypeSpecWithTemplate:
2055 case NestedNameSpecifier::TypeSpec: {
2056 TemporaryBase Rebase(*this, Range.getBegin(), DeclarationName());
2057 QualType T = getDerived().TransformType(QualType(NNS->getAsType(), 0),
2062 if (!getDerived().AlwaysRebuild() &&
2063 Prefix == NNS->getPrefix() &&
2064 T == QualType(NNS->getAsType(), 0))
2067 return getDerived().RebuildNestedNameSpecifier(Prefix, Range,
2068 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate,
2073 // Required to silence a GCC warning
2077 template<typename Derived>
2079 TreeTransform<Derived>::TransformDeclarationName(DeclarationName Name,
2081 QualType ObjectType) {
2085 switch (Name.getNameKind()) {
2086 case DeclarationName::Identifier:
2087 case DeclarationName::ObjCZeroArgSelector:
2088 case DeclarationName::ObjCOneArgSelector:
2089 case DeclarationName::ObjCMultiArgSelector:
2090 case DeclarationName::CXXOperatorName:
2091 case DeclarationName::CXXLiteralOperatorName:
2092 case DeclarationName::CXXUsingDirective:
2095 case DeclarationName::CXXConstructorName:
2096 case DeclarationName::CXXDestructorName:
2097 case DeclarationName::CXXConversionFunctionName: {
2098 TemporaryBase Rebase(*this, Loc, Name);
2099 QualType T = getDerived().TransformType(Name.getCXXNameType(),
2102 return DeclarationName();
2104 return SemaRef.Context.DeclarationNames.getCXXSpecialName(
2106 SemaRef.Context.getCanonicalType(T));
2110 return DeclarationName();
2113 template<typename Derived>
2115 TreeTransform<Derived>::TransformTemplateName(TemplateName Name,
2116 QualType ObjectType) {
2117 SourceLocation Loc = getDerived().getBaseLocation();
2119 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) {
2120 NestedNameSpecifier *NNS
2121 = getDerived().TransformNestedNameSpecifier(QTN->getQualifier(),
2122 /*FIXME:*/SourceRange(getDerived().getBaseLocation()),
2125 return TemplateName();
2127 if (TemplateDecl *Template = QTN->getTemplateDecl()) {
2128 TemplateDecl *TransTemplate
2129 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Loc, Template));
2131 return TemplateName();
2133 if (!getDerived().AlwaysRebuild() &&
2134 NNS == QTN->getQualifier() &&
2135 TransTemplate == Template)
2138 return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(),
2142 // These should be getting filtered out before they make it into the AST.
2143 assert(false && "overloaded template name survived to here");
2146 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) {
2147 NestedNameSpecifier *NNS
2148 = getDerived().TransformNestedNameSpecifier(DTN->getQualifier(),
2149 /*FIXME:*/SourceRange(getDerived().getBaseLocation()),
2151 if (!NNS && DTN->getQualifier())
2152 return TemplateName();
2154 if (!getDerived().AlwaysRebuild() &&
2155 NNS == DTN->getQualifier() &&
2156 ObjectType.isNull())
2159 if (DTN->isIdentifier())
2160 return getDerived().RebuildTemplateName(NNS, *DTN->getIdentifier(),
2163 return getDerived().RebuildTemplateName(NNS, DTN->getOperator(),
2167 if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
2168 TemplateDecl *TransTemplate
2169 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Loc, Template));
2171 return TemplateName();
2173 if (!getDerived().AlwaysRebuild() &&
2174 TransTemplate == Template)
2177 return TemplateName(TransTemplate);
2180 // These should be getting filtered out before they reach the AST.
2181 assert(false && "overloaded function decl survived to here");
2182 return TemplateName();
2185 template<typename Derived>
2186 void TreeTransform<Derived>::InventTemplateArgumentLoc(
2187 const TemplateArgument &Arg,
2188 TemplateArgumentLoc &Output) {
2189 SourceLocation Loc = getDerived().getBaseLocation();
2190 switch (Arg.getKind()) {
2191 case TemplateArgument::Null:
2192 llvm_unreachable("null template argument in TreeTransform");
2195 case TemplateArgument::Type:
2196 Output = TemplateArgumentLoc(Arg,
2197 SemaRef.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc));
2201 case TemplateArgument::Template:
2202 Output = TemplateArgumentLoc(Arg, SourceRange(), Loc);
2205 case TemplateArgument::Expression:
2206 Output = TemplateArgumentLoc(Arg, Arg.getAsExpr());
2209 case TemplateArgument::Declaration:
2210 case TemplateArgument::Integral:
2211 case TemplateArgument::Pack:
2212 Output = TemplateArgumentLoc(Arg, TemplateArgumentLocInfo());
2217 template<typename Derived>
2218 bool TreeTransform<Derived>::TransformTemplateArgument(
2219 const TemplateArgumentLoc &Input,
2220 TemplateArgumentLoc &Output) {
2221 const TemplateArgument &Arg = Input.getArgument();
2222 switch (Arg.getKind()) {
2223 case TemplateArgument::Null:
2224 case TemplateArgument::Integral:
2228 case TemplateArgument::Type: {
2229 TypeSourceInfo *DI = Input.getTypeSourceInfo();
2231 DI = InventTypeSourceInfo(Input.getArgument().getAsType());
2233 DI = getDerived().TransformType(DI);
2234 if (!DI) return true;
2236 Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
2240 case TemplateArgument::Declaration: {
2241 // FIXME: we should never have to transform one of these.
2242 DeclarationName Name;
2243 if (NamedDecl *ND = dyn_cast<NamedDecl>(Arg.getAsDecl()))
2244 Name = ND->getDeclName();
2245 TemporaryBase Rebase(*this, Input.getLocation(), Name);
2246 Decl *D = getDerived().TransformDecl(Input.getLocation(), Arg.getAsDecl());
2247 if (!D) return true;
2249 Expr *SourceExpr = Input.getSourceDeclExpression();
2251 EnterExpressionEvaluationContext Unevaluated(getSema(),
2252 Action::Unevaluated);
2253 Sema::OwningExprResult E = getDerived().TransformExpr(SourceExpr);
2257 SourceExpr = E.takeAs<Expr>();
2258 SourceExpr->Retain();
2262 Output = TemplateArgumentLoc(TemplateArgument(D), SourceExpr);
2266 case TemplateArgument::Template: {
2267 TemporaryBase Rebase(*this, Input.getLocation(), DeclarationName());
2268 TemplateName Template
2269 = getDerived().TransformTemplateName(Arg.getAsTemplate());
2270 if (Template.isNull())
2273 Output = TemplateArgumentLoc(TemplateArgument(Template),
2274 Input.getTemplateQualifierRange(),
2275 Input.getTemplateNameLoc());
2279 case TemplateArgument::Expression: {
2280 // Template argument expressions are not potentially evaluated.
2281 EnterExpressionEvaluationContext Unevaluated(getSema(),
2282 Action::Unevaluated);
2284 Expr *InputExpr = Input.getSourceExpression();
2285 if (!InputExpr) InputExpr = Input.getArgument().getAsExpr();
2287 Sema::OwningExprResult E
2288 = getDerived().TransformExpr(InputExpr);
2289 if (E.isInvalid()) return true;
2291 Expr *ETaken = E.takeAs<Expr>();
2293 Output = TemplateArgumentLoc(TemplateArgument(ETaken), ETaken);
2297 case TemplateArgument::Pack: {
2298 llvm::SmallVector<TemplateArgument, 4> TransformedArgs;
2299 TransformedArgs.reserve(Arg.pack_size());
2300 for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
2301 AEnd = Arg.pack_end();
2304 // FIXME: preserve source information here when we start
2305 // caring about parameter packs.
2307 TemplateArgumentLoc InputArg;
2308 TemplateArgumentLoc OutputArg;
2309 getDerived().InventTemplateArgumentLoc(*A, InputArg);
2310 if (getDerived().TransformTemplateArgument(InputArg, OutputArg))
2313 TransformedArgs.push_back(OutputArg.getArgument());
2315 TemplateArgument Result;
2316 Result.setArgumentPack(TransformedArgs.data(), TransformedArgs.size(),
2318 Output = TemplateArgumentLoc(Result, Input.getLocInfo());
2323 // Work around bogus GCC warning
2327 //===----------------------------------------------------------------------===//
2328 // Type transformation
2329 //===----------------------------------------------------------------------===//
2331 template<typename Derived>
2332 QualType TreeTransform<Derived>::TransformType(QualType T,
2333 QualType ObjectType) {
2334 if (getDerived().AlreadyTransformed(T))
2337 // Temporary workaround. All of these transformations should
2338 // eventually turn into transformations on TypeLocs.
2339 TypeSourceInfo *DI = getSema().Context.CreateTypeSourceInfo(T);
2340 DI->getTypeLoc().initialize(getDerived().getBaseLocation());
2342 TypeSourceInfo *NewDI = getDerived().TransformType(DI, ObjectType);
2347 return NewDI->getType();
2350 template<typename Derived>
2351 TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *DI,
2352 QualType ObjectType) {
2353 if (getDerived().AlreadyTransformed(DI->getType()))
2358 TypeLoc TL = DI->getTypeLoc();
2359 TLB.reserve(TL.getFullDataSize());
2361 QualType Result = getDerived().TransformType(TLB, TL, ObjectType);
2362 if (Result.isNull())
2365 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
2368 template<typename Derived>
2370 TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T,
2371 QualType ObjectType) {
2372 switch (T.getTypeLocClass()) {
2373 #define ABSTRACT_TYPELOC(CLASS, PARENT)
2374 #define TYPELOC(CLASS, PARENT) \
2375 case TypeLoc::CLASS: \
2376 return getDerived().Transform##CLASS##Type(TLB, cast<CLASS##TypeLoc>(T), \
2378 #include "clang/AST/TypeLocNodes.def"
2381 llvm_unreachable("unhandled type loc!");
2385 /// FIXME: By default, this routine adds type qualifiers only to types
2386 /// that can have qualifiers, and silently suppresses those qualifiers
2387 /// that are not permitted (e.g., qualifiers on reference or function
2388 /// types). This is the right thing for template instantiation, but
2389 /// probably not for other clients.
2390 template<typename Derived>
2392 TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB,
2394 QualType ObjectType) {
2395 Qualifiers Quals = T.getType().getLocalQualifiers();
2397 QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc(),
2399 if (Result.isNull())
2402 // Silently suppress qualifiers if the result type can't be qualified.
2403 // FIXME: this is the right thing for template instantiation, but
2404 // probably not for other clients.
2405 if (Result->isFunctionType() || Result->isReferenceType())
2408 Result = SemaRef.Context.getQualifiedType(Result, Quals);
2410 TLB.push<QualifiedTypeLoc>(Result);
2412 // No location information to preserve.
2417 template <class TyLoc> static inline
2418 QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) {
2419 TyLoc NewT = TLB.push<TyLoc>(T.getType());
2420 NewT.setNameLoc(T.getNameLoc());
2424 template<typename Derived>
2425 QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
2427 QualType ObjectType) {
2428 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType());
2429 NewT.setBuiltinLoc(T.getBuiltinLoc());
2430 if (T.needsExtraLocalData())
2431 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs();
2435 template<typename Derived>
2436 QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
2438 QualType ObjectType) {
2440 return TransformTypeSpecType(TLB, T);
2443 template<typename Derived>
2444 QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
2446 QualType ObjectType) {
2447 QualType PointeeType
2448 = getDerived().TransformType(TLB, TL.getPointeeLoc());
2449 if (PointeeType.isNull())
2452 QualType Result = TL.getType();
2453 if (PointeeType->getAs<ObjCObjectType>()) {
2454 // A dependent pointer type 'T *' has is being transformed such
2455 // that an Objective-C class type is being replaced for 'T'. The
2456 // resulting pointer type is an ObjCObjectPointerType, not a
2458 Result = SemaRef.Context.getObjCObjectPointerType(PointeeType);
2460 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
2461 NewT.setStarLoc(TL.getStarLoc());
2465 if (getDerived().AlwaysRebuild() ||
2466 PointeeType != TL.getPointeeLoc().getType()) {
2467 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
2468 if (Result.isNull())
2472 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result);
2473 NewT.setSigilLoc(TL.getSigilLoc());
2477 template<typename Derived>
2479 TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
2480 BlockPointerTypeLoc TL,
2481 QualType ObjectType) {
2482 QualType PointeeType
2483 = getDerived().TransformType(TLB, TL.getPointeeLoc());
2484 if (PointeeType.isNull())
2487 QualType Result = TL.getType();
2488 if (getDerived().AlwaysRebuild() ||
2489 PointeeType != TL.getPointeeLoc().getType()) {
2490 Result = getDerived().RebuildBlockPointerType(PointeeType,
2492 if (Result.isNull())
2496 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result);
2497 NewT.setSigilLoc(TL.getSigilLoc());
2501 /// Transforms a reference type. Note that somewhat paradoxically we
2502 /// don't care whether the type itself is an l-value type or an r-value
2503 /// type; we only care if the type was *written* as an l-value type
2504 /// or an r-value type.
2505 template<typename Derived>
2507 TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB,
2508 ReferenceTypeLoc TL,
2509 QualType ObjectType) {
2510 const ReferenceType *T = TL.getTypePtr();
2512 // Note that this works with the pointee-as-written.
2513 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
2514 if (PointeeType.isNull())
2517 QualType Result = TL.getType();
2518 if (getDerived().AlwaysRebuild() ||
2519 PointeeType != T->getPointeeTypeAsWritten()) {
2520 Result = getDerived().RebuildReferenceType(PointeeType,
2521 T->isSpelledAsLValue(),
2523 if (Result.isNull())
2527 // r-value references can be rebuilt as l-value references.
2528 ReferenceTypeLoc NewTL;
2529 if (isa<LValueReferenceType>(Result))
2530 NewTL = TLB.push<LValueReferenceTypeLoc>(Result);
2532 NewTL = TLB.push<RValueReferenceTypeLoc>(Result);
2533 NewTL.setSigilLoc(TL.getSigilLoc());
2538 template<typename Derived>
2540 TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB,
2541 LValueReferenceTypeLoc TL,
2542 QualType ObjectType) {
2543 return TransformReferenceType(TLB, TL, ObjectType);
2546 template<typename Derived>
2548 TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
2549 RValueReferenceTypeLoc TL,
2550 QualType ObjectType) {
2551 return TransformReferenceType(TLB, TL, ObjectType);
2554 template<typename Derived>
2556 TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
2557 MemberPointerTypeLoc TL,
2558 QualType ObjectType) {
2559 MemberPointerType *T = TL.getTypePtr();
2561 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
2562 if (PointeeType.isNull())
2565 // TODO: preserve source information for this.
2567 = getDerived().TransformType(QualType(T->getClass(), 0));
2568 if (ClassType.isNull())
2571 QualType Result = TL.getType();
2572 if (getDerived().AlwaysRebuild() ||
2573 PointeeType != T->getPointeeType() ||
2574 ClassType != QualType(T->getClass(), 0)) {
2575 Result = getDerived().RebuildMemberPointerType(PointeeType, ClassType,
2577 if (Result.isNull())
2581 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
2582 NewTL.setSigilLoc(TL.getSigilLoc());
2587 template<typename Derived>
2589 TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
2590 ConstantArrayTypeLoc TL,
2591 QualType ObjectType) {
2592 ConstantArrayType *T = TL.getTypePtr();
2593 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
2594 if (ElementType.isNull())
2597 QualType Result = TL.getType();
2598 if (getDerived().AlwaysRebuild() ||
2599 ElementType != T->getElementType()) {
2600 Result = getDerived().RebuildConstantArrayType(ElementType,
2601 T->getSizeModifier(),
2603 T->getIndexTypeCVRQualifiers(),
2604 TL.getBracketsRange());
2605 if (Result.isNull())
2609 ConstantArrayTypeLoc NewTL = TLB.push<ConstantArrayTypeLoc>(Result);
2610 NewTL.setLBracketLoc(TL.getLBracketLoc());
2611 NewTL.setRBracketLoc(TL.getRBracketLoc());
2613 Expr *Size = TL.getSizeExpr();
2615 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2616 Size = getDerived().TransformExpr(Size).template takeAs<Expr>();
2618 NewTL.setSizeExpr(Size);
2623 template<typename Derived>
2624 QualType TreeTransform<Derived>::TransformIncompleteArrayType(
2625 TypeLocBuilder &TLB,
2626 IncompleteArrayTypeLoc TL,
2627 QualType ObjectType) {
2628 IncompleteArrayType *T = TL.getTypePtr();
2629 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
2630 if (ElementType.isNull())
2633 QualType Result = TL.getType();
2634 if (getDerived().AlwaysRebuild() ||
2635 ElementType != T->getElementType()) {
2636 Result = getDerived().RebuildIncompleteArrayType(ElementType,
2637 T->getSizeModifier(),
2638 T->getIndexTypeCVRQualifiers(),
2639 TL.getBracketsRange());
2640 if (Result.isNull())
2644 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
2645 NewTL.setLBracketLoc(TL.getLBracketLoc());
2646 NewTL.setRBracketLoc(TL.getRBracketLoc());
2647 NewTL.setSizeExpr(0);
2652 template<typename Derived>
2654 TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
2655 VariableArrayTypeLoc TL,
2656 QualType ObjectType) {
2657 VariableArrayType *T = TL.getTypePtr();
2658 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
2659 if (ElementType.isNull())
2662 // Array bounds are not potentially evaluated contexts
2663 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2665 Sema::OwningExprResult SizeResult
2666 = getDerived().TransformExpr(T->getSizeExpr());
2667 if (SizeResult.isInvalid())
2670 Expr *Size = static_cast<Expr*>(SizeResult.get());
2672 QualType Result = TL.getType();
2673 if (getDerived().AlwaysRebuild() ||
2674 ElementType != T->getElementType() ||
2675 Size != T->getSizeExpr()) {
2676 Result = getDerived().RebuildVariableArrayType(ElementType,
2677 T->getSizeModifier(),
2679 T->getIndexTypeCVRQualifiers(),
2680 TL.getBracketsRange());
2681 if (Result.isNull())
2684 else SizeResult.take();
2686 VariableArrayTypeLoc NewTL = TLB.push<VariableArrayTypeLoc>(Result);
2687 NewTL.setLBracketLoc(TL.getLBracketLoc());
2688 NewTL.setRBracketLoc(TL.getRBracketLoc());
2689 NewTL.setSizeExpr(Size);
2694 template<typename Derived>
2696 TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
2697 DependentSizedArrayTypeLoc TL,
2698 QualType ObjectType) {
2699 DependentSizedArrayType *T = TL.getTypePtr();
2700 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
2701 if (ElementType.isNull())
2704 // Array bounds are not potentially evaluated contexts
2705 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2707 Sema::OwningExprResult SizeResult
2708 = getDerived().TransformExpr(T->getSizeExpr());
2709 if (SizeResult.isInvalid())
2712 Expr *Size = static_cast<Expr*>(SizeResult.get());
2714 QualType Result = TL.getType();
2715 if (getDerived().AlwaysRebuild() ||
2716 ElementType != T->getElementType() ||
2717 Size != T->getSizeExpr()) {
2718 Result = getDerived().RebuildDependentSizedArrayType(ElementType,
2719 T->getSizeModifier(),
2721 T->getIndexTypeCVRQualifiers(),
2722 TL.getBracketsRange());
2723 if (Result.isNull())
2726 else SizeResult.take();
2728 // We might have any sort of array type now, but fortunately they
2729 // all have the same location layout.
2730 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
2731 NewTL.setLBracketLoc(TL.getLBracketLoc());
2732 NewTL.setRBracketLoc(TL.getRBracketLoc());
2733 NewTL.setSizeExpr(Size);
2738 template<typename Derived>
2739 QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
2740 TypeLocBuilder &TLB,
2741 DependentSizedExtVectorTypeLoc TL,
2742 QualType ObjectType) {
2743 DependentSizedExtVectorType *T = TL.getTypePtr();
2745 // FIXME: ext vector locs should be nested
2746 QualType ElementType = getDerived().TransformType(T->getElementType());
2747 if (ElementType.isNull())
2750 // Vector sizes are not potentially evaluated contexts
2751 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2753 Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
2754 if (Size.isInvalid())
2757 QualType Result = TL.getType();
2758 if (getDerived().AlwaysRebuild() ||
2759 ElementType != T->getElementType() ||
2760 Size.get() != T->getSizeExpr()) {
2761 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
2763 T->getAttributeLoc());
2764 if (Result.isNull())
2769 // Result might be dependent or not.
2770 if (isa<DependentSizedExtVectorType>(Result)) {
2771 DependentSizedExtVectorTypeLoc NewTL
2772 = TLB.push<DependentSizedExtVectorTypeLoc>(Result);
2773 NewTL.setNameLoc(TL.getNameLoc());
2775 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
2776 NewTL.setNameLoc(TL.getNameLoc());
2782 template<typename Derived>
2783 QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
2785 QualType ObjectType) {
2786 VectorType *T = TL.getTypePtr();
2787 QualType ElementType = getDerived().TransformType(T->getElementType());
2788 if (ElementType.isNull())
2791 QualType Result = TL.getType();
2792 if (getDerived().AlwaysRebuild() ||
2793 ElementType != T->getElementType()) {
2794 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(),
2795 T->isAltiVec(), T->isPixel());
2796 if (Result.isNull())
2800 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
2801 NewTL.setNameLoc(TL.getNameLoc());
2806 template<typename Derived>
2807 QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
2808 ExtVectorTypeLoc TL,
2809 QualType ObjectType) {
2810 VectorType *T = TL.getTypePtr();
2811 QualType ElementType = getDerived().TransformType(T->getElementType());
2812 if (ElementType.isNull())
2815 QualType Result = TL.getType();
2816 if (getDerived().AlwaysRebuild() ||
2817 ElementType != T->getElementType()) {
2818 Result = getDerived().RebuildExtVectorType(ElementType,
2819 T->getNumElements(),
2820 /*FIXME*/ SourceLocation());
2821 if (Result.isNull())
2825 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
2826 NewTL.setNameLoc(TL.getNameLoc());
2831 template<typename Derived>
2833 TreeTransform<Derived>::TransformFunctionTypeParam(ParmVarDecl *OldParm) {
2834 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
2835 TypeSourceInfo *NewDI = getDerived().TransformType(OldDI);
2842 return ParmVarDecl::Create(SemaRef.Context,
2843 OldParm->getDeclContext(),
2844 OldParm->getLocation(),
2845 OldParm->getIdentifier(),
2848 OldParm->getStorageClass(),
2849 OldParm->getStorageClassAsWritten(),
2853 template<typename Derived>
2854 bool TreeTransform<Derived>::
2855 TransformFunctionTypeParams(FunctionProtoTypeLoc TL,
2856 llvm::SmallVectorImpl<QualType> &PTypes,
2857 llvm::SmallVectorImpl<ParmVarDecl*> &PVars) {
2858 FunctionProtoType *T = TL.getTypePtr();
2860 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
2861 ParmVarDecl *OldParm = TL.getArg(i);
2864 ParmVarDecl *NewParm;
2867 NewParm = getDerived().TransformFunctionTypeParam(OldParm);
2870 NewType = NewParm->getType();
2872 // Deal with the possibility that we don't have a parameter
2873 // declaration for this parameter.
2877 QualType OldType = T->getArgType(i);
2878 NewType = getDerived().TransformType(OldType);
2879 if (NewType.isNull())
2883 PTypes.push_back(NewType);
2884 PVars.push_back(NewParm);
2890 template<typename Derived>
2892 TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB,
2893 FunctionProtoTypeLoc TL,
2894 QualType ObjectType) {
2895 // Transform the parameters. We do this first for the benefit of template
2896 // instantiations, so that the ParmVarDecls get/ placed into the template
2897 // instantiation scope before we transform the function type.
2898 llvm::SmallVector<QualType, 4> ParamTypes;
2899 llvm::SmallVector<ParmVarDecl*, 4> ParamDecls;
2900 if (getDerived().TransformFunctionTypeParams(TL, ParamTypes, ParamDecls))
2903 FunctionProtoType *T = TL.getTypePtr();
2904 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc());
2905 if (ResultType.isNull())
2908 QualType Result = TL.getType();
2909 if (getDerived().AlwaysRebuild() ||
2910 ResultType != T->getResultType() ||
2911 !std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) {
2912 Result = getDerived().RebuildFunctionProtoType(ResultType,
2917 if (Result.isNull())
2921 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result);
2922 NewTL.setLParenLoc(TL.getLParenLoc());
2923 NewTL.setRParenLoc(TL.getRParenLoc());
2924 for (unsigned i = 0, e = NewTL.getNumArgs(); i != e; ++i)
2925 NewTL.setArg(i, ParamDecls[i]);
2930 template<typename Derived>
2931 QualType TreeTransform<Derived>::TransformFunctionNoProtoType(
2932 TypeLocBuilder &TLB,
2933 FunctionNoProtoTypeLoc TL,
2934 QualType ObjectType) {
2935 FunctionNoProtoType *T = TL.getTypePtr();
2936 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc());
2937 if (ResultType.isNull())
2940 QualType Result = TL.getType();
2941 if (getDerived().AlwaysRebuild() ||
2942 ResultType != T->getResultType())
2943 Result = getDerived().RebuildFunctionNoProtoType(ResultType);
2945 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result);
2946 NewTL.setLParenLoc(TL.getLParenLoc());
2947 NewTL.setRParenLoc(TL.getRParenLoc());
2952 template<typename Derived> QualType
2953 TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB,
2954 UnresolvedUsingTypeLoc TL,
2955 QualType ObjectType) {
2956 UnresolvedUsingType *T = TL.getTypePtr();
2957 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl());
2961 QualType Result = TL.getType();
2962 if (getDerived().AlwaysRebuild() || D != T->getDecl()) {
2963 Result = getDerived().RebuildUnresolvedUsingType(D);
2964 if (Result.isNull())
2968 // We might get an arbitrary type spec type back. We should at
2969 // least always get a type spec type, though.
2970 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result);
2971 NewTL.setNameLoc(TL.getNameLoc());
2976 template<typename Derived>
2977 QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
2979 QualType ObjectType) {
2980 TypedefType *T = TL.getTypePtr();
2981 TypedefDecl *Typedef
2982 = cast_or_null<TypedefDecl>(getDerived().TransformDecl(TL.getNameLoc(),
2987 QualType Result = TL.getType();
2988 if (getDerived().AlwaysRebuild() ||
2989 Typedef != T->getDecl()) {
2990 Result = getDerived().RebuildTypedefType(Typedef);
2991 if (Result.isNull())
2995 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result);
2996 NewTL.setNameLoc(TL.getNameLoc());
3001 template<typename Derived>
3002 QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
3003 TypeOfExprTypeLoc TL,
3004 QualType ObjectType) {
3005 // typeof expressions are not potentially evaluated contexts
3006 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
3008 Sema::OwningExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
3012 QualType Result = TL.getType();
3013 if (getDerived().AlwaysRebuild() ||
3014 E.get() != TL.getUnderlyingExpr()) {
3015 Result = getDerived().RebuildTypeOfExprType(move(E));
3016 if (Result.isNull())
3021 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result);
3022 NewTL.setTypeofLoc(TL.getTypeofLoc());
3023 NewTL.setLParenLoc(TL.getLParenLoc());
3024 NewTL.setRParenLoc(TL.getRParenLoc());
3029 template<typename Derived>
3030 QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
3032 QualType ObjectType) {
3033 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo();
3034 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);
3038 QualType Result = TL.getType();
3039 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {
3040 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType());
3041 if (Result.isNull())
3045 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result);
3046 NewTL.setTypeofLoc(TL.getTypeofLoc());
3047 NewTL.setLParenLoc(TL.getLParenLoc());
3048 NewTL.setRParenLoc(TL.getRParenLoc());
3049 NewTL.setUnderlyingTInfo(New_Under_TI);
3054 template<typename Derived>
3055 QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
3057 QualType ObjectType) {
3058 DecltypeType *T = TL.getTypePtr();
3060 // decltype expressions are not potentially evaluated contexts
3061 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
3063 Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
3067 QualType Result = TL.getType();
3068 if (getDerived().AlwaysRebuild() ||
3069 E.get() != T->getUnderlyingExpr()) {
3070 Result = getDerived().RebuildDecltypeType(move(E));
3071 if (Result.isNull())
3076 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
3077 NewTL.setNameLoc(TL.getNameLoc());
3082 template<typename Derived>
3083 QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,
3085 QualType ObjectType) {
3086 RecordType *T = TL.getTypePtr();
3088 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(),
3093 QualType Result = TL.getType();
3094 if (getDerived().AlwaysRebuild() ||
3095 Record != T->getDecl()) {
3096 Result = getDerived().RebuildRecordType(Record);
3097 if (Result.isNull())
3101 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
3102 NewTL.setNameLoc(TL.getNameLoc());
3107 template<typename Derived>
3108 QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
3110 QualType ObjectType) {
3111 EnumType *T = TL.getTypePtr();
3113 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(),
3118 QualType Result = TL.getType();
3119 if (getDerived().AlwaysRebuild() ||
3120 Enum != T->getDecl()) {
3121 Result = getDerived().RebuildEnumType(Enum);
3122 if (Result.isNull())
3126 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result);
3127 NewTL.setNameLoc(TL.getNameLoc());
3132 template<typename Derived>
3133 QualType TreeTransform<Derived>::TransformInjectedClassNameType(
3134 TypeLocBuilder &TLB,
3135 InjectedClassNameTypeLoc TL,
3136 QualType ObjectType) {
3137 Decl *D = getDerived().TransformDecl(TL.getNameLoc(),
3138 TL.getTypePtr()->getDecl());
3139 if (!D) return QualType();
3141 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D));
3142 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc());
3147 template<typename Derived>
3148 QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
3149 TypeLocBuilder &TLB,
3150 TemplateTypeParmTypeLoc TL,
3151 QualType ObjectType) {
3152 return TransformTypeSpecType(TLB, TL);
3155 template<typename Derived>
3156 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
3157 TypeLocBuilder &TLB,
3158 SubstTemplateTypeParmTypeLoc TL,
3159 QualType ObjectType) {
3160 return TransformTypeSpecType(TLB, TL);
3163 template<typename Derived>
3164 QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
3165 const TemplateSpecializationType *TST,
3166 QualType ObjectType) {
3167 // FIXME: this entire method is a temporary workaround; callers
3168 // should be rewritten to provide real type locs.
3170 // Fake up a TemplateSpecializationTypeLoc.
3172 TemplateSpecializationTypeLoc TL
3173 = TLB.push<TemplateSpecializationTypeLoc>(QualType(TST, 0));
3175 SourceLocation BaseLoc = getDerived().getBaseLocation();
3177 TL.setTemplateNameLoc(BaseLoc);
3178 TL.setLAngleLoc(BaseLoc);
3179 TL.setRAngleLoc(BaseLoc);
3180 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
3181 const TemplateArgument &TA = TST->getArg(i);
3182 TemplateArgumentLoc TAL;
3183 getDerived().InventTemplateArgumentLoc(TA, TAL);
3184 TL.setArgLocInfo(i, TAL.getLocInfo());
3187 TypeLocBuilder IgnoredTLB;
3188 return TransformTemplateSpecializationType(IgnoredTLB, TL, ObjectType);
3191 template<typename Derived>
3192 QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
3193 TypeLocBuilder &TLB,
3194 TemplateSpecializationTypeLoc TL,
3195 QualType ObjectType) {
3196 const TemplateSpecializationType *T = TL.getTypePtr();
3198 TemplateName Template
3199 = getDerived().TransformTemplateName(T->getTemplateName(), ObjectType);
3200 if (Template.isNull())
3203 TemplateArgumentListInfo NewTemplateArgs;
3204 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
3205 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
3207 for (unsigned i = 0, e = T->getNumArgs(); i != e; ++i) {
3208 TemplateArgumentLoc Loc;
3209 if (getDerived().TransformTemplateArgument(TL.getArgLoc(i), Loc))
3211 NewTemplateArgs.addArgument(Loc);
3214 // FIXME: maybe don't rebuild if all the template arguments are the same.
3217 getDerived().RebuildTemplateSpecializationType(Template,
3218 TL.getTemplateNameLoc(),
3221 if (!Result.isNull()) {
3222 TemplateSpecializationTypeLoc NewTL
3223 = TLB.push<TemplateSpecializationTypeLoc>(Result);
3224 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
3225 NewTL.setLAngleLoc(TL.getLAngleLoc());
3226 NewTL.setRAngleLoc(TL.getRAngleLoc());
3227 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
3228 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
3234 template<typename Derived>
3236 TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB,
3237 ElaboratedTypeLoc TL,
3238 QualType ObjectType) {
3239 ElaboratedType *T = TL.getTypePtr();
3241 NestedNameSpecifier *NNS = 0;
3242 // NOTE: the qualifier in an ElaboratedType is optional.
3243 if (T->getQualifier() != 0) {
3244 NNS = getDerived().TransformNestedNameSpecifier(T->getQualifier(),
3245 TL.getQualifierRange(),
3252 // FIXME: this test is meant to workaround a problem (failing assertion)
3253 // occurring if directly executing the code in the else branch.
3254 if (isa<TemplateSpecializationTypeLoc>(TL.getNamedTypeLoc())) {
3255 TemplateSpecializationTypeLoc OldNamedTL
3256 = cast<TemplateSpecializationTypeLoc>(TL.getNamedTypeLoc());
3257 const TemplateSpecializationType* OldTST
3258 = OldNamedTL.getType()->template getAs<TemplateSpecializationType>();
3259 NamedT = TransformTemplateSpecializationType(OldTST, ObjectType);
3260 if (NamedT.isNull())
3262 TemplateSpecializationTypeLoc NewNamedTL
3263 = TLB.push<TemplateSpecializationTypeLoc>(NamedT);
3264 NewNamedTL.copy(OldNamedTL);
3267 NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc());
3268 if (NamedT.isNull())
3272 QualType Result = TL.getType();
3273 if (getDerived().AlwaysRebuild() ||
3274 NNS != T->getQualifier() ||
3275 NamedT != T->getNamedType()) {
3276 Result = getDerived().RebuildElaboratedType(T->getKeyword(), NNS, NamedT);
3277 if (Result.isNull())
3281 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
3282 NewTL.setKeywordLoc(TL.getKeywordLoc());
3283 NewTL.setQualifierRange(TL.getQualifierRange());
3288 template<typename Derived>
3289 QualType TreeTransform<Derived>::TransformDependentNameType(TypeLocBuilder &TLB,
3290 DependentNameTypeLoc TL,
3291 QualType ObjectType) {
3292 DependentNameType *T = TL.getTypePtr();
3294 NestedNameSpecifier *NNS
3295 = getDerived().TransformNestedNameSpecifier(T->getQualifier(),
3296 TL.getQualifierRange(),
3303 if (const TemplateSpecializationType *TemplateId = T->getTemplateId()) {
3304 QualType NewTemplateId
3305 = getDerived().TransformType(QualType(TemplateId, 0));
3306 if (NewTemplateId.isNull())
3309 if (!getDerived().AlwaysRebuild() &&
3310 NNS == T->getQualifier() &&
3311 NewTemplateId == QualType(TemplateId, 0))
3312 return QualType(T, 0);
3314 Result = getDerived().RebuildDependentNameType(T->getKeyword(), NNS,
3317 Result = getDerived().RebuildDependentNameType(T->getKeyword(), NNS,
3320 TL.getQualifierRange(),
3323 if (Result.isNull())
3326 if (const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) {
3327 QualType NamedT = ElabT->getNamedType();
3328 if (isa<TemplateSpecializationType>(NamedT)) {
3329 TemplateSpecializationTypeLoc NamedTLoc
3330 = TLB.push<TemplateSpecializationTypeLoc>(NamedT);
3331 // FIXME: fill locations
3332 NamedTLoc.initializeLocal(TL.getNameLoc());
3334 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc());
3336 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
3337 NewTL.setKeywordLoc(TL.getKeywordLoc());
3338 NewTL.setQualifierRange(TL.getQualifierRange());
3341 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result);
3342 NewTL.setKeywordLoc(TL.getKeywordLoc());
3343 NewTL.setQualifierRange(TL.getQualifierRange());
3344 NewTL.setNameLoc(TL.getNameLoc());
3349 template<typename Derived>
3351 TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
3352 ObjCInterfaceTypeLoc TL,
3353 QualType ObjectType) {
3354 // ObjCInterfaceType is never dependent.
3355 TLB.pushFullCopy(TL);
3356 return TL.getType();
3359 template<typename Derived>
3361 TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
3362 ObjCObjectTypeLoc TL,
3363 QualType ObjectType) {
3364 // ObjCObjectType is never dependent.
3365 TLB.pushFullCopy(TL);
3366 return TL.getType();
3369 template<typename Derived>
3371 TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
3372 ObjCObjectPointerTypeLoc TL,
3373 QualType ObjectType) {
3374 // ObjCObjectPointerType is never dependent.
3375 TLB.pushFullCopy(TL);
3376 return TL.getType();
3379 //===----------------------------------------------------------------------===//
3380 // Statement transformation
3381 //===----------------------------------------------------------------------===//
3382 template<typename Derived>
3383 Sema::OwningStmtResult
3384 TreeTransform<Derived>::TransformNullStmt(NullStmt *S) {
3385 return SemaRef.Owned(S->Retain());
3388 template<typename Derived>
3389 Sema::OwningStmtResult
3390 TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) {
3391 return getDerived().TransformCompoundStmt(S, false);
3394 template<typename Derived>
3395 Sema::OwningStmtResult
3396 TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S,
3398 bool SubStmtChanged = false;
3399 ASTOwningVector<&ActionBase::DeleteStmt> Statements(getSema());
3400 for (CompoundStmt::body_iterator B = S->body_begin(), BEnd = S->body_end();
3402 OwningStmtResult Result = getDerived().TransformStmt(*B);
3403 if (Result.isInvalid())
3404 return getSema().StmtError();
3406 SubStmtChanged = SubStmtChanged || Result.get() != *B;
3407 Statements.push_back(Result.takeAs<Stmt>());
3410 if (!getDerived().AlwaysRebuild() &&
3412 return SemaRef.Owned(S->Retain());
3414 return getDerived().RebuildCompoundStmt(S->getLBracLoc(),
3415 move_arg(Statements),
3420 template<typename Derived>
3421 Sema::OwningStmtResult
3422 TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
3423 OwningExprResult LHS(SemaRef), RHS(SemaRef);
3425 // The case value expressions are not potentially evaluated.
3426 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
3428 // Transform the left-hand case value.
3429 LHS = getDerived().TransformExpr(S->getLHS());
3430 if (LHS.isInvalid())
3431 return SemaRef.StmtError();
3433 // Transform the right-hand case value (for the GNU case-range extension).
3434 RHS = getDerived().TransformExpr(S->getRHS());
3435 if (RHS.isInvalid())
3436 return SemaRef.StmtError();
3439 // Build the case statement.
3440 // Case statements are always rebuilt so that they will attached to their
3441 // transformed switch statement.
3442 OwningStmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
3444 S->getEllipsisLoc(),
3447 if (Case.isInvalid())
3448 return SemaRef.StmtError();
3450 // Transform the statement following the case
3451 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
3452 if (SubStmt.isInvalid())
3453 return SemaRef.StmtError();
3455 // Attach the body to the case statement
3456 return getDerived().RebuildCaseStmtBody(move(Case), move(SubStmt));
3459 template<typename Derived>
3460 Sema::OwningStmtResult
3461 TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
3462 // Transform the statement following the default case
3463 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
3464 if (SubStmt.isInvalid())
3465 return SemaRef.StmtError();
3467 // Default statements are always rebuilt
3468 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
3472 template<typename Derived>
3473 Sema::OwningStmtResult
3474 TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) {
3475 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
3476 if (SubStmt.isInvalid())
3477 return SemaRef.StmtError();
3479 // FIXME: Pass the real colon location in.
3480 SourceLocation ColonLoc = SemaRef.PP.getLocForEndOfToken(S->getIdentLoc());
3481 return getDerived().RebuildLabelStmt(S->getIdentLoc(), S->getID(), ColonLoc,
3485 template<typename Derived>
3486 Sema::OwningStmtResult
3487 TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
3488 // Transform the condition
3489 OwningExprResult Cond(SemaRef);
3490 VarDecl *ConditionVar = 0;
3491 if (S->getConditionVariable()) {
3493 = cast_or_null<VarDecl>(
3494 getDerived().TransformDefinition(
3495 S->getConditionVariable()->getLocation(),
3496 S->getConditionVariable()));
3498 return SemaRef.StmtError();
3500 Cond = getDerived().TransformExpr(S->getCond());
3502 if (Cond.isInvalid())
3503 return SemaRef.StmtError();
3505 // Convert the condition to a boolean value.
3507 OwningExprResult CondE = getSema().ActOnBooleanCondition(0,
3510 if (CondE.isInvalid())
3511 return getSema().StmtError();
3517 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond));
3518 if (!S->getConditionVariable() && S->getCond() && !FullCond->get())
3519 return SemaRef.StmtError();
3521 // Transform the "then" branch.
3522 OwningStmtResult Then = getDerived().TransformStmt(S->getThen());
3523 if (Then.isInvalid())
3524 return SemaRef.StmtError();
3526 // Transform the "else" branch.
3527 OwningStmtResult Else = getDerived().TransformStmt(S->getElse());
3528 if (Else.isInvalid())
3529 return SemaRef.StmtError();
3531 if (!getDerived().AlwaysRebuild() &&
3532 FullCond->get() == S->getCond() &&
3533 ConditionVar == S->getConditionVariable() &&
3534 Then.get() == S->getThen() &&
3535 Else.get() == S->getElse())
3536 return SemaRef.Owned(S->Retain());
3538 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar,
3540 S->getElseLoc(), move(Else));
3543 template<typename Derived>
3544 Sema::OwningStmtResult
3545 TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
3546 // Transform the condition.
3547 OwningExprResult Cond(SemaRef);
3548 VarDecl *ConditionVar = 0;
3549 if (S->getConditionVariable()) {
3551 = cast_or_null<VarDecl>(
3552 getDerived().TransformDefinition(
3553 S->getConditionVariable()->getLocation(),
3554 S->getConditionVariable()));
3556 return SemaRef.StmtError();
3558 Cond = getDerived().TransformExpr(S->getCond());
3560 if (Cond.isInvalid())
3561 return SemaRef.StmtError();
3564 // Rebuild the switch statement.
3565 OwningStmtResult Switch
3566 = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), move(Cond),
3568 if (Switch.isInvalid())
3569 return SemaRef.StmtError();
3571 // Transform the body of the switch statement.
3572 OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3573 if (Body.isInvalid())
3574 return SemaRef.StmtError();
3576 // Complete the switch statement.
3577 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), move(Switch),
3581 template<typename Derived>
3582 Sema::OwningStmtResult
3583 TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
3584 // Transform the condition
3585 OwningExprResult Cond(SemaRef);
3586 VarDecl *ConditionVar = 0;
3587 if (S->getConditionVariable()) {
3589 = cast_or_null<VarDecl>(
3590 getDerived().TransformDefinition(
3591 S->getConditionVariable()->getLocation(),
3592 S->getConditionVariable()));
3594 return SemaRef.StmtError();
3596 Cond = getDerived().TransformExpr(S->getCond());
3598 if (Cond.isInvalid())
3599 return SemaRef.StmtError();
3602 // Convert the condition to a boolean value.
3603 OwningExprResult CondE = getSema().ActOnBooleanCondition(0,
3606 if (CondE.isInvalid())
3607 return getSema().StmtError();
3612 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond));
3613 if (!S->getConditionVariable() && S->getCond() && !FullCond->get())
3614 return SemaRef.StmtError();
3616 // Transform the body
3617 OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3618 if (Body.isInvalid())
3619 return SemaRef.StmtError();
3621 if (!getDerived().AlwaysRebuild() &&
3622 FullCond->get() == S->getCond() &&
3623 ConditionVar == S->getConditionVariable() &&
3624 Body.get() == S->getBody())
3625 return SemaRef.Owned(S->Retain());
3627 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond,
3628 ConditionVar, move(Body));
3631 template<typename Derived>
3632 Sema::OwningStmtResult
3633 TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
3634 // Transform the body
3635 OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3636 if (Body.isInvalid())
3637 return SemaRef.StmtError();
3639 // Transform the condition
3640 OwningExprResult Cond = getDerived().TransformExpr(S->getCond());
3641 if (Cond.isInvalid())
3642 return SemaRef.StmtError();
3644 if (!getDerived().AlwaysRebuild() &&
3645 Cond.get() == S->getCond() &&
3646 Body.get() == S->getBody())
3647 return SemaRef.Owned(S->Retain());
3649 return getDerived().RebuildDoStmt(S->getDoLoc(), move(Body), S->getWhileLoc(),
3650 /*FIXME:*/S->getWhileLoc(), move(Cond),
3654 template<typename Derived>
3655 Sema::OwningStmtResult
3656 TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
3657 // Transform the initialization statement
3658 OwningStmtResult Init = getDerived().TransformStmt(S->getInit());
3659 if (Init.isInvalid())
3660 return SemaRef.StmtError();
3662 // Transform the condition
3663 OwningExprResult Cond(SemaRef);
3664 VarDecl *ConditionVar = 0;
3665 if (S->getConditionVariable()) {
3667 = cast_or_null<VarDecl>(
3668 getDerived().TransformDefinition(
3669 S->getConditionVariable()->getLocation(),
3670 S->getConditionVariable()));
3672 return SemaRef.StmtError();
3674 Cond = getDerived().TransformExpr(S->getCond());
3676 if (Cond.isInvalid())
3677 return SemaRef.StmtError();
3680 // Convert the condition to a boolean value.
3681 OwningExprResult CondE = getSema().ActOnBooleanCondition(0,
3684 if (CondE.isInvalid())
3685 return getSema().StmtError();
3691 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond));
3692 if (!S->getConditionVariable() && S->getCond() && !FullCond->get())
3693 return SemaRef.StmtError();
3695 // Transform the increment
3696 OwningExprResult Inc = getDerived().TransformExpr(S->getInc());
3697 if (Inc.isInvalid())
3698 return SemaRef.StmtError();
3700 Sema::FullExprArg FullInc(getSema().MakeFullExpr(Inc));
3701 if (S->getInc() && !FullInc->get())
3702 return SemaRef.StmtError();
3704 // Transform the body
3705 OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3706 if (Body.isInvalid())
3707 return SemaRef.StmtError();
3709 if (!getDerived().AlwaysRebuild() &&
3710 Init.get() == S->getInit() &&
3711 FullCond->get() == S->getCond() &&
3712 Inc.get() == S->getInc() &&
3713 Body.get() == S->getBody())
3714 return SemaRef.Owned(S->Retain());
3716 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
3717 move(Init), FullCond, ConditionVar,
3718 FullInc, S->getRParenLoc(), move(Body));
3721 template<typename Derived>
3722 Sema::OwningStmtResult
3723 TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
3724 // Goto statements must always be rebuilt, to resolve the label.
3725 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
3729 template<typename Derived>
3730 Sema::OwningStmtResult
3731 TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
3732 OwningExprResult Target = getDerived().TransformExpr(S->getTarget());
3733 if (Target.isInvalid())
3734 return SemaRef.StmtError();
3736 if (!getDerived().AlwaysRebuild() &&
3737 Target.get() == S->getTarget())
3738 return SemaRef.Owned(S->Retain());
3740 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
3744 template<typename Derived>
3745 Sema::OwningStmtResult
3746 TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
3747 return SemaRef.Owned(S->Retain());
3750 template<typename Derived>
3751 Sema::OwningStmtResult
3752 TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
3753 return SemaRef.Owned(S->Retain());
3756 template<typename Derived>
3757 Sema::OwningStmtResult
3758 TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
3759 Sema::OwningExprResult Result = getDerived().TransformExpr(S->getRetValue());
3760 if (Result.isInvalid())
3761 return SemaRef.StmtError();
3763 // FIXME: We always rebuild the return statement because there is no way
3764 // to tell whether the return type of the function has changed.
3765 return getDerived().RebuildReturnStmt(S->getReturnLoc(), move(Result));
3768 template<typename Derived>
3769 Sema::OwningStmtResult
3770 TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
3771 bool DeclChanged = false;
3772 llvm::SmallVector<Decl *, 4> Decls;
3773 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end();
3775 Decl *Transformed = getDerived().TransformDefinition((*D)->getLocation(),
3778 return SemaRef.StmtError();
3780 if (Transformed != *D)
3783 Decls.push_back(Transformed);
3786 if (!getDerived().AlwaysRebuild() && !DeclChanged)
3787 return SemaRef.Owned(S->Retain());
3789 return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(),
3790 S->getStartLoc(), S->getEndLoc());
3793 template<typename Derived>
3794 Sema::OwningStmtResult
3795 TreeTransform<Derived>::TransformSwitchCase(SwitchCase *S) {
3796 assert(false && "SwitchCase is abstract and cannot be transformed");
3797 return SemaRef.Owned(S->Retain());
3800 template<typename Derived>
3801 Sema::OwningStmtResult
3802 TreeTransform<Derived>::TransformAsmStmt(AsmStmt *S) {
3804 ASTOwningVector<&ActionBase::DeleteExpr> Constraints(getSema());
3805 ASTOwningVector<&ActionBase::DeleteExpr> Exprs(getSema());
3806 llvm::SmallVector<IdentifierInfo *, 4> Names;
3808 OwningExprResult AsmString(SemaRef);
3809 ASTOwningVector<&ActionBase::DeleteExpr> Clobbers(getSema());
3811 bool ExprsChanged = false;
3813 // Go through the outputs.
3814 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) {
3815 Names.push_back(S->getOutputIdentifier(I));
3817 // No need to transform the constraint literal.
3818 Constraints.push_back(S->getOutputConstraintLiteral(I)->Retain());
3820 // Transform the output expr.
3821 Expr *OutputExpr = S->getOutputExpr(I);
3822 OwningExprResult Result = getDerived().TransformExpr(OutputExpr);
3823 if (Result.isInvalid())
3824 return SemaRef.StmtError();
3826 ExprsChanged |= Result.get() != OutputExpr;
3828 Exprs.push_back(Result.takeAs<Expr>());
3831 // Go through the inputs.
3832 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) {
3833 Names.push_back(S->getInputIdentifier(I));
3835 // No need to transform the constraint literal.
3836 Constraints.push_back(S->getInputConstraintLiteral(I)->Retain());
3838 // Transform the input expr.
3839 Expr *InputExpr = S->getInputExpr(I);
3840 OwningExprResult Result = getDerived().TransformExpr(InputExpr);
3841 if (Result.isInvalid())
3842 return SemaRef.StmtError();
3844 ExprsChanged |= Result.get() != InputExpr;
3846 Exprs.push_back(Result.takeAs<Expr>());
3849 if (!getDerived().AlwaysRebuild() && !ExprsChanged)
3850 return SemaRef.Owned(S->Retain());
3852 // Go through the clobbers.
3853 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I)
3854 Clobbers.push_back(S->getClobber(I)->Retain());
3856 // No need to transform the asm string literal.
3857 AsmString = SemaRef.Owned(S->getAsmString());
3859 return getDerived().RebuildAsmStmt(S->getAsmLoc(),
3865 move_arg(Constraints),
3874 template<typename Derived>
3875 Sema::OwningStmtResult
3876 TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
3877 // Transform the body of the @try.
3878 OwningStmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
3879 if (TryBody.isInvalid())
3880 return SemaRef.StmtError();
3882 // Transform the @catch statements (if present).
3883 bool AnyCatchChanged = false;
3884 ASTOwningVector<&ActionBase::DeleteStmt> CatchStmts(SemaRef);
3885 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
3886 OwningStmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I));
3887 if (Catch.isInvalid())
3888 return SemaRef.StmtError();
3889 if (Catch.get() != S->getCatchStmt(I))
3890 AnyCatchChanged = true;
3891 CatchStmts.push_back(Catch.release());
3894 // Transform the @finally statement (if present).
3895 OwningStmtResult Finally(SemaRef);
3896 if (S->getFinallyStmt()) {
3897 Finally = getDerived().TransformStmt(S->getFinallyStmt());
3898 if (Finally.isInvalid())
3899 return SemaRef.StmtError();
3902 // If nothing changed, just retain this statement.
3903 if (!getDerived().AlwaysRebuild() &&
3904 TryBody.get() == S->getTryBody() &&
3906 Finally.get() == S->getFinallyStmt())
3907 return SemaRef.Owned(S->Retain());
3909 // Build a new statement.
3910 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), move(TryBody),
3911 move_arg(CatchStmts), move(Finally));
3914 template<typename Derived>
3915 Sema::OwningStmtResult
3916 TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
3917 // Transform the @catch parameter, if there is one.
3919 if (VarDecl *FromVar = S->getCatchParamDecl()) {
3920 TypeSourceInfo *TSInfo = 0;
3921 if (FromVar->getTypeSourceInfo()) {
3922 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
3924 return SemaRef.StmtError();
3929 T = TSInfo->getType();
3931 T = getDerived().TransformType(FromVar->getType());
3933 return SemaRef.StmtError();
3936 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T);
3938 return SemaRef.StmtError();
3941 OwningStmtResult Body = getDerived().TransformStmt(S->getCatchBody());
3942 if (Body.isInvalid())
3943 return SemaRef.StmtError();
3945 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
3950 template<typename Derived>
3951 Sema::OwningStmtResult
3952 TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
3953 // Transform the body.
3954 OwningStmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
3955 if (Body.isInvalid())
3956 return SemaRef.StmtError();
3958 // If nothing changed, just retain this statement.
3959 if (!getDerived().AlwaysRebuild() &&
3960 Body.get() == S->getFinallyBody())
3961 return SemaRef.Owned(S->Retain());
3963 // Build a new statement.
3964 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
3968 template<typename Derived>
3969 Sema::OwningStmtResult
3970 TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
3971 OwningExprResult Operand(SemaRef);
3972 if (S->getThrowExpr()) {
3973 Operand = getDerived().TransformExpr(S->getThrowExpr());
3974 if (Operand.isInvalid())
3975 return getSema().StmtError();
3978 if (!getDerived().AlwaysRebuild() &&
3979 Operand.get() == S->getThrowExpr())
3980 return getSema().Owned(S->Retain());
3982 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), move(Operand));
3985 template<typename Derived>
3986 Sema::OwningStmtResult
3987 TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
3988 ObjCAtSynchronizedStmt *S) {
3989 // Transform the object we are locking.
3990 OwningExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
3991 if (Object.isInvalid())
3992 return SemaRef.StmtError();
3994 // Transform the body.
3995 OwningStmtResult Body = getDerived().TransformStmt(S->getSynchBody());
3996 if (Body.isInvalid())
3997 return SemaRef.StmtError();
3999 // If nothing change, just retain the current statement.
4000 if (!getDerived().AlwaysRebuild() &&
4001 Object.get() == S->getSynchExpr() &&
4002 Body.get() == S->getSynchBody())
4003 return SemaRef.Owned(S->Retain());
4005 // Build a new statement.
4006 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
4007 move(Object), move(Body));
4010 template<typename Derived>
4011 Sema::OwningStmtResult
4012 TreeTransform<Derived>::TransformObjCForCollectionStmt(
4013 ObjCForCollectionStmt *S) {
4014 // Transform the element statement.
4015 OwningStmtResult Element = getDerived().TransformStmt(S->getElement());
4016 if (Element.isInvalid())
4017 return SemaRef.StmtError();
4019 // Transform the collection expression.
4020 OwningExprResult Collection = getDerived().TransformExpr(S->getCollection());
4021 if (Collection.isInvalid())
4022 return SemaRef.StmtError();
4024 // Transform the body.
4025 OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
4026 if (Body.isInvalid())
4027 return SemaRef.StmtError();
4029 // If nothing changed, just retain this statement.
4030 if (!getDerived().AlwaysRebuild() &&
4031 Element.get() == S->getElement() &&
4032 Collection.get() == S->getCollection() &&
4033 Body.get() == S->getBody())
4034 return SemaRef.Owned(S->Retain());
4036 // Build a new statement.
4037 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
4038 /*FIXME:*/S->getForLoc(),
4046 template<typename Derived>
4047 Sema::OwningStmtResult
4048 TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
4049 // Transform the exception declaration, if any.
4051 if (S->getExceptionDecl()) {
4052 VarDecl *ExceptionDecl = S->getExceptionDecl();
4053 TemporaryBase Rebase(*this, ExceptionDecl->getLocation(),
4054 ExceptionDecl->getDeclName());
4056 QualType T = getDerived().TransformType(ExceptionDecl->getType());
4058 return SemaRef.StmtError();
4060 Var = getDerived().RebuildExceptionDecl(ExceptionDecl,
4062 ExceptionDecl->getTypeSourceInfo(),
4063 ExceptionDecl->getIdentifier(),
4064 ExceptionDecl->getLocation(),
4065 /*FIXME: Inaccurate*/
4066 SourceRange(ExceptionDecl->getLocation()));
4067 if (!Var || Var->isInvalidDecl()) {
4069 Var->Destroy(SemaRef.Context);
4070 return SemaRef.StmtError();
4074 // Transform the actual exception handler.
4075 OwningStmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
4076 if (Handler.isInvalid()) {
4078 Var->Destroy(SemaRef.Context);
4079 return SemaRef.StmtError();
4082 if (!getDerived().AlwaysRebuild() &&
4084 Handler.get() == S->getHandlerBlock())
4085 return SemaRef.Owned(S->Retain());
4087 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(),
4092 template<typename Derived>
4093 Sema::OwningStmtResult
4094 TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
4095 // Transform the try block itself.
4096 OwningStmtResult TryBlock
4097 = getDerived().TransformCompoundStmt(S->getTryBlock());
4098 if (TryBlock.isInvalid())
4099 return SemaRef.StmtError();
4101 // Transform the handlers.
4102 bool HandlerChanged = false;
4103 ASTOwningVector<&ActionBase::DeleteStmt> Handlers(SemaRef);
4104 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) {
4105 OwningStmtResult Handler
4106 = getDerived().TransformCXXCatchStmt(S->getHandler(I));
4107 if (Handler.isInvalid())
4108 return SemaRef.StmtError();
4110 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I);
4111 Handlers.push_back(Handler.takeAs<Stmt>());
4114 if (!getDerived().AlwaysRebuild() &&
4115 TryBlock.get() == S->getTryBlock() &&
4117 return SemaRef.Owned(S->Retain());
4119 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), move(TryBlock),
4120 move_arg(Handlers));
4123 //===----------------------------------------------------------------------===//
4124 // Expression transformation
4125 //===----------------------------------------------------------------------===//
4126 template<typename Derived>
4127 Sema::OwningExprResult
4128 TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) {
4129 return SemaRef.Owned(E->Retain());
4132 template<typename Derived>
4133 Sema::OwningExprResult
4134 TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) {
4135 NestedNameSpecifier *Qualifier = 0;
4136 if (E->getQualifier()) {
4137 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
4138 E->getQualifierRange());
4140 return SemaRef.ExprError();
4144 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
4147 return SemaRef.ExprError();
4149 if (!getDerived().AlwaysRebuild() &&
4150 Qualifier == E->getQualifier() &&
4151 ND == E->getDecl() &&
4152 !E->hasExplicitTemplateArgumentList()) {
4154 // Mark it referenced in the new context regardless.
4155 // FIXME: this is a bit instantiation-specific.
4156 SemaRef.MarkDeclarationReferenced(E->getLocation(), ND);
4158 return SemaRef.Owned(E->Retain());
4161 TemplateArgumentListInfo TransArgs, *TemplateArgs = 0;
4162 if (E->hasExplicitTemplateArgumentList()) {
4163 TemplateArgs = &TransArgs;
4164 TransArgs.setLAngleLoc(E->getLAngleLoc());
4165 TransArgs.setRAngleLoc(E->getRAngleLoc());
4166 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
4167 TemplateArgumentLoc Loc;
4168 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc))
4169 return SemaRef.ExprError();
4170 TransArgs.addArgument(Loc);
4174 return getDerived().RebuildDeclRefExpr(Qualifier, E->getQualifierRange(),
4175 ND, E->getLocation(), TemplateArgs);
4178 template<typename Derived>
4179 Sema::OwningExprResult
4180 TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) {
4181 return SemaRef.Owned(E->Retain());
4184 template<typename Derived>
4185 Sema::OwningExprResult
4186 TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) {
4187 return SemaRef.Owned(E->Retain());
4190 template<typename Derived>
4191 Sema::OwningExprResult
4192 TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) {
4193 return SemaRef.Owned(E->Retain());
4196 template<typename Derived>
4197 Sema::OwningExprResult
4198 TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) {
4199 return SemaRef.Owned(E->Retain());
4202 template<typename Derived>
4203 Sema::OwningExprResult
4204 TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) {
4205 return SemaRef.Owned(E->Retain());
4208 template<typename Derived>
4209 Sema::OwningExprResult
4210 TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
4211 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
4212 if (SubExpr.isInvalid())
4213 return SemaRef.ExprError();
4215 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
4216 return SemaRef.Owned(E->Retain());
4218 return getDerived().RebuildParenExpr(move(SubExpr), E->getLParen(),
4222 template<typename Derived>
4223 Sema::OwningExprResult
4224 TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) {
4225 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
4226 if (SubExpr.isInvalid())
4227 return SemaRef.ExprError();
4229 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
4230 return SemaRef.Owned(E->Retain());
4232 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(),
4237 template<typename Derived>
4238 Sema::OwningExprResult
4239 TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) {
4240 // Transform the type.
4241 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
4243 return getSema().ExprError();
4245 // Transform all of the components into components similar to what the
4247 // FIXME: It would be slightly more efficient in the non-dependent case to
4248 // just map FieldDecls, rather than requiring the rebuilder to look for
4249 // the fields again. However, __builtin_offsetof is rare enough in
4250 // template code that we don't care.
4251 bool ExprChanged = false;
4252 typedef Action::OffsetOfComponent Component;
4253 typedef OffsetOfExpr::OffsetOfNode Node;
4254 llvm::SmallVector<Component, 4> Components;
4255 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
4256 const Node &ON = E->getComponent(I);
4258 Comp.isBrackets = true;
4259 Comp.LocStart = ON.getRange().getBegin();
4260 Comp.LocEnd = ON.getRange().getEnd();
4261 switch (ON.getKind()) {
4263 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex());
4264 OwningExprResult Index = getDerived().TransformExpr(FromIndex);
4265 if (Index.isInvalid())
4266 return getSema().ExprError();
4268 ExprChanged = ExprChanged || Index.get() != FromIndex;
4269 Comp.isBrackets = true;
4270 Comp.U.E = Index.takeAs<Expr>(); // FIXME: leaked
4275 case Node::Identifier:
4276 Comp.isBrackets = false;
4277 Comp.U.IdentInfo = ON.getFieldName();
4278 if (!Comp.U.IdentInfo)
4284 // Will be recomputed during the rebuild.
4288 Components.push_back(Comp);
4291 // If nothing changed, retain the existing expression.
4292 if (!getDerived().AlwaysRebuild() &&
4293 Type == E->getTypeSourceInfo() &&
4295 return SemaRef.Owned(E->Retain());
4297 // Build a new offsetof expression.
4298 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type,
4299 Components.data(), Components.size(),
4303 template<typename Derived>
4304 Sema::OwningExprResult
4305 TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
4306 if (E->isArgumentType()) {
4307 TypeSourceInfo *OldT = E->getArgumentTypeInfo();
4309 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
4311 return SemaRef.ExprError();
4313 if (!getDerived().AlwaysRebuild() && OldT == NewT)
4314 return SemaRef.Owned(E->Retain());
4316 return getDerived().RebuildSizeOfAlignOf(NewT, E->getOperatorLoc(),
4318 E->getSourceRange());
4321 Sema::OwningExprResult SubExpr(SemaRef);
4323 // C++0x [expr.sizeof]p1:
4324 // The operand is either an expression, which is an unevaluated operand
4326 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
4328 SubExpr = getDerived().TransformExpr(E->getArgumentExpr());
4329 if (SubExpr.isInvalid())
4330 return SemaRef.ExprError();
4332 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
4333 return SemaRef.Owned(E->Retain());
4336 return getDerived().RebuildSizeOfAlignOf(move(SubExpr), E->getOperatorLoc(),
4338 E->getSourceRange());
4341 template<typename Derived>
4342 Sema::OwningExprResult
4343 TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
4344 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS());
4345 if (LHS.isInvalid())
4346 return SemaRef.ExprError();
4348 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS());
4349 if (RHS.isInvalid())
4350 return SemaRef.ExprError();
4353 if (!getDerived().AlwaysRebuild() &&
4354 LHS.get() == E->getLHS() &&
4355 RHS.get() == E->getRHS())
4356 return SemaRef.Owned(E->Retain());
4358 return getDerived().RebuildArraySubscriptExpr(move(LHS),
4359 /*FIXME:*/E->getLHS()->getLocStart(),
4361 E->getRBracketLoc());
4364 template<typename Derived>
4365 Sema::OwningExprResult
4366 TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
4367 // Transform the callee.
4368 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee());
4369 if (Callee.isInvalid())
4370 return SemaRef.ExprError();
4372 // Transform arguments.
4373 bool ArgChanged = false;
4374 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
4375 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs;
4376 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
4377 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I));
4378 if (Arg.isInvalid())
4379 return SemaRef.ExprError();
4381 // FIXME: Wrong source location information for the ','.
4382 FakeCommaLocs.push_back(
4383 SemaRef.PP.getLocForEndOfToken(E->getArg(I)->getSourceRange().getEnd()));
4385 ArgChanged = ArgChanged || Arg.get() != E->getArg(I);
4386 Args.push_back(Arg.takeAs<Expr>());
4389 if (!getDerived().AlwaysRebuild() &&
4390 Callee.get() == E->getCallee() &&
4392 return SemaRef.Owned(E->Retain());
4394 // FIXME: Wrong source location information for the '('.
4395 SourceLocation FakeLParenLoc
4396 = ((Expr *)Callee.get())->getSourceRange().getBegin();
4397 return getDerived().RebuildCallExpr(move(Callee), FakeLParenLoc,
4399 FakeCommaLocs.data(),
4403 template<typename Derived>
4404 Sema::OwningExprResult
4405 TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
4406 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
4407 if (Base.isInvalid())
4408 return SemaRef.ExprError();
4410 NestedNameSpecifier *Qualifier = 0;
4411 if (E->hasQualifier()) {
4413 = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
4414 E->getQualifierRange());
4416 return SemaRef.ExprError();
4420 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
4421 E->getMemberDecl()));
4423 return SemaRef.ExprError();
4425 NamedDecl *FoundDecl = E->getFoundDecl();
4426 if (FoundDecl == E->getMemberDecl()) {
4429 FoundDecl = cast_or_null<NamedDecl>(
4430 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl));
4432 return SemaRef.ExprError();
4435 if (!getDerived().AlwaysRebuild() &&
4436 Base.get() == E->getBase() &&
4437 Qualifier == E->getQualifier() &&
4438 Member == E->getMemberDecl() &&
4439 FoundDecl == E->getFoundDecl() &&
4440 !E->hasExplicitTemplateArgumentList()) {
4442 // Mark it referenced in the new context regardless.
4443 // FIXME: this is a bit instantiation-specific.
4444 SemaRef.MarkDeclarationReferenced(E->getMemberLoc(), Member);
4445 return SemaRef.Owned(E->Retain());
4448 TemplateArgumentListInfo TransArgs;
4449 if (E->hasExplicitTemplateArgumentList()) {
4450 TransArgs.setLAngleLoc(E->getLAngleLoc());
4451 TransArgs.setRAngleLoc(E->getRAngleLoc());
4452 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
4453 TemplateArgumentLoc Loc;
4454 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc))
4455 return SemaRef.ExprError();
4456 TransArgs.addArgument(Loc);
4460 // FIXME: Bogus source location for the operator
4461 SourceLocation FakeOperatorLoc
4462 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd());
4464 // FIXME: to do this check properly, we will need to preserve the
4465 // first-qualifier-in-scope here, just in case we had a dependent
4466 // base (and therefore couldn't do the check) and a
4467 // nested-name-qualifier (and therefore could do the lookup).
4468 NamedDecl *FirstQualifierInScope = 0;
4470 return getDerived().RebuildMemberExpr(move(Base), FakeOperatorLoc,
4473 E->getQualifierRange(),
4477 (E->hasExplicitTemplateArgumentList()
4479 FirstQualifierInScope);
4482 template<typename Derived>
4483 Sema::OwningExprResult
4484 TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
4485 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS());
4486 if (LHS.isInvalid())
4487 return SemaRef.ExprError();
4489 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS());
4490 if (RHS.isInvalid())
4491 return SemaRef.ExprError();
4493 if (!getDerived().AlwaysRebuild() &&
4494 LHS.get() == E->getLHS() &&
4495 RHS.get() == E->getRHS())
4496 return SemaRef.Owned(E->Retain());
4498 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
4499 move(LHS), move(RHS));
4502 template<typename Derived>
4503 Sema::OwningExprResult
4504 TreeTransform<Derived>::TransformCompoundAssignOperator(
4505 CompoundAssignOperator *E) {
4506 return getDerived().TransformBinaryOperator(E);
4509 template<typename Derived>
4510 Sema::OwningExprResult
4511 TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) {
4512 OwningExprResult Cond = getDerived().TransformExpr(E->getCond());
4513 if (Cond.isInvalid())
4514 return SemaRef.ExprError();
4516 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS());
4517 if (LHS.isInvalid())
4518 return SemaRef.ExprError();
4520 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS());
4521 if (RHS.isInvalid())
4522 return SemaRef.ExprError();
4524 if (!getDerived().AlwaysRebuild() &&
4525 Cond.get() == E->getCond() &&
4526 LHS.get() == E->getLHS() &&
4527 RHS.get() == E->getRHS())
4528 return SemaRef.Owned(E->Retain());
4530 return getDerived().RebuildConditionalOperator(move(Cond),
4531 E->getQuestionLoc(),
4537 template<typename Derived>
4538 Sema::OwningExprResult
4539 TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) {
4540 // Implicit casts are eliminated during transformation, since they
4541 // will be recomputed by semantic analysis after transformation.
4542 return getDerived().TransformExpr(E->getSubExprAsWritten());
4545 template<typename Derived>
4546 Sema::OwningExprResult
4547 TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
4548 TypeSourceInfo *OldT;
4549 TypeSourceInfo *NewT;
4551 // FIXME: Source location isn't quite accurate.
4552 SourceLocation TypeStartLoc
4553 = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc());
4554 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName());
4556 OldT = E->getTypeInfoAsWritten();
4557 NewT = getDerived().TransformType(OldT);
4559 return SemaRef.ExprError();
4562 OwningExprResult SubExpr
4563 = getDerived().TransformExpr(E->getSubExprAsWritten());
4564 if (SubExpr.isInvalid())
4565 return SemaRef.ExprError();
4567 if (!getDerived().AlwaysRebuild() &&
4569 SubExpr.get() == E->getSubExpr())
4570 return SemaRef.Owned(E->Retain());
4572 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
4578 template<typename Derived>
4579 Sema::OwningExprResult
4580 TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) {
4581 TypeSourceInfo *OldT = E->getTypeSourceInfo();
4582 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
4584 return SemaRef.ExprError();
4586 OwningExprResult Init = getDerived().TransformExpr(E->getInitializer());
4587 if (Init.isInvalid())
4588 return SemaRef.ExprError();
4590 if (!getDerived().AlwaysRebuild() &&
4592 Init.get() == E->getInitializer())
4593 return SemaRef.Owned(E->Retain());
4595 // Note: the expression type doesn't necessarily match the
4596 // type-as-written, but that's okay, because it should always be
4597 // derivable from the initializer.
4599 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT,
4600 /*FIXME:*/E->getInitializer()->getLocEnd(),
4604 template<typename Derived>
4605 Sema::OwningExprResult
4606 TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) {
4607 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
4608 if (Base.isInvalid())
4609 return SemaRef.ExprError();
4611 if (!getDerived().AlwaysRebuild() &&
4612 Base.get() == E->getBase())
4613 return SemaRef.Owned(E->Retain());
4615 // FIXME: Bad source location
4616 SourceLocation FakeOperatorLoc
4617 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd());
4618 return getDerived().RebuildExtVectorElementExpr(move(Base), FakeOperatorLoc,
4619 E->getAccessorLoc(),
4623 template<typename Derived>
4624 Sema::OwningExprResult
4625 TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) {
4626 bool InitChanged = false;
4628 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef);
4629 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) {
4630 OwningExprResult Init = getDerived().TransformExpr(E->getInit(I));
4631 if (Init.isInvalid())
4632 return SemaRef.ExprError();
4634 InitChanged = InitChanged || Init.get() != E->getInit(I);
4635 Inits.push_back(Init.takeAs<Expr>());
4638 if (!getDerived().AlwaysRebuild() && !InitChanged)
4639 return SemaRef.Owned(E->Retain());
4641 return getDerived().RebuildInitList(E->getLBraceLoc(), move_arg(Inits),
4642 E->getRBraceLoc(), E->getType());
4645 template<typename Derived>
4646 Sema::OwningExprResult
4647 TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) {
4650 // transform the initializer value
4651 OwningExprResult Init = getDerived().TransformExpr(E->getInit());
4652 if (Init.isInvalid())
4653 return SemaRef.ExprError();
4655 // transform the designators.
4656 ASTOwningVector<&ActionBase::DeleteExpr, 4> ArrayExprs(SemaRef);
4657 bool ExprChanged = false;
4658 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(),
4659 DEnd = E->designators_end();
4661 if (D->isFieldDesignator()) {
4662 Desig.AddDesignator(Designator::getField(D->getFieldName(),
4668 if (D->isArrayDesignator()) {
4669 OwningExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D));
4670 if (Index.isInvalid())
4671 return SemaRef.ExprError();
4673 Desig.AddDesignator(Designator::getArray(Index.get(),
4674 D->getLBracketLoc()));
4676 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D);
4677 ArrayExprs.push_back(Index.release());
4681 assert(D->isArrayRangeDesignator() && "New kind of designator?");
4682 OwningExprResult Start
4683 = getDerived().TransformExpr(E->getArrayRangeStart(*D));
4684 if (Start.isInvalid())
4685 return SemaRef.ExprError();
4687 OwningExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D));
4688 if (End.isInvalid())
4689 return SemaRef.ExprError();
4691 Desig.AddDesignator(Designator::getArrayRange(Start.get(),
4693 D->getLBracketLoc(),
4694 D->getEllipsisLoc()));
4696 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) ||
4697 End.get() != E->getArrayRangeEnd(*D);
4699 ArrayExprs.push_back(Start.release());
4700 ArrayExprs.push_back(End.release());
4703 if (!getDerived().AlwaysRebuild() &&
4704 Init.get() == E->getInit() &&
4706 return SemaRef.Owned(E->Retain());
4708 return getDerived().RebuildDesignatedInitExpr(Desig, move_arg(ArrayExprs),
4709 E->getEqualOrColonLoc(),
4710 E->usesGNUSyntax(), move(Init));
4713 template<typename Derived>
4714 Sema::OwningExprResult
4715 TreeTransform<Derived>::TransformImplicitValueInitExpr(
4716 ImplicitValueInitExpr *E) {
4717 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName());
4719 // FIXME: Will we ever have proper type location here? Will we actually
4720 // need to transform the type?
4721 QualType T = getDerived().TransformType(E->getType());
4723 return SemaRef.ExprError();
4725 if (!getDerived().AlwaysRebuild() &&
4727 return SemaRef.Owned(E->Retain());
4729 return getDerived().RebuildImplicitValueInitExpr(T);
4732 template<typename Derived>
4733 Sema::OwningExprResult
4734 TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) {
4735 // FIXME: Do we want the type as written?
4739 // FIXME: Source location isn't quite accurate.
4740 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName());
4741 T = getDerived().TransformType(E->getType());
4743 return SemaRef.ExprError();
4746 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
4747 if (SubExpr.isInvalid())
4748 return SemaRef.ExprError();
4750 if (!getDerived().AlwaysRebuild() &&
4751 T == E->getType() &&
4752 SubExpr.get() == E->getSubExpr())
4753 return SemaRef.Owned(E->Retain());
4755 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), move(SubExpr),
4756 T, E->getRParenLoc());
4759 template<typename Derived>
4760 Sema::OwningExprResult
4761 TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) {
4762 bool ArgumentChanged = false;
4763 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef);
4764 for (unsigned I = 0, N = E->getNumExprs(); I != N; ++I) {
4765 OwningExprResult Init = getDerived().TransformExpr(E->getExpr(I));
4766 if (Init.isInvalid())
4767 return SemaRef.ExprError();
4769 ArgumentChanged = ArgumentChanged || Init.get() != E->getExpr(I);
4770 Inits.push_back(Init.takeAs<Expr>());
4773 return getDerived().RebuildParenListExpr(E->getLParenLoc(),
4778 /// \brief Transform an address-of-label expression.
4780 /// By default, the transformation of an address-of-label expression always
4781 /// rebuilds the expression, so that the label identifier can be resolved to
4782 /// the corresponding label statement by semantic analysis.
4783 template<typename Derived>
4784 Sema::OwningExprResult
4785 TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) {
4786 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
4790 template<typename Derived>
4791 Sema::OwningExprResult
4792 TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) {
4793 OwningStmtResult SubStmt
4794 = getDerived().TransformCompoundStmt(E->getSubStmt(), true);
4795 if (SubStmt.isInvalid())
4796 return SemaRef.ExprError();
4798 if (!getDerived().AlwaysRebuild() &&
4799 SubStmt.get() == E->getSubStmt())
4800 return SemaRef.Owned(E->Retain());
4802 return getDerived().RebuildStmtExpr(E->getLParenLoc(),
4807 template<typename Derived>
4808 Sema::OwningExprResult
4809 TreeTransform<Derived>::TransformTypesCompatibleExpr(TypesCompatibleExpr *E) {
4812 // FIXME: Source location isn't quite accurate.
4813 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName());
4815 T1 = getDerived().TransformType(E->getArgType1());
4817 return SemaRef.ExprError();
4819 T2 = getDerived().TransformType(E->getArgType2());
4821 return SemaRef.ExprError();
4824 if (!getDerived().AlwaysRebuild() &&
4825 T1 == E->getArgType1() &&
4826 T2 == E->getArgType2())
4827 return SemaRef.Owned(E->Retain());
4829 return getDerived().RebuildTypesCompatibleExpr(E->getBuiltinLoc(),
4830 T1, T2, E->getRParenLoc());
4833 template<typename Derived>
4834 Sema::OwningExprResult
4835 TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) {
4836 OwningExprResult Cond = getDerived().TransformExpr(E->getCond());
4837 if (Cond.isInvalid())
4838 return SemaRef.ExprError();
4840 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS());
4841 if (LHS.isInvalid())
4842 return SemaRef.ExprError();
4844 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS());
4845 if (RHS.isInvalid())
4846 return SemaRef.ExprError();
4848 if (!getDerived().AlwaysRebuild() &&
4849 Cond.get() == E->getCond() &&
4850 LHS.get() == E->getLHS() &&
4851 RHS.get() == E->getRHS())
4852 return SemaRef.Owned(E->Retain());
4854 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(),
4855 move(Cond), move(LHS), move(RHS),
4859 template<typename Derived>
4860 Sema::OwningExprResult
4861 TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) {
4862 return SemaRef.Owned(E->Retain());
4865 template<typename Derived>
4866 Sema::OwningExprResult
4867 TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
4868 switch (E->getOperator()) {
4872 case OO_Array_Delete:
4873 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr");
4874 return SemaRef.ExprError();
4877 // This is a call to an object's operator().
4878 assert(E->getNumArgs() >= 1 && "Object call is missing arguments");
4880 // Transform the object itself.
4881 OwningExprResult Object = getDerived().TransformExpr(E->getArg(0));
4882 if (Object.isInvalid())
4883 return SemaRef.ExprError();
4885 // FIXME: Poor location information
4886 SourceLocation FakeLParenLoc
4887 = SemaRef.PP.getLocForEndOfToken(
4888 static_cast<Expr *>(Object.get())->getLocEnd());
4890 // Transform the call arguments.
4891 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
4892 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs;
4893 for (unsigned I = 1, N = E->getNumArgs(); I != N; ++I) {
4894 if (getDerived().DropCallArgument(E->getArg(I)))
4897 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I));
4898 if (Arg.isInvalid())
4899 return SemaRef.ExprError();
4901 // FIXME: Poor source location information.
4902 SourceLocation FakeCommaLoc
4903 = SemaRef.PP.getLocForEndOfToken(
4904 static_cast<Expr *>(Arg.get())->getLocEnd());
4905 FakeCommaLocs.push_back(FakeCommaLoc);
4906 Args.push_back(Arg.release());
4909 return getDerived().RebuildCallExpr(move(Object), FakeLParenLoc,
4911 FakeCommaLocs.data(),
4915 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4917 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
4918 #include "clang/Basic/OperatorKinds.def"
4923 case OO_Conditional:
4924 llvm_unreachable("conditional operator is not actually overloadable");
4925 return SemaRef.ExprError();
4928 case NUM_OVERLOADED_OPERATORS:
4929 llvm_unreachable("not an overloaded operator?");
4930 return SemaRef.ExprError();
4933 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee());
4934 if (Callee.isInvalid())
4935 return SemaRef.ExprError();
4937 OwningExprResult First = getDerived().TransformExpr(E->getArg(0));
4938 if (First.isInvalid())
4939 return SemaRef.ExprError();
4941 OwningExprResult Second(SemaRef);
4942 if (E->getNumArgs() == 2) {
4943 Second = getDerived().TransformExpr(E->getArg(1));
4944 if (Second.isInvalid())
4945 return SemaRef.ExprError();
4948 if (!getDerived().AlwaysRebuild() &&
4949 Callee.get() == E->getCallee() &&
4950 First.get() == E->getArg(0) &&
4951 (E->getNumArgs() != 2 || Second.get() == E->getArg(1)))
4952 return SemaRef.Owned(E->Retain());
4954 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(),
4955 E->getOperatorLoc(),
4961 template<typename Derived>
4962 Sema::OwningExprResult
4963 TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) {
4964 return getDerived().TransformCallExpr(E);
4967 template<typename Derived>
4968 Sema::OwningExprResult
4969 TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) {
4970 TypeSourceInfo *OldT;
4971 TypeSourceInfo *NewT;
4973 // FIXME: Source location isn't quite accurate.
4974 SourceLocation TypeStartLoc
4975 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc());
4976 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName());
4978 OldT = E->getTypeInfoAsWritten();
4979 NewT = getDerived().TransformType(OldT);
4981 return SemaRef.ExprError();
4984 OwningExprResult SubExpr
4985 = getDerived().TransformExpr(E->getSubExprAsWritten());
4986 if (SubExpr.isInvalid())
4987 return SemaRef.ExprError();
4989 if (!getDerived().AlwaysRebuild() &&
4991 SubExpr.get() == E->getSubExpr())
4992 return SemaRef.Owned(E->Retain());
4994 // FIXME: Poor source location information here.
4995 SourceLocation FakeLAngleLoc
4996 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc());
4997 SourceLocation FakeRAngleLoc = E->getSubExpr()->getSourceRange().getBegin();
4998 SourceLocation FakeRParenLoc
4999 = SemaRef.PP.getLocForEndOfToken(
5000 E->getSubExpr()->getSourceRange().getEnd());
5001 return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(),
5011 template<typename Derived>
5012 Sema::OwningExprResult
5013 TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) {
5014 return getDerived().TransformCXXNamedCastExpr(E);
5017 template<typename Derived>
5018 Sema::OwningExprResult
5019 TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
5020 return getDerived().TransformCXXNamedCastExpr(E);
5023 template<typename Derived>
5024 Sema::OwningExprResult
5025 TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
5026 CXXReinterpretCastExpr *E) {
5027 return getDerived().TransformCXXNamedCastExpr(E);
5030 template<typename Derived>
5031 Sema::OwningExprResult
5032 TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) {
5033 return getDerived().TransformCXXNamedCastExpr(E);
5036 template<typename Derived>
5037 Sema::OwningExprResult
5038 TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
5039 CXXFunctionalCastExpr *E) {
5040 TypeSourceInfo *OldT;
5041 TypeSourceInfo *NewT;
5043 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
5045 OldT = E->getTypeInfoAsWritten();
5046 NewT = getDerived().TransformType(OldT);
5048 return SemaRef.ExprError();
5051 OwningExprResult SubExpr
5052 = getDerived().TransformExpr(E->getSubExprAsWritten());
5053 if (SubExpr.isInvalid())
5054 return SemaRef.ExprError();
5056 if (!getDerived().AlwaysRebuild() &&
5058 SubExpr.get() == E->getSubExpr())
5059 return SemaRef.Owned(E->Retain());
5061 // FIXME: The end of the type's source range is wrong
5062 return getDerived().RebuildCXXFunctionalCastExpr(
5063 /*FIXME:*/SourceRange(E->getTypeBeginLoc()),
5065 /*FIXME:*/E->getSubExpr()->getLocStart(),
5070 template<typename Derived>
5071 Sema::OwningExprResult
5072 TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) {
5073 if (E->isTypeOperand()) {
5074 TypeSourceInfo *TInfo
5075 = getDerived().TransformType(E->getTypeOperandSourceInfo());
5077 return SemaRef.ExprError();
5079 if (!getDerived().AlwaysRebuild() &&
5080 TInfo == E->getTypeOperandSourceInfo())
5081 return SemaRef.Owned(E->Retain());
5083 return getDerived().RebuildCXXTypeidExpr(E->getType(),
5089 // We don't know whether the expression is potentially evaluated until
5090 // after we perform semantic analysis, so the expression is potentially
5091 // potentially evaluated.
5092 EnterExpressionEvaluationContext Unevaluated(SemaRef,
5093 Action::PotentiallyPotentiallyEvaluated);
5095 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
5096 if (SubExpr.isInvalid())
5097 return SemaRef.ExprError();
5099 if (!getDerived().AlwaysRebuild() &&
5100 SubExpr.get() == E->getExprOperand())
5101 return SemaRef.Owned(E->Retain());
5103 return getDerived().RebuildCXXTypeidExpr(E->getType(),
5109 template<typename Derived>
5110 Sema::OwningExprResult
5111 TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
5112 return SemaRef.Owned(E->Retain());
5115 template<typename Derived>
5116 Sema::OwningExprResult
5117 TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
5118 CXXNullPtrLiteralExpr *E) {
5119 return SemaRef.Owned(E->Retain());
5122 template<typename Derived>
5123 Sema::OwningExprResult
5124 TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) {
5125 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName());
5127 QualType T = getDerived().TransformType(E->getType());
5129 return SemaRef.ExprError();
5131 if (!getDerived().AlwaysRebuild() &&
5133 return SemaRef.Owned(E->Retain());
5135 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit());
5138 template<typename Derived>
5139 Sema::OwningExprResult
5140 TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) {
5141 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
5142 if (SubExpr.isInvalid())
5143 return SemaRef.ExprError();
5145 if (!getDerived().AlwaysRebuild() &&
5146 SubExpr.get() == E->getSubExpr())
5147 return SemaRef.Owned(E->Retain());
5149 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), move(SubExpr));
5152 template<typename Derived>
5153 Sema::OwningExprResult
5154 TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
5156 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(),
5159 return SemaRef.ExprError();
5161 if (!getDerived().AlwaysRebuild() &&
5162 Param == E->getParam())
5163 return SemaRef.Owned(E->Retain());
5165 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param);
5168 template<typename Derived>
5169 Sema::OwningExprResult
5170 TreeTransform<Derived>::TransformCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) {
5171 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
5173 QualType T = getDerived().TransformType(E->getType());
5175 return SemaRef.ExprError();
5177 if (!getDerived().AlwaysRebuild() &&
5179 return SemaRef.Owned(E->Retain());
5181 return getDerived().RebuildCXXZeroInitValueExpr(E->getTypeBeginLoc(),
5182 /*FIXME:*/E->getTypeBeginLoc(),
5187 template<typename Derived>
5188 Sema::OwningExprResult
5189 TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) {
5190 // Transform the type that we're allocating
5191 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName());
5192 QualType AllocType = getDerived().TransformType(E->getAllocatedType());
5193 if (AllocType.isNull())
5194 return SemaRef.ExprError();
5196 // Transform the size of the array we're allocating (if any).
5197 OwningExprResult ArraySize = getDerived().TransformExpr(E->getArraySize());
5198 if (ArraySize.isInvalid())
5199 return SemaRef.ExprError();
5201 // Transform the placement arguments (if any).
5202 bool ArgumentChanged = false;
5203 ASTOwningVector<&ActionBase::DeleteExpr> PlacementArgs(SemaRef);
5204 for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) {
5205 OwningExprResult Arg = getDerived().TransformExpr(E->getPlacementArg(I));
5206 if (Arg.isInvalid())
5207 return SemaRef.ExprError();
5209 ArgumentChanged = ArgumentChanged || Arg.get() != E->getPlacementArg(I);
5210 PlacementArgs.push_back(Arg.take());
5213 // transform the constructor arguments (if any).
5214 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(SemaRef);
5215 for (unsigned I = 0, N = E->getNumConstructorArgs(); I != N; ++I) {
5216 if (getDerived().DropCallArgument(E->getConstructorArg(I)))
5219 OwningExprResult Arg = getDerived().TransformExpr(E->getConstructorArg(I));
5220 if (Arg.isInvalid())
5221 return SemaRef.ExprError();
5223 ArgumentChanged = ArgumentChanged || Arg.get() != E->getConstructorArg(I);
5224 ConstructorArgs.push_back(Arg.take());
5227 // Transform constructor, new operator, and delete operator.
5228 CXXConstructorDecl *Constructor = 0;
5229 if (E->getConstructor()) {
5230 Constructor = cast_or_null<CXXConstructorDecl>(
5231 getDerived().TransformDecl(E->getLocStart(),
5232 E->getConstructor()));
5234 return SemaRef.ExprError();
5237 FunctionDecl *OperatorNew = 0;
5238 if (E->getOperatorNew()) {
5239 OperatorNew = cast_or_null<FunctionDecl>(
5240 getDerived().TransformDecl(E->getLocStart(),
5241 E->getOperatorNew()));
5243 return SemaRef.ExprError();
5246 FunctionDecl *OperatorDelete = 0;
5247 if (E->getOperatorDelete()) {
5248 OperatorDelete = cast_or_null<FunctionDecl>(
5249 getDerived().TransformDecl(E->getLocStart(),
5250 E->getOperatorDelete()));
5251 if (!OperatorDelete)
5252 return SemaRef.ExprError();
5255 if (!getDerived().AlwaysRebuild() &&
5256 AllocType == E->getAllocatedType() &&
5257 ArraySize.get() == E->getArraySize() &&
5258 Constructor == E->getConstructor() &&
5259 OperatorNew == E->getOperatorNew() &&
5260 OperatorDelete == E->getOperatorDelete() &&
5262 // Mark any declarations we need as referenced.
5263 // FIXME: instantiation-specific.
5265 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor);
5267 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorNew);
5269 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorDelete);
5270 return SemaRef.Owned(E->Retain());
5273 if (!ArraySize.get()) {
5274 // If no array size was specified, but the new expression was
5275 // instantiated with an array type (e.g., "new T" where T is
5276 // instantiated with "int[4]"), extract the outer bound from the
5277 // array type as our array size. We do this with constant and
5278 // dependently-sized array types.
5279 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType);
5282 } else if (const ConstantArrayType *ConsArrayT
5283 = dyn_cast<ConstantArrayType>(ArrayT)) {
5285 = SemaRef.Owned(new (SemaRef.Context) IntegerLiteral(
5286 ConsArrayT->getSize(),
5287 SemaRef.Context.getSizeType(),
5288 /*FIXME:*/E->getLocStart()));
5289 AllocType = ConsArrayT->getElementType();
5290 } else if (const DependentSizedArrayType *DepArrayT
5291 = dyn_cast<DependentSizedArrayType>(ArrayT)) {
5292 if (DepArrayT->getSizeExpr()) {
5293 ArraySize = SemaRef.Owned(DepArrayT->getSizeExpr()->Retain());
5294 AllocType = DepArrayT->getElementType();
5298 return getDerived().RebuildCXXNewExpr(E->getLocStart(),
5300 /*FIXME:*/E->getLocStart(),
5301 move_arg(PlacementArgs),
5302 /*FIXME:*/E->getLocStart(),
5305 /*FIXME:*/E->getLocStart(),
5306 /*FIXME:*/SourceRange(),
5308 /*FIXME:*/E->getLocStart(),
5309 move_arg(ConstructorArgs),
5313 template<typename Derived>
5314 Sema::OwningExprResult
5315 TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) {
5316 OwningExprResult Operand = getDerived().TransformExpr(E->getArgument());
5317 if (Operand.isInvalid())
5318 return SemaRef.ExprError();
5320 // Transform the delete operator, if known.
5321 FunctionDecl *OperatorDelete = 0;
5322 if (E->getOperatorDelete()) {
5323 OperatorDelete = cast_or_null<FunctionDecl>(
5324 getDerived().TransformDecl(E->getLocStart(),
5325 E->getOperatorDelete()));
5326 if (!OperatorDelete)
5327 return SemaRef.ExprError();
5330 if (!getDerived().AlwaysRebuild() &&
5331 Operand.get() == E->getArgument() &&
5332 OperatorDelete == E->getOperatorDelete()) {
5333 // Mark any declarations we need as referenced.
5334 // FIXME: instantiation-specific.
5336 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorDelete);
5337 return SemaRef.Owned(E->Retain());
5340 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(),
5341 E->isGlobalDelete(),
5346 template<typename Derived>
5347 Sema::OwningExprResult
5348 TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
5349 CXXPseudoDestructorExpr *E) {
5350 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
5351 if (Base.isInvalid())
5352 return SemaRef.ExprError();
5354 Sema::TypeTy *ObjectTypePtr = 0;
5355 bool MayBePseudoDestructor = false;
5356 Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base),
5357 E->getOperatorLoc(),
5358 E->isArrow()? tok::arrow : tok::period,
5360 MayBePseudoDestructor);
5361 if (Base.isInvalid())
5362 return SemaRef.ExprError();
5364 QualType ObjectType = QualType::getFromOpaquePtr(ObjectTypePtr);
5365 NestedNameSpecifier *Qualifier
5366 = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
5367 E->getQualifierRange(),
5369 if (E->getQualifier() && !Qualifier)
5370 return SemaRef.ExprError();
5372 PseudoDestructorTypeStorage Destroyed;
5373 if (E->getDestroyedTypeInfo()) {
5374 TypeSourceInfo *DestroyedTypeInfo
5375 = getDerived().TransformType(E->getDestroyedTypeInfo(), ObjectType);
5376 if (!DestroyedTypeInfo)
5377 return SemaRef.ExprError();
5378 Destroyed = DestroyedTypeInfo;
5379 } else if (ObjectType->isDependentType()) {
5380 // We aren't likely to be able to resolve the identifier down to a type
5381 // now anyway, so just retain the identifier.
5382 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(),
5383 E->getDestroyedTypeLoc());
5385 // Look for a destructor known with the given name.
5388 SS.setScopeRep(Qualifier);
5389 SS.setRange(E->getQualifierRange());
5392 Sema::TypeTy *T = SemaRef.getDestructorName(E->getTildeLoc(),
5393 *E->getDestroyedTypeIdentifier(),
5394 E->getDestroyedTypeLoc(),
5399 return SemaRef.ExprError();
5402 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T),
5403 E->getDestroyedTypeLoc());
5406 TypeSourceInfo *ScopeTypeInfo = 0;
5407 if (E->getScopeTypeInfo()) {
5408 ScopeTypeInfo = getDerived().TransformType(E->getScopeTypeInfo(),
5411 return SemaRef.ExprError();
5414 return getDerived().RebuildCXXPseudoDestructorExpr(move(Base),
5415 E->getOperatorLoc(),
5418 E->getQualifierRange(),
5420 E->getColonColonLoc(),
5425 template<typename Derived>
5426 Sema::OwningExprResult
5427 TreeTransform<Derived>::TransformUnresolvedLookupExpr(
5428 UnresolvedLookupExpr *Old) {
5429 TemporaryBase Rebase(*this, Old->getNameLoc(), DeclarationName());
5431 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(),
5432 Sema::LookupOrdinaryName);
5434 // Transform all the decls.
5435 for (UnresolvedLookupExpr::decls_iterator I = Old->decls_begin(),
5436 E = Old->decls_end(); I != E; ++I) {
5437 NamedDecl *InstD = static_cast<NamedDecl*>(
5438 getDerived().TransformDecl(Old->getNameLoc(),
5441 // Silently ignore these if a UsingShadowDecl instantiated to nothing.
5442 // This can happen because of dependent hiding.
5443 if (isa<UsingShadowDecl>(*I))
5446 return SemaRef.ExprError();
5449 // Expand using declarations.
5450 if (isa<UsingDecl>(InstD)) {
5451 UsingDecl *UD = cast<UsingDecl>(InstD);
5452 for (UsingDecl::shadow_iterator I = UD->shadow_begin(),
5453 E = UD->shadow_end(); I != E; ++I)
5461 // Resolve a kind, but don't do any further analysis. If it's
5462 // ambiguous, the callee needs to deal with it.
5465 // Rebuild the nested-name qualifier, if present.
5467 NestedNameSpecifier *Qualifier = 0;
5468 if (Old->getQualifier()) {
5469 Qualifier = getDerived().TransformNestedNameSpecifier(Old->getQualifier(),
5470 Old->getQualifierRange());
5472 return SemaRef.ExprError();
5474 SS.setScopeRep(Qualifier);
5475 SS.setRange(Old->getQualifierRange());
5478 if (Old->getNamingClass()) {
5479 CXXRecordDecl *NamingClass
5480 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
5482 Old->getNamingClass()));
5484 return SemaRef.ExprError();
5486 R.setNamingClass(NamingClass);
5489 // If we have no template arguments, it's a normal declaration name.
5490 if (!Old->hasExplicitTemplateArgs())
5491 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL());
5493 // If we have template arguments, rebuild them, then rebuild the
5494 // templateid expression.
5495 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc());
5496 for (unsigned I = 0, N = Old->getNumTemplateArgs(); I != N; ++I) {
5497 TemplateArgumentLoc Loc;
5498 if (getDerived().TransformTemplateArgument(Old->getTemplateArgs()[I], Loc))
5499 return SemaRef.ExprError();
5500 TransArgs.addArgument(Loc);
5503 return getDerived().RebuildTemplateIdExpr(SS, R, Old->requiresADL(),
5507 template<typename Derived>
5508 Sema::OwningExprResult
5509 TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
5510 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName());
5512 QualType T = getDerived().TransformType(E->getQueriedType());
5514 return SemaRef.ExprError();
5516 if (!getDerived().AlwaysRebuild() &&
5517 T == E->getQueriedType())
5518 return SemaRef.Owned(E->Retain());
5520 // FIXME: Bad location information
5521 SourceLocation FakeLParenLoc
5522 = SemaRef.PP.getLocForEndOfToken(E->getLocStart());
5524 return getDerived().RebuildUnaryTypeTrait(E->getTrait(),
5526 /*FIXME:*/FakeLParenLoc,
5531 template<typename Derived>
5532 Sema::OwningExprResult
5533 TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
5534 DependentScopeDeclRefExpr *E) {
5535 NestedNameSpecifier *NNS
5536 = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
5537 E->getQualifierRange());
5539 return SemaRef.ExprError();
5541 DeclarationName Name
5542 = getDerived().TransformDeclarationName(E->getDeclName(), E->getLocation());
5544 return SemaRef.ExprError();
5546 if (!E->hasExplicitTemplateArgs()) {
5547 if (!getDerived().AlwaysRebuild() &&
5548 NNS == E->getQualifier() &&
5549 Name == E->getDeclName())
5550 return SemaRef.Owned(E->Retain());
5552 return getDerived().RebuildDependentScopeDeclRefExpr(NNS,
5553 E->getQualifierRange(),
5554 Name, E->getLocation(),
5555 /*TemplateArgs*/ 0);
5558 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
5559 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
5560 TemplateArgumentLoc Loc;
5561 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc))
5562 return SemaRef.ExprError();
5563 TransArgs.addArgument(Loc);
5566 return getDerived().RebuildDependentScopeDeclRefExpr(NNS,
5567 E->getQualifierRange(),
5568 Name, E->getLocation(),
5572 template<typename Derived>
5573 Sema::OwningExprResult
5574 TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) {
5575 // CXXConstructExprs are always implicit, so when we have a
5576 // 1-argument construction we just transform that argument.
5577 if (E->getNumArgs() == 1 ||
5578 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1))))
5579 return getDerived().TransformExpr(E->getArg(0));
5581 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName());
5583 QualType T = getDerived().TransformType(E->getType());
5585 return SemaRef.ExprError();
5587 CXXConstructorDecl *Constructor
5588 = cast_or_null<CXXConstructorDecl>(
5589 getDerived().TransformDecl(E->getLocStart(),
5590 E->getConstructor()));
5592 return SemaRef.ExprError();
5594 bool ArgumentChanged = false;
5595 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
5596 for (CXXConstructExpr::arg_iterator Arg = E->arg_begin(),
5597 ArgEnd = E->arg_end();
5598 Arg != ArgEnd; ++Arg) {
5599 if (getDerived().DropCallArgument(*Arg)) {
5600 ArgumentChanged = true;
5604 OwningExprResult TransArg = getDerived().TransformExpr(*Arg);
5605 if (TransArg.isInvalid())
5606 return SemaRef.ExprError();
5608 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg;
5609 Args.push_back(TransArg.takeAs<Expr>());
5612 if (!getDerived().AlwaysRebuild() &&
5613 T == E->getType() &&
5614 Constructor == E->getConstructor() &&
5616 // Mark the constructor as referenced.
5617 // FIXME: Instantiation-specific
5618 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor);
5619 return SemaRef.Owned(E->Retain());
5622 return getDerived().RebuildCXXConstructExpr(T, /*FIXME:*/E->getLocStart(),
5623 Constructor, E->isElidable(),
5627 /// \brief Transform a C++ temporary-binding expression.
5629 /// Since CXXBindTemporaryExpr nodes are implicitly generated, we just
5630 /// transform the subexpression and return that.
5631 template<typename Derived>
5632 Sema::OwningExprResult
5633 TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
5634 return getDerived().TransformExpr(E->getSubExpr());
5637 /// \brief Transform a C++ reference-binding expression.
5639 /// Since CXXBindReferenceExpr nodes are implicitly generated, we just
5640 /// transform the subexpression and return that.
5641 template<typename Derived>
5642 Sema::OwningExprResult
5643 TreeTransform<Derived>::TransformCXXBindReferenceExpr(CXXBindReferenceExpr *E) {
5644 return getDerived().TransformExpr(E->getSubExpr());
5647 /// \brief Transform a C++ expression that contains temporaries that should
5648 /// be destroyed after the expression is evaluated.
5650 /// Since CXXExprWithTemporaries nodes are implicitly generated, we
5651 /// just transform the subexpression and return that.
5652 template<typename Derived>
5653 Sema::OwningExprResult
5654 TreeTransform<Derived>::TransformCXXExprWithTemporaries(
5655 CXXExprWithTemporaries *E) {
5656 return getDerived().TransformExpr(E->getSubExpr());
5659 template<typename Derived>
5660 Sema::OwningExprResult
5661 TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
5662 CXXTemporaryObjectExpr *E) {
5663 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
5664 QualType T = getDerived().TransformType(E->getType());
5666 return SemaRef.ExprError();
5668 CXXConstructorDecl *Constructor
5669 = cast_or_null<CXXConstructorDecl>(
5670 getDerived().TransformDecl(E->getLocStart(),
5671 E->getConstructor()));
5673 return SemaRef.ExprError();
5675 bool ArgumentChanged = false;
5676 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
5677 Args.reserve(E->getNumArgs());
5678 for (CXXTemporaryObjectExpr::arg_iterator Arg = E->arg_begin(),
5679 ArgEnd = E->arg_end();
5680 Arg != ArgEnd; ++Arg) {
5681 if (getDerived().DropCallArgument(*Arg)) {
5682 ArgumentChanged = true;
5686 OwningExprResult TransArg = getDerived().TransformExpr(*Arg);
5687 if (TransArg.isInvalid())
5688 return SemaRef.ExprError();
5690 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg;
5691 Args.push_back((Expr *)TransArg.release());
5694 if (!getDerived().AlwaysRebuild() &&
5695 T == E->getType() &&
5696 Constructor == E->getConstructor() &&
5698 // FIXME: Instantiation-specific
5699 SemaRef.MarkDeclarationReferenced(E->getTypeBeginLoc(), Constructor);
5700 return SemaRef.MaybeBindToTemporary(E->Retain());
5703 // FIXME: Bogus location information
5704 SourceLocation CommaLoc;
5705 if (Args.size() > 1) {
5706 Expr *First = (Expr *)Args[0];
5708 = SemaRef.PP.getLocForEndOfToken(First->getSourceRange().getEnd());
5710 return getDerived().RebuildCXXTemporaryObjectExpr(E->getTypeBeginLoc(),
5712 /*FIXME:*/E->getTypeBeginLoc(),
5718 template<typename Derived>
5719 Sema::OwningExprResult
5720 TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
5721 CXXUnresolvedConstructExpr *E) {
5722 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
5723 QualType T = getDerived().TransformType(E->getTypeAsWritten());
5725 return SemaRef.ExprError();
5727 bool ArgumentChanged = false;
5728 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
5729 llvm::SmallVector<SourceLocation, 8> FakeCommaLocs;
5730 for (CXXUnresolvedConstructExpr::arg_iterator Arg = E->arg_begin(),
5731 ArgEnd = E->arg_end();
5732 Arg != ArgEnd; ++Arg) {
5733 OwningExprResult TransArg = getDerived().TransformExpr(*Arg);
5734 if (TransArg.isInvalid())
5735 return SemaRef.ExprError();
5737 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg;
5738 FakeCommaLocs.push_back(
5739 SemaRef.PP.getLocForEndOfToken((*Arg)->getLocEnd()));
5740 Args.push_back(TransArg.takeAs<Expr>());
5743 if (!getDerived().AlwaysRebuild() &&
5744 T == E->getTypeAsWritten() &&
5746 return SemaRef.Owned(E->Retain());
5748 // FIXME: we're faking the locations of the commas
5749 return getDerived().RebuildCXXUnresolvedConstructExpr(E->getTypeBeginLoc(),
5753 FakeCommaLocs.data(),
5757 template<typename Derived>
5758 Sema::OwningExprResult
5759 TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
5760 CXXDependentScopeMemberExpr *E) {
5761 // Transform the base of the expression.
5762 OwningExprResult Base(SemaRef, (Expr*) 0);
5765 QualType ObjectType;
5766 if (!E->isImplicitAccess()) {
5767 OldBase = E->getBase();
5768 Base = getDerived().TransformExpr(OldBase);
5769 if (Base.isInvalid())
5770 return SemaRef.ExprError();
5772 // Start the member reference and compute the object's type.
5773 Sema::TypeTy *ObjectTy = 0;
5774 bool MayBePseudoDestructor = false;
5775 Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base),
5776 E->getOperatorLoc(),
5777 E->isArrow()? tok::arrow : tok::period,
5779 MayBePseudoDestructor);
5780 if (Base.isInvalid())
5781 return SemaRef.ExprError();
5783 ObjectType = QualType::getFromOpaquePtr(ObjectTy);
5784 BaseType = ((Expr*) Base.get())->getType();
5787 BaseType = getDerived().TransformType(E->getBaseType());
5788 ObjectType = BaseType->getAs<PointerType>()->getPointeeType();
5791 // Transform the first part of the nested-name-specifier that qualifies
5793 NamedDecl *FirstQualifierInScope
5794 = getDerived().TransformFirstQualifierInScope(
5795 E->getFirstQualifierFoundInScope(),
5796 E->getQualifierRange().getBegin());
5798 NestedNameSpecifier *Qualifier = 0;
5799 if (E->getQualifier()) {
5800 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
5801 E->getQualifierRange(),
5803 FirstQualifierInScope);
5805 return SemaRef.ExprError();
5808 DeclarationName Name
5809 = getDerived().TransformDeclarationName(E->getMember(), E->getMemberLoc(),
5812 return SemaRef.ExprError();
5814 if (!E->hasExplicitTemplateArgs()) {
5815 // This is a reference to a member without an explicitly-specified
5816 // template argument list. Optimize for this common case.
5817 if (!getDerived().AlwaysRebuild() &&
5818 Base.get() == OldBase &&
5819 BaseType == E->getBaseType() &&
5820 Qualifier == E->getQualifier() &&
5821 Name == E->getMember() &&
5822 FirstQualifierInScope == E->getFirstQualifierFoundInScope())
5823 return SemaRef.Owned(E->Retain());
5825 return getDerived().RebuildCXXDependentScopeMemberExpr(move(Base),
5828 E->getOperatorLoc(),
5830 E->getQualifierRange(),
5831 FirstQualifierInScope,
5834 /*TemplateArgs*/ 0);
5837 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
5838 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
5839 TemplateArgumentLoc Loc;
5840 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc))
5841 return SemaRef.ExprError();
5842 TransArgs.addArgument(Loc);
5845 return getDerived().RebuildCXXDependentScopeMemberExpr(move(Base),
5848 E->getOperatorLoc(),
5850 E->getQualifierRange(),
5851 FirstQualifierInScope,
5857 template<typename Derived>
5858 Sema::OwningExprResult
5859 TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) {
5860 // Transform the base of the expression.
5861 OwningExprResult Base(SemaRef, (Expr*) 0);
5863 if (!Old->isImplicitAccess()) {
5864 Base = getDerived().TransformExpr(Old->getBase());
5865 if (Base.isInvalid())
5866 return SemaRef.ExprError();
5867 BaseType = ((Expr*) Base.get())->getType();
5869 BaseType = getDerived().TransformType(Old->getBaseType());
5872 NestedNameSpecifier *Qualifier = 0;
5873 if (Old->getQualifier()) {
5875 = getDerived().TransformNestedNameSpecifier(Old->getQualifier(),
5876 Old->getQualifierRange());
5878 return SemaRef.ExprError();
5881 LookupResult R(SemaRef, Old->getMemberName(), Old->getMemberLoc(),
5882 Sema::LookupOrdinaryName);
5884 // Transform all the decls.
5885 for (UnresolvedMemberExpr::decls_iterator I = Old->decls_begin(),
5886 E = Old->decls_end(); I != E; ++I) {
5887 NamedDecl *InstD = static_cast<NamedDecl*>(
5888 getDerived().TransformDecl(Old->getMemberLoc(),
5891 // Silently ignore these if a UsingShadowDecl instantiated to nothing.
5892 // This can happen because of dependent hiding.
5893 if (isa<UsingShadowDecl>(*I))
5896 return SemaRef.ExprError();
5899 // Expand using declarations.
5900 if (isa<UsingDecl>(InstD)) {
5901 UsingDecl *UD = cast<UsingDecl>(InstD);
5902 for (UsingDecl::shadow_iterator I = UD->shadow_begin(),
5903 E = UD->shadow_end(); I != E; ++I)
5913 // Determine the naming class.
5914 if (Old->getNamingClass()) {
5915 CXXRecordDecl *NamingClass
5916 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
5917 Old->getMemberLoc(),
5918 Old->getNamingClass()));
5920 return SemaRef.ExprError();
5922 R.setNamingClass(NamingClass);
5925 TemplateArgumentListInfo TransArgs;
5926 if (Old->hasExplicitTemplateArgs()) {
5927 TransArgs.setLAngleLoc(Old->getLAngleLoc());
5928 TransArgs.setRAngleLoc(Old->getRAngleLoc());
5929 for (unsigned I = 0, N = Old->getNumTemplateArgs(); I != N; ++I) {
5930 TemplateArgumentLoc Loc;
5931 if (getDerived().TransformTemplateArgument(Old->getTemplateArgs()[I],
5933 return SemaRef.ExprError();
5934 TransArgs.addArgument(Loc);
5938 // FIXME: to do this check properly, we will need to preserve the
5939 // first-qualifier-in-scope here, just in case we had a dependent
5940 // base (and therefore couldn't do the check) and a
5941 // nested-name-qualifier (and therefore could do the lookup).
5942 NamedDecl *FirstQualifierInScope = 0;
5944 return getDerived().RebuildUnresolvedMemberExpr(move(Base),
5946 Old->getOperatorLoc(),
5949 Old->getQualifierRange(),
5950 FirstQualifierInScope,
5952 (Old->hasExplicitTemplateArgs()
5956 template<typename Derived>
5957 Sema::OwningExprResult
5958 TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) {
5959 return SemaRef.Owned(E->Retain());
5962 template<typename Derived>
5963 Sema::OwningExprResult
5964 TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) {
5965 TypeSourceInfo *EncodedTypeInfo
5966 = getDerived().TransformType(E->getEncodedTypeSourceInfo());
5967 if (!EncodedTypeInfo)
5968 return SemaRef.ExprError();
5970 if (!getDerived().AlwaysRebuild() &&
5971 EncodedTypeInfo == E->getEncodedTypeSourceInfo())
5972 return SemaRef.Owned(E->Retain());
5974 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(),
5979 template<typename Derived>
5980 Sema::OwningExprResult
5981 TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) {
5982 // Transform arguments.
5983 bool ArgChanged = false;
5984 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
5985 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
5986 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I));
5987 if (Arg.isInvalid())
5988 return SemaRef.ExprError();
5990 ArgChanged = ArgChanged || Arg.get() != E->getArg(I);
5991 Args.push_back(Arg.takeAs<Expr>());
5994 if (E->getReceiverKind() == ObjCMessageExpr::Class) {
5995 // Class message: transform the receiver type.
5996 TypeSourceInfo *ReceiverTypeInfo
5997 = getDerived().TransformType(E->getClassReceiverTypeInfo());
5998 if (!ReceiverTypeInfo)
5999 return SemaRef.ExprError();
6001 // If nothing changed, just retain the existing message send.
6002 if (!getDerived().AlwaysRebuild() &&
6003 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged)
6004 return SemaRef.Owned(E->Retain());
6006 // Build a new class message send.
6007 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo,
6015 // Instance message: transform the receiver
6016 assert(E->getReceiverKind() == ObjCMessageExpr::Instance &&
6017 "Only class and instance messages may be instantiated");
6018 OwningExprResult Receiver
6019 = getDerived().TransformExpr(E->getInstanceReceiver());
6020 if (Receiver.isInvalid())
6021 return SemaRef.ExprError();
6023 // If nothing changed, just retain the existing message send.
6024 if (!getDerived().AlwaysRebuild() &&
6025 Receiver.get() == E->getInstanceReceiver() && !ArgChanged)
6026 return SemaRef.Owned(E->Retain());
6028 // Build a new instance message send.
6029 return getDerived().RebuildObjCMessageExpr(move(Receiver),
6037 template<typename Derived>
6038 Sema::OwningExprResult
6039 TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) {
6040 return SemaRef.Owned(E->Retain());
6043 template<typename Derived>
6044 Sema::OwningExprResult
6045 TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) {
6046 return SemaRef.Owned(E->Retain());
6049 template<typename Derived>
6050 Sema::OwningExprResult
6051 TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) {
6052 // Transform the base expression.
6053 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
6054 if (Base.isInvalid())
6055 return SemaRef.ExprError();
6057 // We don't need to transform the ivar; it will never change.
6059 // If nothing changed, just retain the existing expression.
6060 if (!getDerived().AlwaysRebuild() &&
6061 Base.get() == E->getBase())
6062 return SemaRef.Owned(E->Retain());
6064 return getDerived().RebuildObjCIvarRefExpr(move(Base), E->getDecl(),
6066 E->isArrow(), E->isFreeIvar());
6069 template<typename Derived>
6070 Sema::OwningExprResult
6071 TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
6072 // Transform the base expression.
6073 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
6074 if (Base.isInvalid())
6075 return SemaRef.ExprError();
6077 // We don't need to transform the property; it will never change.
6079 // If nothing changed, just retain the existing expression.
6080 if (!getDerived().AlwaysRebuild() &&
6081 Base.get() == E->getBase())
6082 return SemaRef.Owned(E->Retain());
6084 return getDerived().RebuildObjCPropertyRefExpr(move(Base), E->getProperty(),
6088 template<typename Derived>
6089 Sema::OwningExprResult
6090 TreeTransform<Derived>::TransformObjCImplicitSetterGetterRefExpr(
6091 ObjCImplicitSetterGetterRefExpr *E) {
6092 // If this implicit setter/getter refers to class methods, it cannot have any
6093 // dependent parts. Just retain the existing declaration.
6094 if (E->getInterfaceDecl())
6095 return SemaRef.Owned(E->Retain());
6097 // Transform the base expression.
6098 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
6099 if (Base.isInvalid())
6100 return SemaRef.ExprError();
6102 // We don't need to transform the getters/setters; they will never change.
6104 // If nothing changed, just retain the existing expression.
6105 if (!getDerived().AlwaysRebuild() &&
6106 Base.get() == E->getBase())
6107 return SemaRef.Owned(E->Retain());
6109 return getDerived().RebuildObjCImplicitSetterGetterRefExpr(
6110 E->getGetterMethod(),
6112 E->getSetterMethod(),
6118 template<typename Derived>
6119 Sema::OwningExprResult
6120 TreeTransform<Derived>::TransformObjCSuperExpr(ObjCSuperExpr *E) {
6121 // Can never occur in a dependent context.
6122 return SemaRef.Owned(E->Retain());
6125 template<typename Derived>
6126 Sema::OwningExprResult
6127 TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) {
6128 // Transform the base expression.
6129 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
6130 if (Base.isInvalid())
6131 return SemaRef.ExprError();
6133 // If nothing changed, just retain the existing expression.
6134 if (!getDerived().AlwaysRebuild() &&
6135 Base.get() == E->getBase())
6136 return SemaRef.Owned(E->Retain());
6138 return getDerived().RebuildObjCIsaExpr(move(Base), E->getIsaMemberLoc(),
6142 template<typename Derived>
6143 Sema::OwningExprResult
6144 TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) {
6145 bool ArgumentChanged = false;
6146 ASTOwningVector<&ActionBase::DeleteExpr> SubExprs(SemaRef);
6147 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) {
6148 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExpr(I));
6149 if (SubExpr.isInvalid())
6150 return SemaRef.ExprError();
6152 ArgumentChanged = ArgumentChanged || SubExpr.get() != E->getExpr(I);
6153 SubExprs.push_back(SubExpr.takeAs<Expr>());
6156 if (!getDerived().AlwaysRebuild() &&
6158 return SemaRef.Owned(E->Retain());
6160 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(),
6165 template<typename Derived>
6166 Sema::OwningExprResult
6167 TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) {
6168 // FIXME: Implement this!
6169 assert(false && "Cannot transform block expressions yet");
6170 return SemaRef.Owned(E->Retain());
6173 template<typename Derived>
6174 Sema::OwningExprResult
6175 TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E) {
6176 // FIXME: Implement this!
6177 assert(false && "Cannot transform block-related expressions yet");
6178 return SemaRef.Owned(E->Retain());
6181 //===----------------------------------------------------------------------===//
6182 // Type reconstruction
6183 //===----------------------------------------------------------------------===//
6185 template<typename Derived>
6186 QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType,
6187 SourceLocation Star) {
6188 return SemaRef.BuildPointerType(PointeeType, Qualifiers(), Star,
6189 getDerived().getBaseEntity());
6192 template<typename Derived>
6193 QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType,
6194 SourceLocation Star) {
6195 return SemaRef.BuildBlockPointerType(PointeeType, Qualifiers(), Star,
6196 getDerived().getBaseEntity());
6199 template<typename Derived>
6201 TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType,
6202 bool WrittenAsLValue,
6203 SourceLocation Sigil) {
6204 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, Qualifiers(),
6205 Sigil, getDerived().getBaseEntity());
6208 template<typename Derived>
6210 TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType,
6212 SourceLocation Sigil) {
6213 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Qualifiers(),
6214 Sigil, getDerived().getBaseEntity());
6217 template<typename Derived>
6219 TreeTransform<Derived>::RebuildArrayType(QualType ElementType,
6220 ArrayType::ArraySizeModifier SizeMod,
6221 const llvm::APInt *Size,
6223 unsigned IndexTypeQuals,
6224 SourceRange BracketsRange) {
6225 if (SizeExpr || !Size)
6226 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr,
6227 IndexTypeQuals, BracketsRange,
6228 getDerived().getBaseEntity());
6230 QualType Types[] = {
6231 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy,
6232 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy,
6233 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty
6235 const unsigned NumTypes = sizeof(Types) / sizeof(QualType);
6237 for (unsigned I = 0; I != NumTypes; ++I)
6238 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) {
6239 SizeType = Types[I];
6243 IntegerLiteral ArraySize(*Size, SizeType, /*FIXME*/BracketsRange.getBegin());
6244 return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize,
6245 IndexTypeQuals, BracketsRange,
6246 getDerived().getBaseEntity());
6249 template<typename Derived>
6251 TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType,
6252 ArrayType::ArraySizeModifier SizeMod,
6253 const llvm::APInt &Size,
6254 unsigned IndexTypeQuals,
6255 SourceRange BracketsRange) {
6256 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0,
6257 IndexTypeQuals, BracketsRange);
6260 template<typename Derived>
6262 TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType,
6263 ArrayType::ArraySizeModifier SizeMod,
6264 unsigned IndexTypeQuals,
6265 SourceRange BracketsRange) {
6266 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0,
6267 IndexTypeQuals, BracketsRange);
6270 template<typename Derived>
6272 TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType,
6273 ArrayType::ArraySizeModifier SizeMod,
6275 unsigned IndexTypeQuals,
6276 SourceRange BracketsRange) {
6277 return getDerived().RebuildArrayType(ElementType, SizeMod, 0,
6278 SizeExpr.takeAs<Expr>(),
6279 IndexTypeQuals, BracketsRange);
6282 template<typename Derived>
6284 TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType,
6285 ArrayType::ArraySizeModifier SizeMod,
6287 unsigned IndexTypeQuals,
6288 SourceRange BracketsRange) {
6289 return getDerived().RebuildArrayType(ElementType, SizeMod, 0,
6290 SizeExpr.takeAs<Expr>(),
6291 IndexTypeQuals, BracketsRange);
6294 template<typename Derived>
6295 QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType,
6296 unsigned NumElements,
6297 bool IsAltiVec, bool IsPixel) {
6298 // FIXME: semantic checking!
6299 return SemaRef.Context.getVectorType(ElementType, NumElements,
6300 IsAltiVec, IsPixel);
6303 template<typename Derived>
6304 QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType,
6305 unsigned NumElements,
6306 SourceLocation AttributeLoc) {
6307 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
6309 IntegerLiteral *VectorSize
6310 = new (SemaRef.Context) IntegerLiteral(numElements, SemaRef.Context.IntTy,
6312 return SemaRef.BuildExtVectorType(ElementType, SemaRef.Owned(VectorSize),
6316 template<typename Derived>
6318 TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType,
6320 SourceLocation AttributeLoc) {
6321 return SemaRef.BuildExtVectorType(ElementType, move(SizeExpr), AttributeLoc);
6324 template<typename Derived>
6325 QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T,
6326 QualType *ParamTypes,
6327 unsigned NumParamTypes,
6330 return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic,
6332 getDerived().getBaseLocation(),
6333 getDerived().getBaseEntity());
6336 template<typename Derived>
6337 QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) {
6338 return SemaRef.Context.getFunctionNoProtoType(T);
6341 template<typename Derived>
6342 QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(Decl *D) {
6343 assert(D && "no decl found");
6344 if (D->isInvalidDecl()) return QualType();
6346 // FIXME: Doesn't account for ObjCInterfaceDecl!
6348 if (isa<UsingDecl>(D)) {
6349 UsingDecl *Using = cast<UsingDecl>(D);
6350 assert(Using->isTypeName() &&
6351 "UnresolvedUsingTypenameDecl transformed to non-typename using");
6353 // A valid resolved using typename decl points to exactly one type decl.
6354 assert(++Using->shadow_begin() == Using->shadow_end());
6355 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl());
6358 assert(isa<UnresolvedUsingTypenameDecl>(D) &&
6359 "UnresolvedUsingTypenameDecl transformed to non-using decl");
6360 Ty = cast<UnresolvedUsingTypenameDecl>(D);
6363 return SemaRef.Context.getTypeDeclType(Ty);
6366 template<typename Derived>
6367 QualType TreeTransform<Derived>::RebuildTypeOfExprType(ExprArg E) {
6368 return SemaRef.BuildTypeofExprType(E.takeAs<Expr>());
6371 template<typename Derived>
6372 QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) {
6373 return SemaRef.Context.getTypeOfType(Underlying);
6376 template<typename Derived>
6377 QualType TreeTransform<Derived>::RebuildDecltypeType(ExprArg E) {
6378 return SemaRef.BuildDecltypeType(E.takeAs<Expr>());
6381 template<typename Derived>
6382 QualType TreeTransform<Derived>::RebuildTemplateSpecializationType(
6383 TemplateName Template,
6384 SourceLocation TemplateNameLoc,
6385 const TemplateArgumentListInfo &TemplateArgs) {
6386 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
6389 template<typename Derived>
6390 NestedNameSpecifier *
6391 TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
6394 QualType ObjectType,
6395 NamedDecl *FirstQualifierInScope) {
6397 // FIXME: The source location information is all wrong.
6399 SS.setScopeRep(Prefix);
6400 return static_cast<NestedNameSpecifier *>(
6401 SemaRef.BuildCXXNestedNameSpecifier(0, SS, Range.getEnd(),
6404 FirstQualifierInScope,
6408 template<typename Derived>
6409 NestedNameSpecifier *
6410 TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
6412 NamespaceDecl *NS) {
6413 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, NS);
6416 template<typename Derived>
6417 NestedNameSpecifier *
6418 TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
6422 if (T->isDependentType() || T->isRecordType() ||
6423 (SemaRef.getLangOptions().CPlusPlus0x && T->isEnumeralType())) {
6424 assert(!T.hasLocalQualifiers() && "Can't get cv-qualifiers here");
6425 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, TemplateKW,
6429 SemaRef.Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T;
6433 template<typename Derived>
6435 TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier,
6437 TemplateDecl *Template) {
6438 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW,
6442 template<typename Derived>
6444 TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier,
6445 const IdentifierInfo &II,
6446 QualType ObjectType) {
6448 SS.setRange(SourceRange(getDerived().getBaseLocation()));
6449 SS.setScopeRep(Qualifier);
6451 Name.setIdentifier(&II, /*FIXME:*/getDerived().getBaseLocation());
6452 return getSema().ActOnDependentTemplateName(
6453 /*FIXME:*/getDerived().getBaseLocation(),
6456 ObjectType.getAsOpaquePtr(),
6457 /*EnteringContext=*/false)
6458 .template getAsVal<TemplateName>();
6461 template<typename Derived>
6463 TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier,
6464 OverloadedOperatorKind Operator,
6465 QualType ObjectType) {
6467 SS.setRange(SourceRange(getDerived().getBaseLocation()));
6468 SS.setScopeRep(Qualifier);
6470 SourceLocation SymbolLocations[3]; // FIXME: Bogus location information.
6471 Name.setOperatorFunctionId(/*FIXME:*/getDerived().getBaseLocation(),
6472 Operator, SymbolLocations);
6473 return getSema().ActOnDependentTemplateName(
6474 /*FIXME:*/getDerived().getBaseLocation(),
6477 ObjectType.getAsOpaquePtr(),
6478 /*EnteringContext=*/false)
6479 .template getAsVal<TemplateName>();
6482 template<typename Derived>
6483 Sema::OwningExprResult
6484 TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
6485 SourceLocation OpLoc,
6489 Expr *FirstExpr = (Expr *)First.get();
6490 Expr *SecondExpr = (Expr *)Second.get();
6491 Expr *CalleeExpr = ((Expr *)Callee.get())->IgnoreParenCasts();
6492 bool isPostIncDec = SecondExpr && (Op == OO_PlusPlus || Op == OO_MinusMinus);
6494 // Determine whether this should be a builtin operation.
6495 if (Op == OO_Subscript) {
6496 if (!FirstExpr->getType()->isOverloadableType() &&
6497 !SecondExpr->getType()->isOverloadableType())
6498 return getSema().CreateBuiltinArraySubscriptExpr(move(First),
6499 CalleeExpr->getLocStart(),
6500 move(Second), OpLoc);
6501 } else if (Op == OO_Arrow) {
6502 // -> is never a builtin operation.
6503 return SemaRef.BuildOverloadedArrowExpr(0, move(First), OpLoc);
6504 } else if (SecondExpr == 0 || isPostIncDec) {
6505 if (!FirstExpr->getType()->isOverloadableType()) {
6506 // The argument is not of overloadable type, so try to create a
6507 // built-in unary operation.
6508 UnaryOperator::Opcode Opc
6509 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
6511 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, move(First));
6514 if (!FirstExpr->getType()->isOverloadableType() &&
6515 !SecondExpr->getType()->isOverloadableType()) {
6516 // Neither of the arguments is an overloadable type, so try to
6517 // create a built-in binary operation.
6518 BinaryOperator::Opcode Opc = BinaryOperator::getOverloadedOpcode(Op);
6519 OwningExprResult Result
6520 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, FirstExpr, SecondExpr);
6521 if (Result.isInvalid())
6522 return SemaRef.ExprError();
6526 return move(Result);
6530 // Compute the transformed set of functions (and function templates) to be
6531 // used during overload resolution.
6532 UnresolvedSet<16> Functions;
6534 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(CalleeExpr)) {
6535 assert(ULE->requiresADL());
6537 // FIXME: Do we have to check
6538 // IsAcceptableNonMemberOperatorCandidate for each of these?
6539 Functions.append(ULE->decls_begin(), ULE->decls_end());
6541 Functions.addDecl(cast<DeclRefExpr>(CalleeExpr)->getDecl());
6544 // Add any functions found via argument-dependent lookup.
6545 Expr *Args[2] = { FirstExpr, SecondExpr };
6546 unsigned NumArgs = 1 + (SecondExpr != 0);
6548 // Create the overloaded operator invocation for unary operators.
6549 if (NumArgs == 1 || isPostIncDec) {
6550 UnaryOperator::Opcode Opc
6551 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
6552 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(First));
6555 if (Op == OO_Subscript)
6556 return SemaRef.CreateOverloadedArraySubscriptExpr(CalleeExpr->getLocStart(),
6561 // Create the overloaded operator invocation for binary operators.
6562 BinaryOperator::Opcode Opc =
6563 BinaryOperator::getOverloadedOpcode(Op);
6564 OwningExprResult Result
6565 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]);
6566 if (Result.isInvalid())
6567 return SemaRef.ExprError();
6571 return move(Result);
6574 template<typename Derived>
6575 Sema::OwningExprResult
6576 TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(ExprArg Base,
6577 SourceLocation OperatorLoc,
6579 NestedNameSpecifier *Qualifier,
6580 SourceRange QualifierRange,
6581 TypeSourceInfo *ScopeType,
6582 SourceLocation CCLoc,
6583 SourceLocation TildeLoc,
6584 PseudoDestructorTypeStorage Destroyed) {
6587 SS.setRange(QualifierRange);
6588 SS.setScopeRep(Qualifier);
6591 Expr *BaseE = (Expr *)Base.get();
6592 QualType BaseType = BaseE->getType();
6593 if (BaseE->isTypeDependent() || Destroyed.getIdentifier() ||
6594 (!isArrow && !BaseType->getAs<RecordType>()) ||
6595 (isArrow && BaseType->getAs<PointerType>() &&
6596 !BaseType->getAs<PointerType>()->getPointeeType()
6597 ->template getAs<RecordType>())){
6598 // This pseudo-destructor expression is still a pseudo-destructor.
6599 return SemaRef.BuildPseudoDestructorExpr(move(Base), OperatorLoc,
6600 isArrow? tok::arrow : tok::period,
6601 SS, ScopeType, CCLoc, TildeLoc,
6606 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo();
6607 DeclarationName Name
6608 = SemaRef.Context.DeclarationNames.getCXXDestructorName(
6609 SemaRef.Context.getCanonicalType(DestroyedType->getType()));
6611 // FIXME: the ScopeType should be tacked onto SS.
6613 return getSema().BuildMemberReferenceExpr(move(Base), BaseType,
6614 OperatorLoc, isArrow,
6615 SS, /*FIXME: FirstQualifier*/ 0,
6616 Name, Destroyed.getLocation(),
6617 /*TemplateArgs*/ 0);
6620 } // end namespace clang
6622 #endif // LLVM_CLANG_SEMA_TREETRANSFORM_H