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_EXPR(Node, Parent)
348 #include "clang/AST/StmtNodes.def"
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 elaborated type.
496 QualType RebuildElaboratedType(QualType T, ElaboratedType::TagKind Tag) {
497 return SemaRef.Context.getElaboratedType(T, Tag);
500 /// \brief Build a new typeof(expr) type.
502 /// By default, performs semantic analysis when building the typeof type.
503 /// Subclasses may override this routine to provide different behavior.
504 QualType RebuildTypeOfExprType(ExprArg Underlying);
506 /// \brief Build a new typeof(type) type.
508 /// By default, builds a new TypeOfType with the given underlying type.
509 QualType RebuildTypeOfType(QualType Underlying);
511 /// \brief Build a new C++0x decltype type.
513 /// By default, performs semantic analysis when building the decltype type.
514 /// Subclasses may override this routine to provide different behavior.
515 QualType RebuildDecltypeType(ExprArg Underlying);
517 /// \brief Build a new template specialization type.
519 /// By default, performs semantic analysis when building the template
520 /// specialization type. Subclasses may override this routine to provide
521 /// different behavior.
522 QualType RebuildTemplateSpecializationType(TemplateName Template,
523 SourceLocation TemplateLoc,
524 const TemplateArgumentListInfo &Args);
526 /// \brief Build a new qualified name type.
528 /// By default, builds a new QualifiedNameType type from the
529 /// nested-name-specifier and the named type. Subclasses may override
530 /// this routine to provide different behavior.
531 QualType RebuildQualifiedNameType(NestedNameSpecifier *NNS, QualType Named) {
532 return SemaRef.Context.getQualifiedNameType(NNS, Named);
535 /// \brief Build a new typename type that refers to a template-id.
537 /// By default, builds a new DependentNameType type from the
538 /// nested-name-specifier
539 /// and the given type. Subclasses may override this routine to provide
540 /// different behavior.
541 QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword,
542 NestedNameSpecifier *NNS, QualType T) {
543 if (NNS->isDependent()) {
544 // If the name is still dependent, just build a new dependent name type.
547 if (!SemaRef.computeDeclContext(SS))
548 return SemaRef.Context.getDependentNameType(Keyword, NNS,
549 cast<TemplateSpecializationType>(T));
552 // FIXME: Handle elaborated-type-specifiers separately.
553 return SemaRef.Context.getQualifiedNameType(NNS, T);
556 /// \brief Build a new typename type that refers to an identifier.
558 /// By default, performs semantic analysis when building the typename type
559 /// (or qualified name type). Subclasses may override this routine to provide
560 /// different behavior.
561 QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword,
562 NestedNameSpecifier *NNS,
563 const IdentifierInfo *Id,
568 if (NNS->isDependent()) {
569 // If the name is still dependent, just build a new dependent name type.
570 if (!SemaRef.computeDeclContext(SS))
571 return SemaRef.Context.getDependentNameType(Keyword, NNS, Id);
574 TagDecl::TagKind Kind = TagDecl::TK_enum;
579 return SemaRef.CheckTypenameType(Keyword, NNS, *Id, SR);
581 case ETK_Class: Kind = TagDecl::TK_class; break;
582 case ETK_Struct: Kind = TagDecl::TK_struct; break;
583 case ETK_Union: Kind = TagDecl::TK_union; break;
584 case ETK_Enum: Kind = TagDecl::TK_enum; break;
587 // We had a dependent elaborated-type-specifier that as been transformed
588 // into a non-dependent elaborated-type-specifier. Find the tag we're
590 LookupResult Result(SemaRef, Id, SR.getEnd(), Sema::LookupTagName);
591 DeclContext *DC = SemaRef.computeDeclContext(SS, false);
596 SemaRef.LookupQualifiedName(Result, DC);
597 switch (Result.getResultKind()) {
598 case LookupResult::NotFound:
599 case LookupResult::NotFoundInCurrentInstantiation:
602 case LookupResult::Found:
603 Tag = Result.getAsSingle<TagDecl>();
606 case LookupResult::FoundOverloaded:
607 case LookupResult::FoundUnresolvedValue:
608 llvm_unreachable("Tag lookup cannot find non-tags");
611 case LookupResult::Ambiguous:
612 // Let the LookupResult structure handle ambiguities.
617 // FIXME: Would be nice to highlight just the source range.
618 SemaRef.Diag(SR.getEnd(), diag::err_not_tag_in_scope)
623 // FIXME: Terrible location information
624 if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind, SR.getEnd(), *Id)) {
625 SemaRef.Diag(SR.getBegin(), diag::err_use_with_wrong_tag) << Id;
626 SemaRef.Diag(Tag->getLocation(), diag::note_previous_use);
630 // Build the elaborated-type-specifier type.
631 QualType T = SemaRef.Context.getTypeDeclType(Tag);
632 T = SemaRef.Context.getQualifiedNameType(NNS, T);
633 return SemaRef.Context.getElaboratedType(T, Kind);
636 /// \brief Build a new nested-name-specifier given the prefix and an
637 /// identifier that names the next step in the nested-name-specifier.
639 /// By default, performs semantic analysis when building the new
640 /// nested-name-specifier. Subclasses may override this routine to provide
641 /// different behavior.
642 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
646 NamedDecl *FirstQualifierInScope);
648 /// \brief Build a new nested-name-specifier given the prefix and the
649 /// namespace named in the next step in the nested-name-specifier.
651 /// By default, performs semantic analysis when building the new
652 /// nested-name-specifier. Subclasses may override this routine to provide
653 /// different behavior.
654 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
658 /// \brief Build a new nested-name-specifier given the prefix and the
659 /// type named in the next step in the nested-name-specifier.
661 /// By default, performs semantic analysis when building the new
662 /// nested-name-specifier. Subclasses may override this routine to provide
663 /// different behavior.
664 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
669 /// \brief Build a new template name given a nested name specifier, a flag
670 /// indicating whether the "template" keyword was provided, and the template
671 /// that the template name refers to.
673 /// By default, builds the new template name directly. Subclasses may override
674 /// this routine to provide different behavior.
675 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier,
677 TemplateDecl *Template);
679 /// \brief Build a new template name given a nested name specifier and the
680 /// name that is referred to as a template.
682 /// By default, performs semantic analysis to determine whether the name can
683 /// be resolved to a specific template, then builds the appropriate kind of
684 /// template name. Subclasses may override this routine to provide different
686 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier,
687 const IdentifierInfo &II,
688 QualType ObjectType);
690 /// \brief Build a new template name given a nested name specifier and the
691 /// overloaded operator name that is referred to as a template.
693 /// By default, performs semantic analysis to determine whether the name can
694 /// be resolved to a specific template, then builds the appropriate kind of
695 /// template name. Subclasses may override this routine to provide different
697 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier,
698 OverloadedOperatorKind Operator,
699 QualType ObjectType);
701 /// \brief Build a new compound statement.
703 /// By default, performs semantic analysis to build the new statement.
704 /// Subclasses may override this routine to provide different behavior.
705 OwningStmtResult RebuildCompoundStmt(SourceLocation LBraceLoc,
706 MultiStmtArg Statements,
707 SourceLocation RBraceLoc,
709 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, move(Statements),
713 /// \brief Build a new case statement.
715 /// By default, performs semantic analysis to build the new statement.
716 /// Subclasses may override this routine to provide different behavior.
717 OwningStmtResult RebuildCaseStmt(SourceLocation CaseLoc,
719 SourceLocation EllipsisLoc,
721 SourceLocation ColonLoc) {
722 return getSema().ActOnCaseStmt(CaseLoc, move(LHS), EllipsisLoc, move(RHS),
726 /// \brief Attach the body to a new case statement.
728 /// By default, performs semantic analysis to build the new statement.
729 /// Subclasses may override this routine to provide different behavior.
730 OwningStmtResult RebuildCaseStmtBody(StmtArg S, StmtArg Body) {
731 getSema().ActOnCaseStmtBody(S.get(), move(Body));
735 /// \brief Build a new default statement.
737 /// By default, performs semantic analysis to build the new statement.
738 /// Subclasses may override this routine to provide different behavior.
739 OwningStmtResult RebuildDefaultStmt(SourceLocation DefaultLoc,
740 SourceLocation ColonLoc,
742 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, move(SubStmt),
746 /// \brief Build a new label statement.
748 /// By default, performs semantic analysis to build the new statement.
749 /// Subclasses may override this routine to provide different behavior.
750 OwningStmtResult RebuildLabelStmt(SourceLocation IdentLoc,
752 SourceLocation ColonLoc,
754 return SemaRef.ActOnLabelStmt(IdentLoc, Id, ColonLoc, move(SubStmt));
757 /// \brief Build a new "if" statement.
759 /// By default, performs semantic analysis to build the new statement.
760 /// Subclasses may override this routine to provide different behavior.
761 OwningStmtResult RebuildIfStmt(SourceLocation IfLoc, Sema::FullExprArg Cond,
762 VarDecl *CondVar, StmtArg Then,
763 SourceLocation ElseLoc, StmtArg Else) {
764 return getSema().ActOnIfStmt(IfLoc, Cond, DeclPtrTy::make(CondVar),
765 move(Then), ElseLoc, move(Else));
768 /// \brief Start building a new switch statement.
770 /// By default, performs semantic analysis to build the new statement.
771 /// Subclasses may override this routine to provide different behavior.
772 OwningStmtResult RebuildSwitchStmtStart(Sema::FullExprArg Cond,
774 return getSema().ActOnStartOfSwitchStmt(Cond, DeclPtrTy::make(CondVar));
777 /// \brief Attach the body to the switch statement.
779 /// By default, performs semantic analysis to build the new statement.
780 /// Subclasses may override this routine to provide different behavior.
781 OwningStmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc,
782 StmtArg Switch, StmtArg Body) {
783 return getSema().ActOnFinishSwitchStmt(SwitchLoc, move(Switch),
787 /// \brief Build a new while statement.
789 /// By default, performs semantic analysis to build the new statement.
790 /// Subclasses may override this routine to provide different behavior.
791 OwningStmtResult RebuildWhileStmt(SourceLocation WhileLoc,
792 Sema::FullExprArg Cond,
795 return getSema().ActOnWhileStmt(WhileLoc, Cond, DeclPtrTy::make(CondVar),
799 /// \brief Build a new do-while statement.
801 /// By default, performs semantic analysis to build the new statement.
802 /// Subclasses may override this routine to provide different behavior.
803 OwningStmtResult RebuildDoStmt(SourceLocation DoLoc, StmtArg Body,
804 SourceLocation WhileLoc,
805 SourceLocation LParenLoc,
807 SourceLocation RParenLoc) {
808 return getSema().ActOnDoStmt(DoLoc, move(Body), WhileLoc, LParenLoc,
809 move(Cond), RParenLoc);
812 /// \brief Build a new for statement.
814 /// By default, performs semantic analysis to build the new statement.
815 /// Subclasses may override this routine to provide different behavior.
816 OwningStmtResult RebuildForStmt(SourceLocation ForLoc,
817 SourceLocation LParenLoc,
818 StmtArg Init, Sema::FullExprArg Cond,
819 VarDecl *CondVar, Sema::FullExprArg Inc,
820 SourceLocation RParenLoc, StmtArg Body) {
821 return getSema().ActOnForStmt(ForLoc, LParenLoc, move(Init), Cond,
822 DeclPtrTy::make(CondVar),
823 Inc, RParenLoc, move(Body));
826 /// \brief Build a new goto statement.
828 /// By default, performs semantic analysis to build the new statement.
829 /// Subclasses may override this routine to provide different behavior.
830 OwningStmtResult RebuildGotoStmt(SourceLocation GotoLoc,
831 SourceLocation LabelLoc,
833 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label->getID());
836 /// \brief Build a new indirect goto statement.
838 /// By default, performs semantic analysis to build the new statement.
839 /// Subclasses may override this routine to provide different behavior.
840 OwningStmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc,
841 SourceLocation StarLoc,
843 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, move(Target));
846 /// \brief Build a new return statement.
848 /// By default, performs semantic analysis to build the new statement.
849 /// Subclasses may override this routine to provide different behavior.
850 OwningStmtResult RebuildReturnStmt(SourceLocation ReturnLoc,
853 return getSema().ActOnReturnStmt(ReturnLoc, move(Result));
856 /// \brief Build a new declaration statement.
858 /// By default, performs semantic analysis to build the new statement.
859 /// Subclasses may override this routine to provide different behavior.
860 OwningStmtResult RebuildDeclStmt(Decl **Decls, unsigned NumDecls,
861 SourceLocation StartLoc,
862 SourceLocation EndLoc) {
863 return getSema().Owned(
864 new (getSema().Context) DeclStmt(
865 DeclGroupRef::Create(getSema().Context,
870 /// \brief Build a new inline asm statement.
872 /// By default, performs semantic analysis to build the new statement.
873 /// Subclasses may override this routine to provide different behavior.
874 OwningStmtResult RebuildAsmStmt(SourceLocation AsmLoc,
879 IdentifierInfo **Names,
880 MultiExprArg Constraints,
883 MultiExprArg Clobbers,
884 SourceLocation RParenLoc,
886 return getSema().ActOnAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
887 NumInputs, Names, move(Constraints),
888 move(Exprs), move(AsmString), move(Clobbers),
892 /// \brief Build a new Objective-C @try statement.
894 /// By default, performs semantic analysis to build the new statement.
895 /// Subclasses may override this routine to provide different behavior.
896 OwningStmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc,
898 MultiStmtArg CatchStmts,
900 return getSema().ActOnObjCAtTryStmt(AtLoc, move(TryBody), move(CatchStmts),
904 /// \brief Rebuild an Objective-C exception declaration.
906 /// By default, performs semantic analysis to build the new declaration.
907 /// Subclasses may override this routine to provide different behavior.
908 VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
909 TypeSourceInfo *TInfo, QualType T) {
910 return getSema().BuildObjCExceptionDecl(TInfo, T,
911 ExceptionDecl->getIdentifier(),
912 ExceptionDecl->getLocation());
915 /// \brief Build a new Objective-C @catch statement.
917 /// By default, performs semantic analysis to build the new statement.
918 /// Subclasses may override this routine to provide different behavior.
919 OwningStmtResult RebuildObjCAtCatchStmt(SourceLocation AtLoc,
920 SourceLocation RParenLoc,
923 return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
924 Sema::DeclPtrTy::make(Var),
928 /// \brief Build a new Objective-C @finally statement.
930 /// By default, performs semantic analysis to build the new statement.
931 /// Subclasses may override this routine to provide different behavior.
932 OwningStmtResult RebuildObjCAtFinallyStmt(SourceLocation AtLoc,
934 return getSema().ActOnObjCAtFinallyStmt(AtLoc, move(Body));
937 /// \brief Build a new Objective-C @throw statement.
939 /// By default, performs semantic analysis to build the new statement.
940 /// Subclasses may override this routine to provide different behavior.
941 OwningStmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc,
943 return getSema().BuildObjCAtThrowStmt(AtLoc, move(Operand));
946 /// \brief Build a new Objective-C @synchronized statement.
948 /// By default, performs semantic analysis to build the new statement.
949 /// Subclasses may override this routine to provide different behavior.
950 OwningStmtResult RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc,
953 return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, move(Object),
957 /// \brief Build a new Objective-C fast enumeration statement.
959 /// By default, performs semantic analysis to build the new statement.
960 /// Subclasses may override this routine to provide different behavior.
961 OwningStmtResult RebuildObjCForCollectionStmt(SourceLocation ForLoc,
962 SourceLocation LParenLoc,
965 SourceLocation RParenLoc,
967 return getSema().ActOnObjCForCollectionStmt(ForLoc, LParenLoc,
974 /// \brief Build a new C++ exception declaration.
976 /// By default, performs semantic analysis to build the new decaration.
977 /// Subclasses may override this routine to provide different behavior.
978 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl, QualType T,
979 TypeSourceInfo *Declarator,
980 IdentifierInfo *Name,
982 SourceRange TypeRange) {
983 return getSema().BuildExceptionDeclaration(0, T, Declarator, Name, Loc,
987 /// \brief Build a new C++ catch statement.
989 /// By default, performs semantic analysis to build the new statement.
990 /// Subclasses may override this routine to provide different behavior.
991 OwningStmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc,
992 VarDecl *ExceptionDecl,
994 return getSema().Owned(
995 new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl,
996 Handler.takeAs<Stmt>()));
999 /// \brief Build a new C++ try statement.
1001 /// By default, performs semantic analysis to build the new statement.
1002 /// Subclasses may override this routine to provide different behavior.
1003 OwningStmtResult RebuildCXXTryStmt(SourceLocation TryLoc,
1005 MultiStmtArg Handlers) {
1006 return getSema().ActOnCXXTryBlock(TryLoc, move(TryBlock), move(Handlers));
1009 /// \brief Build a new expression that references a declaration.
1011 /// By default, performs semantic analysis to build the new expression.
1012 /// Subclasses may override this routine to provide different behavior.
1013 OwningExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS,
1016 return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
1020 /// \brief Build a new expression that references a declaration.
1022 /// By default, performs semantic analysis to build the new expression.
1023 /// Subclasses may override this routine to provide different behavior.
1024 OwningExprResult RebuildDeclRefExpr(NestedNameSpecifier *Qualifier,
1025 SourceRange QualifierRange,
1026 ValueDecl *VD, SourceLocation Loc,
1027 TemplateArgumentListInfo *TemplateArgs) {
1029 SS.setScopeRep(Qualifier);
1030 SS.setRange(QualifierRange);
1032 // FIXME: loses template args.
1034 return getSema().BuildDeclarationNameExpr(SS, Loc, VD);
1037 /// \brief Build a new expression in parentheses.
1039 /// By default, performs semantic analysis to build the new expression.
1040 /// Subclasses may override this routine to provide different behavior.
1041 OwningExprResult RebuildParenExpr(ExprArg SubExpr, SourceLocation LParen,
1042 SourceLocation RParen) {
1043 return getSema().ActOnParenExpr(LParen, RParen, move(SubExpr));
1046 /// \brief Build a new pseudo-destructor expression.
1048 /// By default, performs semantic analysis to build the new expression.
1049 /// Subclasses may override this routine to provide different behavior.
1050 OwningExprResult RebuildCXXPseudoDestructorExpr(ExprArg Base,
1051 SourceLocation OperatorLoc,
1053 NestedNameSpecifier *Qualifier,
1054 SourceRange QualifierRange,
1055 TypeSourceInfo *ScopeType,
1056 SourceLocation CCLoc,
1057 SourceLocation TildeLoc,
1058 PseudoDestructorTypeStorage Destroyed);
1060 /// \brief Build a new unary operator expression.
1062 /// By default, performs semantic analysis to build the new expression.
1063 /// Subclasses may override this routine to provide different behavior.
1064 OwningExprResult RebuildUnaryOperator(SourceLocation OpLoc,
1065 UnaryOperator::Opcode Opc,
1067 return getSema().BuildUnaryOp(/*Scope=*/0, OpLoc, Opc, move(SubExpr));
1070 /// \brief Build a new builtin offsetof expression.
1072 /// By default, performs semantic analysis to build the new expression.
1073 /// Subclasses may override this routine to provide different behavior.
1074 OwningExprResult RebuildOffsetOfExpr(SourceLocation OperatorLoc,
1075 TypeSourceInfo *Type,
1076 Action::OffsetOfComponent *Components,
1077 unsigned NumComponents,
1078 SourceLocation RParenLoc) {
1079 return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
1080 NumComponents, RParenLoc);
1083 /// \brief Build a new sizeof or alignof expression with a type argument.
1085 /// By default, performs semantic analysis to build the new expression.
1086 /// Subclasses may override this routine to provide different behavior.
1087 OwningExprResult RebuildSizeOfAlignOf(TypeSourceInfo *TInfo,
1088 SourceLocation OpLoc,
1089 bool isSizeOf, SourceRange R) {
1090 return getSema().CreateSizeOfAlignOfExpr(TInfo, OpLoc, isSizeOf, R);
1093 /// \brief Build a new sizeof or alignof expression with an expression
1096 /// By default, performs semantic analysis to build the new expression.
1097 /// Subclasses may override this routine to provide different behavior.
1098 OwningExprResult RebuildSizeOfAlignOf(ExprArg SubExpr, SourceLocation OpLoc,
1099 bool isSizeOf, SourceRange R) {
1100 OwningExprResult Result
1101 = getSema().CreateSizeOfAlignOfExpr((Expr *)SubExpr.get(),
1102 OpLoc, isSizeOf, R);
1103 if (Result.isInvalid())
1104 return getSema().ExprError();
1107 return move(Result);
1110 /// \brief Build a new array subscript expression.
1112 /// By default, performs semantic analysis to build the new expression.
1113 /// Subclasses may override this routine to provide different behavior.
1114 OwningExprResult RebuildArraySubscriptExpr(ExprArg LHS,
1115 SourceLocation LBracketLoc,
1117 SourceLocation RBracketLoc) {
1118 return getSema().ActOnArraySubscriptExpr(/*Scope=*/0, move(LHS),
1119 LBracketLoc, move(RHS),
1123 /// \brief Build a new call expression.
1125 /// By default, performs semantic analysis to build the new expression.
1126 /// Subclasses may override this routine to provide different behavior.
1127 OwningExprResult RebuildCallExpr(ExprArg Callee, SourceLocation LParenLoc,
1129 SourceLocation *CommaLocs,
1130 SourceLocation RParenLoc) {
1131 return getSema().ActOnCallExpr(/*Scope=*/0, move(Callee), LParenLoc,
1132 move(Args), CommaLocs, RParenLoc);
1135 /// \brief Build a new member access expression.
1137 /// By default, performs semantic analysis to build the new expression.
1138 /// Subclasses may override this routine to provide different behavior.
1139 OwningExprResult RebuildMemberExpr(ExprArg Base, SourceLocation OpLoc,
1141 NestedNameSpecifier *Qualifier,
1142 SourceRange QualifierRange,
1143 SourceLocation MemberLoc,
1145 NamedDecl *FoundDecl,
1146 const TemplateArgumentListInfo *ExplicitTemplateArgs,
1147 NamedDecl *FirstQualifierInScope) {
1148 if (!Member->getDeclName()) {
1149 // We have a reference to an unnamed field.
1150 assert(!Qualifier && "Can't have an unnamed field with a qualifier!");
1152 Expr *BaseExpr = Base.takeAs<Expr>();
1153 if (getSema().PerformObjectMemberConversion(BaseExpr, Qualifier,
1155 return getSema().ExprError();
1158 new (getSema().Context) MemberExpr(BaseExpr, isArrow,
1160 cast<FieldDecl>(Member)->getType());
1161 return getSema().Owned(ME);
1166 SS.setRange(QualifierRange);
1167 SS.setScopeRep(Qualifier);
1170 QualType BaseType = ((Expr*) Base.get())->getType();
1172 // FIXME: this involves duplicating earlier analysis in a lot of
1173 // cases; we should avoid this when possible.
1174 LookupResult R(getSema(), Member->getDeclName(), MemberLoc,
1175 Sema::LookupMemberName);
1176 R.addDecl(FoundDecl);
1179 return getSema().BuildMemberReferenceExpr(move(Base), BaseType,
1181 SS, FirstQualifierInScope,
1182 R, ExplicitTemplateArgs);
1185 /// \brief Build a new binary operator expression.
1187 /// By default, performs semantic analysis to build the new expression.
1188 /// Subclasses may override this routine to provide different behavior.
1189 OwningExprResult RebuildBinaryOperator(SourceLocation OpLoc,
1190 BinaryOperator::Opcode Opc,
1191 ExprArg LHS, ExprArg RHS) {
1192 return getSema().BuildBinOp(/*Scope=*/0, OpLoc, Opc,
1193 LHS.takeAs<Expr>(), RHS.takeAs<Expr>());
1196 /// \brief Build a new conditional operator expression.
1198 /// By default, performs semantic analysis to build the new expression.
1199 /// Subclasses may override this routine to provide different behavior.
1200 OwningExprResult RebuildConditionalOperator(ExprArg Cond,
1201 SourceLocation QuestionLoc,
1203 SourceLocation ColonLoc,
1205 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, move(Cond),
1206 move(LHS), move(RHS));
1209 /// \brief Build a new C-style cast expression.
1211 /// By default, performs semantic analysis to build the new expression.
1212 /// Subclasses may override this routine to provide different behavior.
1213 OwningExprResult RebuildCStyleCastExpr(SourceLocation LParenLoc,
1214 TypeSourceInfo *TInfo,
1215 SourceLocation RParenLoc,
1217 return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
1221 /// \brief Build a new compound literal expression.
1223 /// By default, performs semantic analysis to build the new expression.
1224 /// Subclasses may override this routine to provide different behavior.
1225 OwningExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc,
1226 TypeSourceInfo *TInfo,
1227 SourceLocation RParenLoc,
1229 return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
1233 /// \brief Build a new extended vector element access expression.
1235 /// By default, performs semantic analysis to build the new expression.
1236 /// Subclasses may override this routine to provide different behavior.
1237 OwningExprResult RebuildExtVectorElementExpr(ExprArg Base,
1238 SourceLocation OpLoc,
1239 SourceLocation AccessorLoc,
1240 IdentifierInfo &Accessor) {
1243 QualType BaseType = ((Expr*) Base.get())->getType();
1244 return getSema().BuildMemberReferenceExpr(move(Base), BaseType,
1245 OpLoc, /*IsArrow*/ false,
1246 SS, /*FirstQualifierInScope*/ 0,
1247 DeclarationName(&Accessor),
1249 /* TemplateArgs */ 0);
1252 /// \brief Build a new initializer list expression.
1254 /// By default, performs semantic analysis to build the new expression.
1255 /// Subclasses may override this routine to provide different behavior.
1256 OwningExprResult RebuildInitList(SourceLocation LBraceLoc,
1258 SourceLocation RBraceLoc,
1259 QualType ResultTy) {
1260 OwningExprResult Result
1261 = SemaRef.ActOnInitList(LBraceLoc, move(Inits), RBraceLoc);
1262 if (Result.isInvalid() || ResultTy->isDependentType())
1263 return move(Result);
1265 // Patch in the result type we were given, which may have been computed
1266 // when the initial InitListExpr was built.
1267 InitListExpr *ILE = cast<InitListExpr>((Expr *)Result.get());
1268 ILE->setType(ResultTy);
1269 return move(Result);
1272 /// \brief Build a new designated initializer expression.
1274 /// By default, performs semantic analysis to build the new expression.
1275 /// Subclasses may override this routine to provide different behavior.
1276 OwningExprResult RebuildDesignatedInitExpr(Designation &Desig,
1277 MultiExprArg ArrayExprs,
1278 SourceLocation EqualOrColonLoc,
1281 OwningExprResult Result
1282 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
1284 if (Result.isInvalid())
1285 return SemaRef.ExprError();
1287 ArrayExprs.release();
1288 return move(Result);
1291 /// \brief Build a new value-initialized expression.
1293 /// By default, builds the implicit value initialization without performing
1294 /// any semantic analysis. Subclasses may override this routine to provide
1295 /// different behavior.
1296 OwningExprResult RebuildImplicitValueInitExpr(QualType T) {
1297 return SemaRef.Owned(new (SemaRef.Context) ImplicitValueInitExpr(T));
1300 /// \brief Build a new \c va_arg expression.
1302 /// By default, performs semantic analysis to build the new expression.
1303 /// Subclasses may override this routine to provide different behavior.
1304 OwningExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc, ExprArg SubExpr,
1305 QualType T, SourceLocation RParenLoc) {
1306 return getSema().ActOnVAArg(BuiltinLoc, move(SubExpr), T.getAsOpaquePtr(),
1310 /// \brief Build a new expression list in parentheses.
1312 /// By default, performs semantic analysis to build the new expression.
1313 /// Subclasses may override this routine to provide different behavior.
1314 OwningExprResult RebuildParenListExpr(SourceLocation LParenLoc,
1315 MultiExprArg SubExprs,
1316 SourceLocation RParenLoc) {
1317 return getSema().ActOnParenOrParenListExpr(LParenLoc, RParenLoc,
1321 /// \brief Build a new address-of-label expression.
1323 /// By default, performs semantic analysis, using the name of the label
1324 /// rather than attempting to map the label statement itself.
1325 /// Subclasses may override this routine to provide different behavior.
1326 OwningExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc,
1327 SourceLocation LabelLoc,
1329 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label->getID());
1332 /// \brief Build a new GNU statement expression.
1334 /// By default, performs semantic analysis to build the new expression.
1335 /// Subclasses may override this routine to provide different behavior.
1336 OwningExprResult RebuildStmtExpr(SourceLocation LParenLoc,
1338 SourceLocation RParenLoc) {
1339 return getSema().ActOnStmtExpr(LParenLoc, move(SubStmt), RParenLoc);
1342 /// \brief Build a new __builtin_types_compatible_p expression.
1344 /// By default, performs semantic analysis to build the new expression.
1345 /// Subclasses may override this routine to provide different behavior.
1346 OwningExprResult RebuildTypesCompatibleExpr(SourceLocation BuiltinLoc,
1347 QualType T1, QualType T2,
1348 SourceLocation RParenLoc) {
1349 return getSema().ActOnTypesCompatibleExpr(BuiltinLoc,
1350 T1.getAsOpaquePtr(),
1351 T2.getAsOpaquePtr(),
1355 /// \brief Build a new __builtin_choose_expr expression.
1357 /// By default, performs semantic analysis to build the new expression.
1358 /// Subclasses may override this routine to provide different behavior.
1359 OwningExprResult RebuildChooseExpr(SourceLocation BuiltinLoc,
1360 ExprArg Cond, ExprArg LHS, ExprArg RHS,
1361 SourceLocation RParenLoc) {
1362 return SemaRef.ActOnChooseExpr(BuiltinLoc,
1363 move(Cond), move(LHS), move(RHS),
1367 /// \brief Build a new overloaded operator call expression.
1369 /// By default, performs semantic analysis to build the new expression.
1370 /// The semantic analysis provides the behavior of template instantiation,
1371 /// copying with transformations that turn what looks like an overloaded
1372 /// operator call into a use of a builtin operator, performing
1373 /// argument-dependent lookup, etc. Subclasses may override this routine to
1374 /// provide different behavior.
1375 OwningExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
1376 SourceLocation OpLoc,
1381 /// \brief Build a new C++ "named" cast expression, such as static_cast or
1382 /// reinterpret_cast.
1384 /// By default, this routine dispatches to one of the more-specific routines
1385 /// for a particular named case, e.g., RebuildCXXStaticCastExpr().
1386 /// Subclasses may override this routine to provide different behavior.
1387 OwningExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc,
1388 Stmt::StmtClass Class,
1389 SourceLocation LAngleLoc,
1390 TypeSourceInfo *TInfo,
1391 SourceLocation RAngleLoc,
1392 SourceLocation LParenLoc,
1394 SourceLocation RParenLoc) {
1396 case Stmt::CXXStaticCastExprClass:
1397 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
1398 RAngleLoc, LParenLoc,
1399 move(SubExpr), RParenLoc);
1401 case Stmt::CXXDynamicCastExprClass:
1402 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
1403 RAngleLoc, LParenLoc,
1404 move(SubExpr), RParenLoc);
1406 case Stmt::CXXReinterpretCastExprClass:
1407 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
1408 RAngleLoc, LParenLoc,
1412 case Stmt::CXXConstCastExprClass:
1413 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
1414 RAngleLoc, LParenLoc,
1415 move(SubExpr), RParenLoc);
1418 assert(false && "Invalid C++ named cast");
1422 return getSema().ExprError();
1425 /// \brief Build a new C++ static_cast expression.
1427 /// By default, performs semantic analysis to build the new expression.
1428 /// Subclasses may override this routine to provide different behavior.
1429 OwningExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc,
1430 SourceLocation LAngleLoc,
1431 TypeSourceInfo *TInfo,
1432 SourceLocation RAngleLoc,
1433 SourceLocation LParenLoc,
1435 SourceLocation RParenLoc) {
1436 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
1437 TInfo, move(SubExpr),
1438 SourceRange(LAngleLoc, RAngleLoc),
1439 SourceRange(LParenLoc, RParenLoc));
1442 /// \brief Build a new C++ dynamic_cast expression.
1444 /// By default, performs semantic analysis to build the new expression.
1445 /// Subclasses may override this routine to provide different behavior.
1446 OwningExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc,
1447 SourceLocation LAngleLoc,
1448 TypeSourceInfo *TInfo,
1449 SourceLocation RAngleLoc,
1450 SourceLocation LParenLoc,
1452 SourceLocation RParenLoc) {
1453 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
1454 TInfo, move(SubExpr),
1455 SourceRange(LAngleLoc, RAngleLoc),
1456 SourceRange(LParenLoc, RParenLoc));
1459 /// \brief Build a new C++ reinterpret_cast expression.
1461 /// By default, performs semantic analysis to build the new expression.
1462 /// Subclasses may override this routine to provide different behavior.
1463 OwningExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc,
1464 SourceLocation LAngleLoc,
1465 TypeSourceInfo *TInfo,
1466 SourceLocation RAngleLoc,
1467 SourceLocation LParenLoc,
1469 SourceLocation RParenLoc) {
1470 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
1471 TInfo, move(SubExpr),
1472 SourceRange(LAngleLoc, RAngleLoc),
1473 SourceRange(LParenLoc, RParenLoc));
1476 /// \brief Build a new C++ const_cast expression.
1478 /// By default, performs semantic analysis to build the new expression.
1479 /// Subclasses may override this routine to provide different behavior.
1480 OwningExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc,
1481 SourceLocation LAngleLoc,
1482 TypeSourceInfo *TInfo,
1483 SourceLocation RAngleLoc,
1484 SourceLocation LParenLoc,
1486 SourceLocation RParenLoc) {
1487 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
1488 TInfo, move(SubExpr),
1489 SourceRange(LAngleLoc, RAngleLoc),
1490 SourceRange(LParenLoc, RParenLoc));
1493 /// \brief Build a new C++ functional-style cast expression.
1495 /// By default, performs semantic analysis to build the new expression.
1496 /// Subclasses may override this routine to provide different behavior.
1497 OwningExprResult RebuildCXXFunctionalCastExpr(SourceRange TypeRange,
1498 TypeSourceInfo *TInfo,
1499 SourceLocation LParenLoc,
1501 SourceLocation RParenLoc) {
1502 void *Sub = SubExpr.takeAs<Expr>();
1503 return getSema().ActOnCXXTypeConstructExpr(TypeRange,
1504 TInfo->getType().getAsOpaquePtr(),
1506 Sema::MultiExprArg(getSema(), &Sub, 1),
1511 /// \brief Build a new C++ typeid(type) expression.
1513 /// By default, performs semantic analysis to build the new expression.
1514 /// Subclasses may override this routine to provide different behavior.
1515 OwningExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
1516 SourceLocation TypeidLoc,
1517 TypeSourceInfo *Operand,
1518 SourceLocation RParenLoc) {
1519 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
1523 /// \brief Build a new C++ typeid(expr) expression.
1525 /// By default, performs semantic analysis to build the new expression.
1526 /// Subclasses may override this routine to provide different behavior.
1527 OwningExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
1528 SourceLocation TypeidLoc,
1530 SourceLocation RParenLoc) {
1531 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, move(Operand),
1535 /// \brief Build a new C++ "this" expression.
1537 /// By default, builds a new "this" expression without performing any
1538 /// semantic analysis. Subclasses may override this routine to provide
1539 /// different behavior.
1540 OwningExprResult RebuildCXXThisExpr(SourceLocation ThisLoc,
1543 return getSema().Owned(
1544 new (getSema().Context) CXXThisExpr(ThisLoc, ThisType,
1548 /// \brief Build a new C++ throw expression.
1550 /// By default, performs semantic analysis to build the new expression.
1551 /// Subclasses may override this routine to provide different behavior.
1552 OwningExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, ExprArg Sub) {
1553 return getSema().ActOnCXXThrow(ThrowLoc, move(Sub));
1556 /// \brief Build a new C++ default-argument expression.
1558 /// By default, builds a new default-argument expression, which does not
1559 /// require any semantic analysis. Subclasses may override this routine to
1560 /// provide different behavior.
1561 OwningExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc,
1562 ParmVarDecl *Param) {
1563 return getSema().Owned(CXXDefaultArgExpr::Create(getSema().Context, Loc,
1567 /// \brief Build a new C++ zero-initialization expression.
1569 /// By default, performs semantic analysis to build the new expression.
1570 /// Subclasses may override this routine to provide different behavior.
1571 OwningExprResult RebuildCXXZeroInitValueExpr(SourceLocation TypeStartLoc,
1572 SourceLocation LParenLoc,
1574 SourceLocation RParenLoc) {
1575 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeStartLoc),
1576 T.getAsOpaquePtr(), LParenLoc,
1577 MultiExprArg(getSema(), 0, 0),
1581 /// \brief Build a new C++ "new" expression.
1583 /// By default, performs semantic analysis to build the new expression.
1584 /// Subclasses may override this routine to provide different behavior.
1585 OwningExprResult RebuildCXXNewExpr(SourceLocation StartLoc,
1587 SourceLocation PlacementLParen,
1588 MultiExprArg PlacementArgs,
1589 SourceLocation PlacementRParen,
1592 SourceLocation TypeLoc,
1593 SourceRange TypeRange,
1595 SourceLocation ConstructorLParen,
1596 MultiExprArg ConstructorArgs,
1597 SourceLocation ConstructorRParen) {
1598 return getSema().BuildCXXNew(StartLoc, UseGlobal,
1600 move(PlacementArgs),
1608 move(ConstructorArgs),
1612 /// \brief Build a new C++ "delete" expression.
1614 /// By default, performs semantic analysis to build the new expression.
1615 /// Subclasses may override this routine to provide different behavior.
1616 OwningExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc,
1617 bool IsGlobalDelete,
1620 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
1624 /// \brief Build a new unary type trait expression.
1626 /// By default, performs semantic analysis to build the new expression.
1627 /// Subclasses may override this routine to provide different behavior.
1628 OwningExprResult RebuildUnaryTypeTrait(UnaryTypeTrait Trait,
1629 SourceLocation StartLoc,
1630 SourceLocation LParenLoc,
1632 SourceLocation RParenLoc) {
1633 return getSema().ActOnUnaryTypeTrait(Trait, StartLoc, LParenLoc,
1634 T.getAsOpaquePtr(), RParenLoc);
1637 /// \brief Build a new (previously unresolved) declaration reference
1640 /// By default, performs semantic analysis to build the new expression.
1641 /// Subclasses may override this routine to provide different behavior.
1642 OwningExprResult RebuildDependentScopeDeclRefExpr(NestedNameSpecifier *NNS,
1643 SourceRange QualifierRange,
1644 DeclarationName Name,
1645 SourceLocation Location,
1646 const TemplateArgumentListInfo *TemplateArgs) {
1648 SS.setRange(QualifierRange);
1649 SS.setScopeRep(NNS);
1652 return getSema().BuildQualifiedTemplateIdExpr(SS, Name, Location,
1655 return getSema().BuildQualifiedDeclarationNameExpr(SS, Name, Location);
1658 /// \brief Build a new template-id expression.
1660 /// By default, performs semantic analysis to build the new expression.
1661 /// Subclasses may override this routine to provide different behavior.
1662 OwningExprResult RebuildTemplateIdExpr(const CXXScopeSpec &SS,
1665 const TemplateArgumentListInfo &TemplateArgs) {
1666 return getSema().BuildTemplateIdExpr(SS, R, RequiresADL, TemplateArgs);
1669 /// \brief Build a new object-construction expression.
1671 /// By default, performs semantic analysis to build the new expression.
1672 /// Subclasses may override this routine to provide different behavior.
1673 OwningExprResult RebuildCXXConstructExpr(QualType T,
1675 CXXConstructorDecl *Constructor,
1677 MultiExprArg Args) {
1678 ASTOwningVector<&ActionBase::DeleteExpr> ConvertedArgs(SemaRef);
1679 if (getSema().CompleteConstructorCall(Constructor, move(Args), Loc,
1681 return getSema().ExprError();
1683 return getSema().BuildCXXConstructExpr(Loc, T, Constructor, IsElidable,
1684 move_arg(ConvertedArgs));
1687 /// \brief Build a new object-construction expression.
1689 /// By default, performs semantic analysis to build the new expression.
1690 /// Subclasses may override this routine to provide different behavior.
1691 OwningExprResult RebuildCXXTemporaryObjectExpr(SourceLocation TypeBeginLoc,
1693 SourceLocation LParenLoc,
1695 SourceLocation *Commas,
1696 SourceLocation RParenLoc) {
1697 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeBeginLoc),
1705 /// \brief Build a new object-construction expression.
1707 /// By default, performs semantic analysis to build the new expression.
1708 /// Subclasses may override this routine to provide different behavior.
1709 OwningExprResult RebuildCXXUnresolvedConstructExpr(SourceLocation TypeBeginLoc,
1711 SourceLocation LParenLoc,
1713 SourceLocation *Commas,
1714 SourceLocation RParenLoc) {
1715 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeBeginLoc,
1716 /*FIXME*/LParenLoc),
1724 /// \brief Build a new member reference expression.
1726 /// By default, performs semantic analysis to build the new expression.
1727 /// Subclasses may override this routine to provide different behavior.
1728 OwningExprResult RebuildCXXDependentScopeMemberExpr(ExprArg BaseE,
1731 SourceLocation OperatorLoc,
1732 NestedNameSpecifier *Qualifier,
1733 SourceRange QualifierRange,
1734 NamedDecl *FirstQualifierInScope,
1735 DeclarationName Name,
1736 SourceLocation MemberLoc,
1737 const TemplateArgumentListInfo *TemplateArgs) {
1739 SS.setRange(QualifierRange);
1740 SS.setScopeRep(Qualifier);
1742 return SemaRef.BuildMemberReferenceExpr(move(BaseE), BaseType,
1743 OperatorLoc, IsArrow,
1744 SS, FirstQualifierInScope,
1745 Name, MemberLoc, TemplateArgs);
1748 /// \brief Build a new member reference expression.
1750 /// By default, performs semantic analysis to build the new expression.
1751 /// Subclasses may override this routine to provide different behavior.
1752 OwningExprResult RebuildUnresolvedMemberExpr(ExprArg BaseE,
1754 SourceLocation OperatorLoc,
1756 NestedNameSpecifier *Qualifier,
1757 SourceRange QualifierRange,
1758 NamedDecl *FirstQualifierInScope,
1760 const TemplateArgumentListInfo *TemplateArgs) {
1762 SS.setRange(QualifierRange);
1763 SS.setScopeRep(Qualifier);
1765 return SemaRef.BuildMemberReferenceExpr(move(BaseE), BaseType,
1766 OperatorLoc, IsArrow,
1767 SS, FirstQualifierInScope,
1771 /// \brief Build a new Objective-C @encode expression.
1773 /// By default, performs semantic analysis to build the new expression.
1774 /// Subclasses may override this routine to provide different behavior.
1775 OwningExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc,
1776 TypeSourceInfo *EncodeTypeInfo,
1777 SourceLocation RParenLoc) {
1778 return SemaRef.Owned(SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo,
1782 /// \brief Build a new Objective-C class message.
1783 OwningExprResult RebuildObjCMessageExpr(TypeSourceInfo *ReceiverTypeInfo,
1785 ObjCMethodDecl *Method,
1786 SourceLocation LBracLoc,
1788 SourceLocation RBracLoc) {
1789 return SemaRef.BuildClassMessage(ReceiverTypeInfo,
1790 ReceiverTypeInfo->getType(),
1791 /*SuperLoc=*/SourceLocation(),
1792 Sel, Method, LBracLoc, RBracLoc,
1796 /// \brief Build a new Objective-C instance message.
1797 OwningExprResult RebuildObjCMessageExpr(ExprArg Receiver,
1799 ObjCMethodDecl *Method,
1800 SourceLocation LBracLoc,
1802 SourceLocation RBracLoc) {
1803 QualType ReceiverType = static_cast<Expr *>(Receiver.get())->getType();
1804 return SemaRef.BuildInstanceMessage(move(Receiver),
1806 /*SuperLoc=*/SourceLocation(),
1807 Sel, Method, LBracLoc, RBracLoc,
1811 /// \brief Build a new Objective-C ivar reference expression.
1813 /// By default, performs semantic analysis to build the new expression.
1814 /// Subclasses may override this routine to provide different behavior.
1815 OwningExprResult RebuildObjCIvarRefExpr(ExprArg BaseArg, ObjCIvarDecl *Ivar,
1816 SourceLocation IvarLoc,
1817 bool IsArrow, bool IsFreeIvar) {
1818 // FIXME: We lose track of the IsFreeIvar bit.
1820 Expr *Base = BaseArg.takeAs<Expr>();
1821 LookupResult R(getSema(), Ivar->getDeclName(), IvarLoc,
1822 Sema::LookupMemberName);
1823 OwningExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow,
1826 if (Result.isInvalid())
1827 return getSema().ExprError();
1830 return move(Result);
1832 return getSema().BuildMemberReferenceExpr(getSema().Owned(Base),
1834 /*FIXME:*/IvarLoc, IsArrow, SS,
1835 /*FirstQualifierInScope=*/0,
1837 /*TemplateArgs=*/0);
1840 /// \brief Build a new Objective-C property reference expression.
1842 /// By default, performs semantic analysis to build the new expression.
1843 /// Subclasses may override this routine to provide different behavior.
1844 OwningExprResult RebuildObjCPropertyRefExpr(ExprArg BaseArg,
1845 ObjCPropertyDecl *Property,
1846 SourceLocation PropertyLoc) {
1848 Expr *Base = BaseArg.takeAs<Expr>();
1849 LookupResult R(getSema(), Property->getDeclName(), PropertyLoc,
1850 Sema::LookupMemberName);
1851 bool IsArrow = false;
1852 OwningExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow,
1853 /*FIME:*/PropertyLoc,
1855 if (Result.isInvalid())
1856 return getSema().ExprError();
1859 return move(Result);
1861 return getSema().BuildMemberReferenceExpr(getSema().Owned(Base),
1863 /*FIXME:*/PropertyLoc, IsArrow,
1865 /*FirstQualifierInScope=*/0,
1867 /*TemplateArgs=*/0);
1870 /// \brief Build a new Objective-C implicit setter/getter reference
1873 /// By default, performs semantic analysis to build the new expression.
1874 /// Subclasses may override this routine to provide different behavior.
1875 OwningExprResult RebuildObjCImplicitSetterGetterRefExpr(
1876 ObjCMethodDecl *Getter,
1878 ObjCMethodDecl *Setter,
1879 SourceLocation NameLoc,
1881 // Since these expressions can only be value-dependent, we do not need to
1882 // perform semantic analysis again.
1883 return getSema().Owned(
1884 new (getSema().Context) ObjCImplicitSetterGetterRefExpr(Getter, T,
1887 Base.takeAs<Expr>()));
1890 /// \brief Build a new Objective-C "isa" expression.
1892 /// By default, performs semantic analysis to build the new expression.
1893 /// Subclasses may override this routine to provide different behavior.
1894 OwningExprResult RebuildObjCIsaExpr(ExprArg BaseArg, SourceLocation IsaLoc,
1897 Expr *Base = BaseArg.takeAs<Expr>();
1898 LookupResult R(getSema(), &getSema().Context.Idents.get("isa"), IsaLoc,
1899 Sema::LookupMemberName);
1900 OwningExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow,
1903 if (Result.isInvalid())
1904 return getSema().ExprError();
1907 return move(Result);
1909 return getSema().BuildMemberReferenceExpr(getSema().Owned(Base),
1911 /*FIXME:*/IsaLoc, IsArrow, SS,
1912 /*FirstQualifierInScope=*/0,
1914 /*TemplateArgs=*/0);
1917 /// \brief Build a new shuffle vector expression.
1919 /// By default, performs semantic analysis to build the new expression.
1920 /// Subclasses may override this routine to provide different behavior.
1921 OwningExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc,
1922 MultiExprArg SubExprs,
1923 SourceLocation RParenLoc) {
1924 // Find the declaration for __builtin_shufflevector
1925 const IdentifierInfo &Name
1926 = SemaRef.Context.Idents.get("__builtin_shufflevector");
1927 TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl();
1928 DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name));
1929 assert(Lookup.first != Lookup.second && "No __builtin_shufflevector?");
1931 // Build a reference to the __builtin_shufflevector builtin
1932 FunctionDecl *Builtin = cast<FunctionDecl>(*Lookup.first);
1934 = new (SemaRef.Context) DeclRefExpr(Builtin, Builtin->getType(),
1936 SemaRef.UsualUnaryConversions(Callee);
1938 // Build the CallExpr
1939 unsigned NumSubExprs = SubExprs.size();
1940 Expr **Subs = (Expr **)SubExprs.release();
1941 CallExpr *TheCall = new (SemaRef.Context) CallExpr(SemaRef.Context, Callee,
1943 Builtin->getResultType(),
1945 OwningExprResult OwnedCall(SemaRef.Owned(TheCall));
1947 // Type-check the __builtin_shufflevector expression.
1948 OwningExprResult Result = SemaRef.SemaBuiltinShuffleVector(TheCall);
1949 if (Result.isInvalid())
1950 return SemaRef.ExprError();
1952 OwnedCall.release();
1953 return move(Result);
1957 template<typename Derived>
1958 Sema::OwningStmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) {
1960 return SemaRef.Owned(S);
1962 switch (S->getStmtClass()) {
1963 case Stmt::NoStmtClass: break;
1965 // Transform individual statement nodes
1966 #define STMT(Node, Parent) \
1967 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
1968 #define EXPR(Node, Parent)
1969 #include "clang/AST/StmtNodes.def"
1971 // Transform expressions by calling TransformExpr.
1972 #define STMT(Node, Parent)
1973 #define ABSTRACT_EXPR(Node, Parent)
1974 #define EXPR(Node, Parent) case Stmt::Node##Class:
1975 #include "clang/AST/StmtNodes.def"
1977 Sema::OwningExprResult E = getDerived().TransformExpr(cast<Expr>(S));
1979 return getSema().StmtError();
1981 return getSema().ActOnExprStmt(getSema().MakeFullExpr(E));
1985 return SemaRef.Owned(S->Retain());
1989 template<typename Derived>
1990 Sema::OwningExprResult TreeTransform<Derived>::TransformExpr(Expr *E) {
1992 return SemaRef.Owned(E);
1994 switch (E->getStmtClass()) {
1995 case Stmt::NoStmtClass: break;
1996 #define STMT(Node, Parent) case Stmt::Node##Class: break;
1997 #define ABSTRACT_EXPR(Node, Parent)
1998 #define EXPR(Node, Parent) \
1999 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
2000 #include "clang/AST/StmtNodes.def"
2003 return SemaRef.Owned(E->Retain());
2006 template<typename Derived>
2007 NestedNameSpecifier *
2008 TreeTransform<Derived>::TransformNestedNameSpecifier(NestedNameSpecifier *NNS,
2010 QualType ObjectType,
2011 NamedDecl *FirstQualifierInScope) {
2015 // Transform the prefix of this nested name specifier.
2016 NestedNameSpecifier *Prefix = NNS->getPrefix();
2018 Prefix = getDerived().TransformNestedNameSpecifier(Prefix, Range,
2020 FirstQualifierInScope);
2024 // Clear out the object type and the first qualifier in scope; they only
2025 // apply to the first element in the nested-name-specifier.
2026 ObjectType = QualType();
2027 FirstQualifierInScope = 0;
2030 switch (NNS->getKind()) {
2031 case NestedNameSpecifier::Identifier:
2032 assert((Prefix || !ObjectType.isNull()) &&
2033 "Identifier nested-name-specifier with no prefix or object type");
2034 if (!getDerived().AlwaysRebuild() && Prefix == NNS->getPrefix() &&
2035 ObjectType.isNull())
2038 return getDerived().RebuildNestedNameSpecifier(Prefix, Range,
2039 *NNS->getAsIdentifier(),
2041 FirstQualifierInScope);
2043 case NestedNameSpecifier::Namespace: {
2045 = cast_or_null<NamespaceDecl>(
2046 getDerived().TransformDecl(Range.getBegin(),
2047 NNS->getAsNamespace()));
2048 if (!getDerived().AlwaysRebuild() &&
2049 Prefix == NNS->getPrefix() &&
2050 NS == NNS->getAsNamespace())
2053 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, NS);
2056 case NestedNameSpecifier::Global:
2057 // There is no meaningful transformation that one could perform on the
2061 case NestedNameSpecifier::TypeSpecWithTemplate:
2062 case NestedNameSpecifier::TypeSpec: {
2063 TemporaryBase Rebase(*this, Range.getBegin(), DeclarationName());
2064 QualType T = getDerived().TransformType(QualType(NNS->getAsType(), 0),
2069 if (!getDerived().AlwaysRebuild() &&
2070 Prefix == NNS->getPrefix() &&
2071 T == QualType(NNS->getAsType(), 0))
2074 return getDerived().RebuildNestedNameSpecifier(Prefix, Range,
2075 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate,
2080 // Required to silence a GCC warning
2084 template<typename Derived>
2086 TreeTransform<Derived>::TransformDeclarationName(DeclarationName Name,
2088 QualType ObjectType) {
2092 switch (Name.getNameKind()) {
2093 case DeclarationName::Identifier:
2094 case DeclarationName::ObjCZeroArgSelector:
2095 case DeclarationName::ObjCOneArgSelector:
2096 case DeclarationName::ObjCMultiArgSelector:
2097 case DeclarationName::CXXOperatorName:
2098 case DeclarationName::CXXLiteralOperatorName:
2099 case DeclarationName::CXXUsingDirective:
2102 case DeclarationName::CXXConstructorName:
2103 case DeclarationName::CXXDestructorName:
2104 case DeclarationName::CXXConversionFunctionName: {
2105 TemporaryBase Rebase(*this, Loc, Name);
2106 QualType T = getDerived().TransformType(Name.getCXXNameType(),
2109 return DeclarationName();
2111 return SemaRef.Context.DeclarationNames.getCXXSpecialName(
2113 SemaRef.Context.getCanonicalType(T));
2117 return DeclarationName();
2120 template<typename Derived>
2122 TreeTransform<Derived>::TransformTemplateName(TemplateName Name,
2123 QualType ObjectType) {
2124 SourceLocation Loc = getDerived().getBaseLocation();
2126 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) {
2127 NestedNameSpecifier *NNS
2128 = getDerived().TransformNestedNameSpecifier(QTN->getQualifier(),
2129 /*FIXME:*/SourceRange(getDerived().getBaseLocation()),
2132 return TemplateName();
2134 if (TemplateDecl *Template = QTN->getTemplateDecl()) {
2135 TemplateDecl *TransTemplate
2136 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Loc, Template));
2138 return TemplateName();
2140 if (!getDerived().AlwaysRebuild() &&
2141 NNS == QTN->getQualifier() &&
2142 TransTemplate == Template)
2145 return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(),
2149 // These should be getting filtered out before they make it into the AST.
2150 assert(false && "overloaded template name survived to here");
2153 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) {
2154 NestedNameSpecifier *NNS
2155 = getDerived().TransformNestedNameSpecifier(DTN->getQualifier(),
2156 /*FIXME:*/SourceRange(getDerived().getBaseLocation()),
2158 if (!NNS && DTN->getQualifier())
2159 return TemplateName();
2161 if (!getDerived().AlwaysRebuild() &&
2162 NNS == DTN->getQualifier() &&
2163 ObjectType.isNull())
2166 if (DTN->isIdentifier())
2167 return getDerived().RebuildTemplateName(NNS, *DTN->getIdentifier(),
2170 return getDerived().RebuildTemplateName(NNS, DTN->getOperator(),
2174 if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
2175 TemplateDecl *TransTemplate
2176 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Loc, Template));
2178 return TemplateName();
2180 if (!getDerived().AlwaysRebuild() &&
2181 TransTemplate == Template)
2184 return TemplateName(TransTemplate);
2187 // These should be getting filtered out before they reach the AST.
2188 assert(false && "overloaded function decl survived to here");
2189 return TemplateName();
2192 template<typename Derived>
2193 void TreeTransform<Derived>::InventTemplateArgumentLoc(
2194 const TemplateArgument &Arg,
2195 TemplateArgumentLoc &Output) {
2196 SourceLocation Loc = getDerived().getBaseLocation();
2197 switch (Arg.getKind()) {
2198 case TemplateArgument::Null:
2199 llvm_unreachable("null template argument in TreeTransform");
2202 case TemplateArgument::Type:
2203 Output = TemplateArgumentLoc(Arg,
2204 SemaRef.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc));
2208 case TemplateArgument::Template:
2209 Output = TemplateArgumentLoc(Arg, SourceRange(), Loc);
2212 case TemplateArgument::Expression:
2213 Output = TemplateArgumentLoc(Arg, Arg.getAsExpr());
2216 case TemplateArgument::Declaration:
2217 case TemplateArgument::Integral:
2218 case TemplateArgument::Pack:
2219 Output = TemplateArgumentLoc(Arg, TemplateArgumentLocInfo());
2224 template<typename Derived>
2225 bool TreeTransform<Derived>::TransformTemplateArgument(
2226 const TemplateArgumentLoc &Input,
2227 TemplateArgumentLoc &Output) {
2228 const TemplateArgument &Arg = Input.getArgument();
2229 switch (Arg.getKind()) {
2230 case TemplateArgument::Null:
2231 case TemplateArgument::Integral:
2235 case TemplateArgument::Type: {
2236 TypeSourceInfo *DI = Input.getTypeSourceInfo();
2238 DI = InventTypeSourceInfo(Input.getArgument().getAsType());
2240 DI = getDerived().TransformType(DI);
2241 if (!DI) return true;
2243 Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
2247 case TemplateArgument::Declaration: {
2248 // FIXME: we should never have to transform one of these.
2249 DeclarationName Name;
2250 if (NamedDecl *ND = dyn_cast<NamedDecl>(Arg.getAsDecl()))
2251 Name = ND->getDeclName();
2252 TemporaryBase Rebase(*this, Input.getLocation(), Name);
2253 Decl *D = getDerived().TransformDecl(Input.getLocation(), Arg.getAsDecl());
2254 if (!D) return true;
2256 Expr *SourceExpr = Input.getSourceDeclExpression();
2258 EnterExpressionEvaluationContext Unevaluated(getSema(),
2259 Action::Unevaluated);
2260 Sema::OwningExprResult E = getDerived().TransformExpr(SourceExpr);
2264 SourceExpr = E.takeAs<Expr>();
2265 SourceExpr->Retain();
2269 Output = TemplateArgumentLoc(TemplateArgument(D), SourceExpr);
2273 case TemplateArgument::Template: {
2274 TemporaryBase Rebase(*this, Input.getLocation(), DeclarationName());
2275 TemplateName Template
2276 = getDerived().TransformTemplateName(Arg.getAsTemplate());
2277 if (Template.isNull())
2280 Output = TemplateArgumentLoc(TemplateArgument(Template),
2281 Input.getTemplateQualifierRange(),
2282 Input.getTemplateNameLoc());
2286 case TemplateArgument::Expression: {
2287 // Template argument expressions are not potentially evaluated.
2288 EnterExpressionEvaluationContext Unevaluated(getSema(),
2289 Action::Unevaluated);
2291 Expr *InputExpr = Input.getSourceExpression();
2292 if (!InputExpr) InputExpr = Input.getArgument().getAsExpr();
2294 Sema::OwningExprResult E
2295 = getDerived().TransformExpr(InputExpr);
2296 if (E.isInvalid()) return true;
2298 Expr *ETaken = E.takeAs<Expr>();
2300 Output = TemplateArgumentLoc(TemplateArgument(ETaken), ETaken);
2304 case TemplateArgument::Pack: {
2305 llvm::SmallVector<TemplateArgument, 4> TransformedArgs;
2306 TransformedArgs.reserve(Arg.pack_size());
2307 for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
2308 AEnd = Arg.pack_end();
2311 // FIXME: preserve source information here when we start
2312 // caring about parameter packs.
2314 TemplateArgumentLoc InputArg;
2315 TemplateArgumentLoc OutputArg;
2316 getDerived().InventTemplateArgumentLoc(*A, InputArg);
2317 if (getDerived().TransformTemplateArgument(InputArg, OutputArg))
2320 TransformedArgs.push_back(OutputArg.getArgument());
2322 TemplateArgument Result;
2323 Result.setArgumentPack(TransformedArgs.data(), TransformedArgs.size(),
2325 Output = TemplateArgumentLoc(Result, Input.getLocInfo());
2330 // Work around bogus GCC warning
2334 //===----------------------------------------------------------------------===//
2335 // Type transformation
2336 //===----------------------------------------------------------------------===//
2338 template<typename Derived>
2339 QualType TreeTransform<Derived>::TransformType(QualType T,
2340 QualType ObjectType) {
2341 if (getDerived().AlreadyTransformed(T))
2344 // Temporary workaround. All of these transformations should
2345 // eventually turn into transformations on TypeLocs.
2346 TypeSourceInfo *DI = getSema().Context.CreateTypeSourceInfo(T);
2347 DI->getTypeLoc().initialize(getDerived().getBaseLocation());
2349 TypeSourceInfo *NewDI = getDerived().TransformType(DI, ObjectType);
2354 return NewDI->getType();
2357 template<typename Derived>
2358 TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *DI,
2359 QualType ObjectType) {
2360 if (getDerived().AlreadyTransformed(DI->getType()))
2365 TypeLoc TL = DI->getTypeLoc();
2366 TLB.reserve(TL.getFullDataSize());
2368 QualType Result = getDerived().TransformType(TLB, TL, ObjectType);
2369 if (Result.isNull())
2372 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
2375 template<typename Derived>
2377 TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T,
2378 QualType ObjectType) {
2379 switch (T.getTypeLocClass()) {
2380 #define ABSTRACT_TYPELOC(CLASS, PARENT)
2381 #define TYPELOC(CLASS, PARENT) \
2382 case TypeLoc::CLASS: \
2383 return getDerived().Transform##CLASS##Type(TLB, cast<CLASS##TypeLoc>(T), \
2385 #include "clang/AST/TypeLocNodes.def"
2388 llvm_unreachable("unhandled type loc!");
2392 /// FIXME: By default, this routine adds type qualifiers only to types
2393 /// that can have qualifiers, and silently suppresses those qualifiers
2394 /// that are not permitted (e.g., qualifiers on reference or function
2395 /// types). This is the right thing for template instantiation, but
2396 /// probably not for other clients.
2397 template<typename Derived>
2399 TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB,
2401 QualType ObjectType) {
2402 Qualifiers Quals = T.getType().getLocalQualifiers();
2404 QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc(),
2406 if (Result.isNull())
2409 // Silently suppress qualifiers if the result type can't be qualified.
2410 // FIXME: this is the right thing for template instantiation, but
2411 // probably not for other clients.
2412 if (Result->isFunctionType() || Result->isReferenceType())
2415 Result = SemaRef.Context.getQualifiedType(Result, Quals);
2417 TLB.push<QualifiedTypeLoc>(Result);
2419 // No location information to preserve.
2424 template <class TyLoc> static inline
2425 QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) {
2426 TyLoc NewT = TLB.push<TyLoc>(T.getType());
2427 NewT.setNameLoc(T.getNameLoc());
2431 template<typename Derived>
2432 QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
2434 QualType ObjectType) {
2435 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType());
2436 NewT.setBuiltinLoc(T.getBuiltinLoc());
2437 if (T.needsExtraLocalData())
2438 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs();
2442 template<typename Derived>
2443 QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
2445 QualType ObjectType) {
2447 return TransformTypeSpecType(TLB, T);
2450 template<typename Derived>
2451 QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
2453 QualType ObjectType) {
2454 QualType PointeeType
2455 = getDerived().TransformType(TLB, TL.getPointeeLoc());
2456 if (PointeeType.isNull())
2459 QualType Result = TL.getType();
2460 if (PointeeType->isObjCInterfaceType()) {
2461 // A dependent pointer type 'T *' has is being transformed such
2462 // that an Objective-C class type is being replaced for 'T'. The
2463 // resulting pointer type is an ObjCObjectPointerType, not a
2465 const ObjCInterfaceType *IFace = PointeeType->getAs<ObjCInterfaceType>();
2466 Result = SemaRef.Context.getObjCObjectPointerType(PointeeType,
2467 const_cast<ObjCProtocolDecl **>(
2468 IFace->qual_begin()),
2469 IFace->getNumProtocols());
2471 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
2472 NewT.setStarLoc(TL.getSigilLoc());
2473 NewT.setHasProtocolsAsWritten(false);
2474 NewT.setLAngleLoc(SourceLocation());
2475 NewT.setRAngleLoc(SourceLocation());
2476 NewT.setHasBaseTypeAsWritten(true);
2480 if (getDerived().AlwaysRebuild() ||
2481 PointeeType != TL.getPointeeLoc().getType()) {
2482 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
2483 if (Result.isNull())
2487 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result);
2488 NewT.setSigilLoc(TL.getSigilLoc());
2492 template<typename Derived>
2494 TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
2495 BlockPointerTypeLoc TL,
2496 QualType ObjectType) {
2497 QualType PointeeType
2498 = getDerived().TransformType(TLB, TL.getPointeeLoc());
2499 if (PointeeType.isNull())
2502 QualType Result = TL.getType();
2503 if (getDerived().AlwaysRebuild() ||
2504 PointeeType != TL.getPointeeLoc().getType()) {
2505 Result = getDerived().RebuildBlockPointerType(PointeeType,
2507 if (Result.isNull())
2511 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result);
2512 NewT.setSigilLoc(TL.getSigilLoc());
2516 /// Transforms a reference type. Note that somewhat paradoxically we
2517 /// don't care whether the type itself is an l-value type or an r-value
2518 /// type; we only care if the type was *written* as an l-value type
2519 /// or an r-value type.
2520 template<typename Derived>
2522 TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB,
2523 ReferenceTypeLoc TL,
2524 QualType ObjectType) {
2525 const ReferenceType *T = TL.getTypePtr();
2527 // Note that this works with the pointee-as-written.
2528 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
2529 if (PointeeType.isNull())
2532 QualType Result = TL.getType();
2533 if (getDerived().AlwaysRebuild() ||
2534 PointeeType != T->getPointeeTypeAsWritten()) {
2535 Result = getDerived().RebuildReferenceType(PointeeType,
2536 T->isSpelledAsLValue(),
2538 if (Result.isNull())
2542 // r-value references can be rebuilt as l-value references.
2543 ReferenceTypeLoc NewTL;
2544 if (isa<LValueReferenceType>(Result))
2545 NewTL = TLB.push<LValueReferenceTypeLoc>(Result);
2547 NewTL = TLB.push<RValueReferenceTypeLoc>(Result);
2548 NewTL.setSigilLoc(TL.getSigilLoc());
2553 template<typename Derived>
2555 TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB,
2556 LValueReferenceTypeLoc TL,
2557 QualType ObjectType) {
2558 return TransformReferenceType(TLB, TL, ObjectType);
2561 template<typename Derived>
2563 TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
2564 RValueReferenceTypeLoc TL,
2565 QualType ObjectType) {
2566 return TransformReferenceType(TLB, TL, ObjectType);
2569 template<typename Derived>
2571 TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
2572 MemberPointerTypeLoc TL,
2573 QualType ObjectType) {
2574 MemberPointerType *T = TL.getTypePtr();
2576 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
2577 if (PointeeType.isNull())
2580 // TODO: preserve source information for this.
2582 = getDerived().TransformType(QualType(T->getClass(), 0));
2583 if (ClassType.isNull())
2586 QualType Result = TL.getType();
2587 if (getDerived().AlwaysRebuild() ||
2588 PointeeType != T->getPointeeType() ||
2589 ClassType != QualType(T->getClass(), 0)) {
2590 Result = getDerived().RebuildMemberPointerType(PointeeType, ClassType,
2592 if (Result.isNull())
2596 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
2597 NewTL.setSigilLoc(TL.getSigilLoc());
2602 template<typename Derived>
2604 TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
2605 ConstantArrayTypeLoc TL,
2606 QualType ObjectType) {
2607 ConstantArrayType *T = TL.getTypePtr();
2608 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
2609 if (ElementType.isNull())
2612 QualType Result = TL.getType();
2613 if (getDerived().AlwaysRebuild() ||
2614 ElementType != T->getElementType()) {
2615 Result = getDerived().RebuildConstantArrayType(ElementType,
2616 T->getSizeModifier(),
2618 T->getIndexTypeCVRQualifiers(),
2619 TL.getBracketsRange());
2620 if (Result.isNull())
2624 ConstantArrayTypeLoc NewTL = TLB.push<ConstantArrayTypeLoc>(Result);
2625 NewTL.setLBracketLoc(TL.getLBracketLoc());
2626 NewTL.setRBracketLoc(TL.getRBracketLoc());
2628 Expr *Size = TL.getSizeExpr();
2630 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2631 Size = getDerived().TransformExpr(Size).template takeAs<Expr>();
2633 NewTL.setSizeExpr(Size);
2638 template<typename Derived>
2639 QualType TreeTransform<Derived>::TransformIncompleteArrayType(
2640 TypeLocBuilder &TLB,
2641 IncompleteArrayTypeLoc TL,
2642 QualType ObjectType) {
2643 IncompleteArrayType *T = TL.getTypePtr();
2644 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
2645 if (ElementType.isNull())
2648 QualType Result = TL.getType();
2649 if (getDerived().AlwaysRebuild() ||
2650 ElementType != T->getElementType()) {
2651 Result = getDerived().RebuildIncompleteArrayType(ElementType,
2652 T->getSizeModifier(),
2653 T->getIndexTypeCVRQualifiers(),
2654 TL.getBracketsRange());
2655 if (Result.isNull())
2659 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
2660 NewTL.setLBracketLoc(TL.getLBracketLoc());
2661 NewTL.setRBracketLoc(TL.getRBracketLoc());
2662 NewTL.setSizeExpr(0);
2667 template<typename Derived>
2669 TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
2670 VariableArrayTypeLoc TL,
2671 QualType ObjectType) {
2672 VariableArrayType *T = TL.getTypePtr();
2673 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
2674 if (ElementType.isNull())
2677 // Array bounds are not potentially evaluated contexts
2678 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2680 Sema::OwningExprResult SizeResult
2681 = getDerived().TransformExpr(T->getSizeExpr());
2682 if (SizeResult.isInvalid())
2685 Expr *Size = static_cast<Expr*>(SizeResult.get());
2687 QualType Result = TL.getType();
2688 if (getDerived().AlwaysRebuild() ||
2689 ElementType != T->getElementType() ||
2690 Size != T->getSizeExpr()) {
2691 Result = getDerived().RebuildVariableArrayType(ElementType,
2692 T->getSizeModifier(),
2694 T->getIndexTypeCVRQualifiers(),
2695 TL.getBracketsRange());
2696 if (Result.isNull())
2699 else SizeResult.take();
2701 VariableArrayTypeLoc NewTL = TLB.push<VariableArrayTypeLoc>(Result);
2702 NewTL.setLBracketLoc(TL.getLBracketLoc());
2703 NewTL.setRBracketLoc(TL.getRBracketLoc());
2704 NewTL.setSizeExpr(Size);
2709 template<typename Derived>
2711 TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
2712 DependentSizedArrayTypeLoc TL,
2713 QualType ObjectType) {
2714 DependentSizedArrayType *T = TL.getTypePtr();
2715 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
2716 if (ElementType.isNull())
2719 // Array bounds are not potentially evaluated contexts
2720 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2722 Sema::OwningExprResult SizeResult
2723 = getDerived().TransformExpr(T->getSizeExpr());
2724 if (SizeResult.isInvalid())
2727 Expr *Size = static_cast<Expr*>(SizeResult.get());
2729 QualType Result = TL.getType();
2730 if (getDerived().AlwaysRebuild() ||
2731 ElementType != T->getElementType() ||
2732 Size != T->getSizeExpr()) {
2733 Result = getDerived().RebuildDependentSizedArrayType(ElementType,
2734 T->getSizeModifier(),
2736 T->getIndexTypeCVRQualifiers(),
2737 TL.getBracketsRange());
2738 if (Result.isNull())
2741 else SizeResult.take();
2743 // We might have any sort of array type now, but fortunately they
2744 // all have the same location layout.
2745 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
2746 NewTL.setLBracketLoc(TL.getLBracketLoc());
2747 NewTL.setRBracketLoc(TL.getRBracketLoc());
2748 NewTL.setSizeExpr(Size);
2753 template<typename Derived>
2754 QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
2755 TypeLocBuilder &TLB,
2756 DependentSizedExtVectorTypeLoc TL,
2757 QualType ObjectType) {
2758 DependentSizedExtVectorType *T = TL.getTypePtr();
2760 // FIXME: ext vector locs should be nested
2761 QualType ElementType = getDerived().TransformType(T->getElementType());
2762 if (ElementType.isNull())
2765 // Vector sizes are not potentially evaluated contexts
2766 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
2768 Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
2769 if (Size.isInvalid())
2772 QualType Result = TL.getType();
2773 if (getDerived().AlwaysRebuild() ||
2774 ElementType != T->getElementType() ||
2775 Size.get() != T->getSizeExpr()) {
2776 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
2778 T->getAttributeLoc());
2779 if (Result.isNull())
2784 // Result might be dependent or not.
2785 if (isa<DependentSizedExtVectorType>(Result)) {
2786 DependentSizedExtVectorTypeLoc NewTL
2787 = TLB.push<DependentSizedExtVectorTypeLoc>(Result);
2788 NewTL.setNameLoc(TL.getNameLoc());
2790 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
2791 NewTL.setNameLoc(TL.getNameLoc());
2797 template<typename Derived>
2798 QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
2800 QualType ObjectType) {
2801 VectorType *T = TL.getTypePtr();
2802 QualType ElementType = getDerived().TransformType(T->getElementType());
2803 if (ElementType.isNull())
2806 QualType Result = TL.getType();
2807 if (getDerived().AlwaysRebuild() ||
2808 ElementType != T->getElementType()) {
2809 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(),
2810 T->isAltiVec(), T->isPixel());
2811 if (Result.isNull())
2815 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
2816 NewTL.setNameLoc(TL.getNameLoc());
2821 template<typename Derived>
2822 QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
2823 ExtVectorTypeLoc TL,
2824 QualType ObjectType) {
2825 VectorType *T = TL.getTypePtr();
2826 QualType ElementType = getDerived().TransformType(T->getElementType());
2827 if (ElementType.isNull())
2830 QualType Result = TL.getType();
2831 if (getDerived().AlwaysRebuild() ||
2832 ElementType != T->getElementType()) {
2833 Result = getDerived().RebuildExtVectorType(ElementType,
2834 T->getNumElements(),
2835 /*FIXME*/ SourceLocation());
2836 if (Result.isNull())
2840 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
2841 NewTL.setNameLoc(TL.getNameLoc());
2846 template<typename Derived>
2848 TreeTransform<Derived>::TransformFunctionTypeParam(ParmVarDecl *OldParm) {
2849 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
2850 TypeSourceInfo *NewDI = getDerived().TransformType(OldDI);
2857 return ParmVarDecl::Create(SemaRef.Context,
2858 OldParm->getDeclContext(),
2859 OldParm->getLocation(),
2860 OldParm->getIdentifier(),
2863 OldParm->getStorageClass(),
2864 OldParm->getStorageClassAsWritten(),
2868 template<typename Derived>
2869 bool TreeTransform<Derived>::
2870 TransformFunctionTypeParams(FunctionProtoTypeLoc TL,
2871 llvm::SmallVectorImpl<QualType> &PTypes,
2872 llvm::SmallVectorImpl<ParmVarDecl*> &PVars) {
2873 FunctionProtoType *T = TL.getTypePtr();
2875 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
2876 ParmVarDecl *OldParm = TL.getArg(i);
2879 ParmVarDecl *NewParm;
2882 NewParm = getDerived().TransformFunctionTypeParam(OldParm);
2885 NewType = NewParm->getType();
2887 // Deal with the possibility that we don't have a parameter
2888 // declaration for this parameter.
2892 QualType OldType = T->getArgType(i);
2893 NewType = getDerived().TransformType(OldType);
2894 if (NewType.isNull())
2898 PTypes.push_back(NewType);
2899 PVars.push_back(NewParm);
2905 template<typename Derived>
2907 TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB,
2908 FunctionProtoTypeLoc TL,
2909 QualType ObjectType) {
2910 // Transform the parameters. We do this first for the benefit of template
2911 // instantiations, so that the ParmVarDecls get/ placed into the template
2912 // instantiation scope before we transform the function type.
2913 llvm::SmallVector<QualType, 4> ParamTypes;
2914 llvm::SmallVector<ParmVarDecl*, 4> ParamDecls;
2915 if (getDerived().TransformFunctionTypeParams(TL, ParamTypes, ParamDecls))
2918 FunctionProtoType *T = TL.getTypePtr();
2919 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc());
2920 if (ResultType.isNull())
2923 QualType Result = TL.getType();
2924 if (getDerived().AlwaysRebuild() ||
2925 ResultType != T->getResultType() ||
2926 !std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) {
2927 Result = getDerived().RebuildFunctionProtoType(ResultType,
2932 if (Result.isNull())
2936 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result);
2937 NewTL.setLParenLoc(TL.getLParenLoc());
2938 NewTL.setRParenLoc(TL.getRParenLoc());
2939 for (unsigned i = 0, e = NewTL.getNumArgs(); i != e; ++i)
2940 NewTL.setArg(i, ParamDecls[i]);
2945 template<typename Derived>
2946 QualType TreeTransform<Derived>::TransformFunctionNoProtoType(
2947 TypeLocBuilder &TLB,
2948 FunctionNoProtoTypeLoc TL,
2949 QualType ObjectType) {
2950 FunctionNoProtoType *T = TL.getTypePtr();
2951 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc());
2952 if (ResultType.isNull())
2955 QualType Result = TL.getType();
2956 if (getDerived().AlwaysRebuild() ||
2957 ResultType != T->getResultType())
2958 Result = getDerived().RebuildFunctionNoProtoType(ResultType);
2960 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result);
2961 NewTL.setLParenLoc(TL.getLParenLoc());
2962 NewTL.setRParenLoc(TL.getRParenLoc());
2967 template<typename Derived> QualType
2968 TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB,
2969 UnresolvedUsingTypeLoc TL,
2970 QualType ObjectType) {
2971 UnresolvedUsingType *T = TL.getTypePtr();
2972 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl());
2976 QualType Result = TL.getType();
2977 if (getDerived().AlwaysRebuild() || D != T->getDecl()) {
2978 Result = getDerived().RebuildUnresolvedUsingType(D);
2979 if (Result.isNull())
2983 // We might get an arbitrary type spec type back. We should at
2984 // least always get a type spec type, though.
2985 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result);
2986 NewTL.setNameLoc(TL.getNameLoc());
2991 template<typename Derived>
2992 QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
2994 QualType ObjectType) {
2995 TypedefType *T = TL.getTypePtr();
2996 TypedefDecl *Typedef
2997 = cast_or_null<TypedefDecl>(getDerived().TransformDecl(TL.getNameLoc(),
3002 QualType Result = TL.getType();
3003 if (getDerived().AlwaysRebuild() ||
3004 Typedef != T->getDecl()) {
3005 Result = getDerived().RebuildTypedefType(Typedef);
3006 if (Result.isNull())
3010 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result);
3011 NewTL.setNameLoc(TL.getNameLoc());
3016 template<typename Derived>
3017 QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
3018 TypeOfExprTypeLoc TL,
3019 QualType ObjectType) {
3020 // typeof expressions are not potentially evaluated contexts
3021 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
3023 Sema::OwningExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
3027 QualType Result = TL.getType();
3028 if (getDerived().AlwaysRebuild() ||
3029 E.get() != TL.getUnderlyingExpr()) {
3030 Result = getDerived().RebuildTypeOfExprType(move(E));
3031 if (Result.isNull())
3036 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result);
3037 NewTL.setTypeofLoc(TL.getTypeofLoc());
3038 NewTL.setLParenLoc(TL.getLParenLoc());
3039 NewTL.setRParenLoc(TL.getRParenLoc());
3044 template<typename Derived>
3045 QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
3047 QualType ObjectType) {
3048 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo();
3049 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);
3053 QualType Result = TL.getType();
3054 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {
3055 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType());
3056 if (Result.isNull())
3060 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result);
3061 NewTL.setTypeofLoc(TL.getTypeofLoc());
3062 NewTL.setLParenLoc(TL.getLParenLoc());
3063 NewTL.setRParenLoc(TL.getRParenLoc());
3064 NewTL.setUnderlyingTInfo(New_Under_TI);
3069 template<typename Derived>
3070 QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
3072 QualType ObjectType) {
3073 DecltypeType *T = TL.getTypePtr();
3075 // decltype expressions are not potentially evaluated contexts
3076 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
3078 Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
3082 QualType Result = TL.getType();
3083 if (getDerived().AlwaysRebuild() ||
3084 E.get() != T->getUnderlyingExpr()) {
3085 Result = getDerived().RebuildDecltypeType(move(E));
3086 if (Result.isNull())
3091 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
3092 NewTL.setNameLoc(TL.getNameLoc());
3097 template<typename Derived>
3098 QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,
3100 QualType ObjectType) {
3101 RecordType *T = TL.getTypePtr();
3103 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(),
3108 QualType Result = TL.getType();
3109 if (getDerived().AlwaysRebuild() ||
3110 Record != T->getDecl()) {
3111 Result = getDerived().RebuildRecordType(Record);
3112 if (Result.isNull())
3116 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
3117 NewTL.setNameLoc(TL.getNameLoc());
3122 template<typename Derived>
3123 QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
3125 QualType ObjectType) {
3126 EnumType *T = TL.getTypePtr();
3128 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(),
3133 QualType Result = TL.getType();
3134 if (getDerived().AlwaysRebuild() ||
3135 Enum != T->getDecl()) {
3136 Result = getDerived().RebuildEnumType(Enum);
3137 if (Result.isNull())
3141 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result);
3142 NewTL.setNameLoc(TL.getNameLoc());
3147 template <typename Derived>
3148 QualType TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB,
3149 ElaboratedTypeLoc TL,
3150 QualType ObjectType) {
3151 ElaboratedType *T = TL.getTypePtr();
3153 // FIXME: this should be a nested type.
3154 QualType Underlying = getDerived().TransformType(T->getUnderlyingType());
3155 if (Underlying.isNull())
3158 QualType Result = TL.getType();
3159 if (getDerived().AlwaysRebuild() ||
3160 Underlying != T->getUnderlyingType()) {
3161 Result = getDerived().RebuildElaboratedType(Underlying, T->getTagKind());
3162 if (Result.isNull())
3166 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
3167 NewTL.setNameLoc(TL.getNameLoc());
3172 template<typename Derived>
3173 QualType TreeTransform<Derived>::TransformInjectedClassNameType(
3174 TypeLocBuilder &TLB,
3175 InjectedClassNameTypeLoc TL,
3176 QualType ObjectType) {
3177 Decl *D = getDerived().TransformDecl(TL.getNameLoc(),
3178 TL.getTypePtr()->getDecl());
3179 if (!D) return QualType();
3181 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D));
3182 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc());
3187 template<typename Derived>
3188 QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
3189 TypeLocBuilder &TLB,
3190 TemplateTypeParmTypeLoc TL,
3191 QualType ObjectType) {
3192 return TransformTypeSpecType(TLB, TL);
3195 template<typename Derived>
3196 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
3197 TypeLocBuilder &TLB,
3198 SubstTemplateTypeParmTypeLoc TL,
3199 QualType ObjectType) {
3200 return TransformTypeSpecType(TLB, TL);
3203 template<typename Derived>
3204 QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
3205 const TemplateSpecializationType *TST,
3206 QualType ObjectType) {
3207 // FIXME: this entire method is a temporary workaround; callers
3208 // should be rewritten to provide real type locs.
3210 // Fake up a TemplateSpecializationTypeLoc.
3212 TemplateSpecializationTypeLoc TL
3213 = TLB.push<TemplateSpecializationTypeLoc>(QualType(TST, 0));
3215 SourceLocation BaseLoc = getDerived().getBaseLocation();
3217 TL.setTemplateNameLoc(BaseLoc);
3218 TL.setLAngleLoc(BaseLoc);
3219 TL.setRAngleLoc(BaseLoc);
3220 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
3221 const TemplateArgument &TA = TST->getArg(i);
3222 TemplateArgumentLoc TAL;
3223 getDerived().InventTemplateArgumentLoc(TA, TAL);
3224 TL.setArgLocInfo(i, TAL.getLocInfo());
3227 TypeLocBuilder IgnoredTLB;
3228 return TransformTemplateSpecializationType(IgnoredTLB, TL, ObjectType);
3231 template<typename Derived>
3232 QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
3233 TypeLocBuilder &TLB,
3234 TemplateSpecializationTypeLoc TL,
3235 QualType ObjectType) {
3236 const TemplateSpecializationType *T = TL.getTypePtr();
3238 TemplateName Template
3239 = getDerived().TransformTemplateName(T->getTemplateName(), ObjectType);
3240 if (Template.isNull())
3243 TemplateArgumentListInfo NewTemplateArgs;
3244 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
3245 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
3247 for (unsigned i = 0, e = T->getNumArgs(); i != e; ++i) {
3248 TemplateArgumentLoc Loc;
3249 if (getDerived().TransformTemplateArgument(TL.getArgLoc(i), Loc))
3251 NewTemplateArgs.addArgument(Loc);
3254 // FIXME: maybe don't rebuild if all the template arguments are the same.
3257 getDerived().RebuildTemplateSpecializationType(Template,
3258 TL.getTemplateNameLoc(),
3261 if (!Result.isNull()) {
3262 TemplateSpecializationTypeLoc NewTL
3263 = TLB.push<TemplateSpecializationTypeLoc>(Result);
3264 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
3265 NewTL.setLAngleLoc(TL.getLAngleLoc());
3266 NewTL.setRAngleLoc(TL.getRAngleLoc());
3267 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
3268 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
3274 template<typename Derived>
3276 TreeTransform<Derived>::TransformQualifiedNameType(TypeLocBuilder &TLB,
3277 QualifiedNameTypeLoc TL,
3278 QualType ObjectType) {
3279 QualifiedNameType *T = TL.getTypePtr();
3280 NestedNameSpecifier *NNS
3281 = getDerived().TransformNestedNameSpecifier(T->getQualifier(),
3287 QualType Named = getDerived().TransformType(T->getNamedType());
3291 QualType Result = TL.getType();
3292 if (getDerived().AlwaysRebuild() ||
3293 NNS != T->getQualifier() ||
3294 Named != T->getNamedType()) {
3295 Result = getDerived().RebuildQualifiedNameType(NNS, Named);
3296 if (Result.isNull())
3300 QualifiedNameTypeLoc NewTL = TLB.push<QualifiedNameTypeLoc>(Result);
3301 NewTL.setNameLoc(TL.getNameLoc());
3306 template<typename Derived>
3307 QualType TreeTransform<Derived>::TransformDependentNameType(TypeLocBuilder &TLB,
3308 DependentNameTypeLoc TL,
3309 QualType ObjectType) {
3310 DependentNameType *T = TL.getTypePtr();
3312 /* FIXME: preserve source information better than this */
3313 SourceRange SR(TL.getNameLoc());
3315 NestedNameSpecifier *NNS
3316 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), SR,
3323 if (const TemplateSpecializationType *TemplateId = T->getTemplateId()) {
3324 QualType NewTemplateId
3325 = getDerived().TransformType(QualType(TemplateId, 0));
3326 if (NewTemplateId.isNull())
3329 if (!getDerived().AlwaysRebuild() &&
3330 NNS == T->getQualifier() &&
3331 NewTemplateId == QualType(TemplateId, 0))
3332 return QualType(T, 0);
3334 Result = getDerived().RebuildDependentNameType(T->getKeyword(), NNS,
3337 Result = getDerived().RebuildDependentNameType(T->getKeyword(), NNS,
3338 T->getIdentifier(), SR);
3340 if (Result.isNull())
3343 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result);
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 return TL.getType();
3358 template<typename Derived>
3360 TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
3361 ObjCObjectPointerTypeLoc TL,
3362 QualType ObjectType) {
3363 // ObjCObjectPointerType is never dependent.
3364 return TL.getType();
3367 //===----------------------------------------------------------------------===//
3368 // Statement transformation
3369 //===----------------------------------------------------------------------===//
3370 template<typename Derived>
3371 Sema::OwningStmtResult
3372 TreeTransform<Derived>::TransformNullStmt(NullStmt *S) {
3373 return SemaRef.Owned(S->Retain());
3376 template<typename Derived>
3377 Sema::OwningStmtResult
3378 TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) {
3379 return getDerived().TransformCompoundStmt(S, false);
3382 template<typename Derived>
3383 Sema::OwningStmtResult
3384 TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S,
3386 bool SubStmtChanged = false;
3387 ASTOwningVector<&ActionBase::DeleteStmt> Statements(getSema());
3388 for (CompoundStmt::body_iterator B = S->body_begin(), BEnd = S->body_end();
3390 OwningStmtResult Result = getDerived().TransformStmt(*B);
3391 if (Result.isInvalid())
3392 return getSema().StmtError();
3394 SubStmtChanged = SubStmtChanged || Result.get() != *B;
3395 Statements.push_back(Result.takeAs<Stmt>());
3398 if (!getDerived().AlwaysRebuild() &&
3400 return SemaRef.Owned(S->Retain());
3402 return getDerived().RebuildCompoundStmt(S->getLBracLoc(),
3403 move_arg(Statements),
3408 template<typename Derived>
3409 Sema::OwningStmtResult
3410 TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
3411 OwningExprResult LHS(SemaRef), RHS(SemaRef);
3413 // The case value expressions are not potentially evaluated.
3414 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
3416 // Transform the left-hand case value.
3417 LHS = getDerived().TransformExpr(S->getLHS());
3418 if (LHS.isInvalid())
3419 return SemaRef.StmtError();
3421 // Transform the right-hand case value (for the GNU case-range extension).
3422 RHS = getDerived().TransformExpr(S->getRHS());
3423 if (RHS.isInvalid())
3424 return SemaRef.StmtError();
3427 // Build the case statement.
3428 // Case statements are always rebuilt so that they will attached to their
3429 // transformed switch statement.
3430 OwningStmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
3432 S->getEllipsisLoc(),
3435 if (Case.isInvalid())
3436 return SemaRef.StmtError();
3438 // Transform the statement following the case
3439 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
3440 if (SubStmt.isInvalid())
3441 return SemaRef.StmtError();
3443 // Attach the body to the case statement
3444 return getDerived().RebuildCaseStmtBody(move(Case), move(SubStmt));
3447 template<typename Derived>
3448 Sema::OwningStmtResult
3449 TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
3450 // Transform the statement following the default case
3451 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
3452 if (SubStmt.isInvalid())
3453 return SemaRef.StmtError();
3455 // Default statements are always rebuilt
3456 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
3460 template<typename Derived>
3461 Sema::OwningStmtResult
3462 TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) {
3463 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
3464 if (SubStmt.isInvalid())
3465 return SemaRef.StmtError();
3467 // FIXME: Pass the real colon location in.
3468 SourceLocation ColonLoc = SemaRef.PP.getLocForEndOfToken(S->getIdentLoc());
3469 return getDerived().RebuildLabelStmt(S->getIdentLoc(), S->getID(), ColonLoc,
3473 template<typename Derived>
3474 Sema::OwningStmtResult
3475 TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
3476 // Transform the condition
3477 OwningExprResult Cond(SemaRef);
3478 VarDecl *ConditionVar = 0;
3479 if (S->getConditionVariable()) {
3481 = cast_or_null<VarDecl>(
3482 getDerived().TransformDefinition(
3483 S->getConditionVariable()->getLocation(),
3484 S->getConditionVariable()));
3486 return SemaRef.StmtError();
3488 Cond = getDerived().TransformExpr(S->getCond());
3490 if (Cond.isInvalid())
3491 return SemaRef.StmtError();
3494 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond));
3496 // Transform the "then" branch.
3497 OwningStmtResult Then = getDerived().TransformStmt(S->getThen());
3498 if (Then.isInvalid())
3499 return SemaRef.StmtError();
3501 // Transform the "else" branch.
3502 OwningStmtResult Else = getDerived().TransformStmt(S->getElse());
3503 if (Else.isInvalid())
3504 return SemaRef.StmtError();
3506 if (!getDerived().AlwaysRebuild() &&
3507 FullCond->get() == S->getCond() &&
3508 ConditionVar == S->getConditionVariable() &&
3509 Then.get() == S->getThen() &&
3510 Else.get() == S->getElse())
3511 return SemaRef.Owned(S->Retain());
3513 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar,
3515 S->getElseLoc(), move(Else));
3518 template<typename Derived>
3519 Sema::OwningStmtResult
3520 TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
3521 // Transform the condition.
3522 OwningExprResult Cond(SemaRef);
3523 VarDecl *ConditionVar = 0;
3524 if (S->getConditionVariable()) {
3526 = cast_or_null<VarDecl>(
3527 getDerived().TransformDefinition(
3528 S->getConditionVariable()->getLocation(),
3529 S->getConditionVariable()));
3531 return SemaRef.StmtError();
3533 Cond = getDerived().TransformExpr(S->getCond());
3535 if (Cond.isInvalid())
3536 return SemaRef.StmtError();
3539 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond));
3541 // Rebuild the switch statement.
3542 OwningStmtResult Switch = getDerived().RebuildSwitchStmtStart(FullCond,
3544 if (Switch.isInvalid())
3545 return SemaRef.StmtError();
3547 // Transform the body of the switch statement.
3548 OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3549 if (Body.isInvalid())
3550 return SemaRef.StmtError();
3552 // Complete the switch statement.
3553 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), move(Switch),
3557 template<typename Derived>
3558 Sema::OwningStmtResult
3559 TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
3560 // Transform the condition
3561 OwningExprResult Cond(SemaRef);
3562 VarDecl *ConditionVar = 0;
3563 if (S->getConditionVariable()) {
3565 = cast_or_null<VarDecl>(
3566 getDerived().TransformDefinition(
3567 S->getConditionVariable()->getLocation(),
3568 S->getConditionVariable()));
3570 return SemaRef.StmtError();
3572 Cond = getDerived().TransformExpr(S->getCond());
3574 if (Cond.isInvalid())
3575 return SemaRef.StmtError();
3578 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond));
3580 // Transform the body
3581 OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3582 if (Body.isInvalid())
3583 return SemaRef.StmtError();
3585 if (!getDerived().AlwaysRebuild() &&
3586 FullCond->get() == S->getCond() &&
3587 ConditionVar == S->getConditionVariable() &&
3588 Body.get() == S->getBody())
3589 return SemaRef.Owned(S->Retain());
3591 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond, ConditionVar,
3595 template<typename Derived>
3596 Sema::OwningStmtResult
3597 TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
3598 // Transform the condition
3599 OwningExprResult Cond = getDerived().TransformExpr(S->getCond());
3600 if (Cond.isInvalid())
3601 return SemaRef.StmtError();
3603 // Transform the body
3604 OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3605 if (Body.isInvalid())
3606 return SemaRef.StmtError();
3608 if (!getDerived().AlwaysRebuild() &&
3609 Cond.get() == S->getCond() &&
3610 Body.get() == S->getBody())
3611 return SemaRef.Owned(S->Retain());
3613 return getDerived().RebuildDoStmt(S->getDoLoc(), move(Body), S->getWhileLoc(),
3614 /*FIXME:*/S->getWhileLoc(), move(Cond),
3618 template<typename Derived>
3619 Sema::OwningStmtResult
3620 TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
3621 // Transform the initialization statement
3622 OwningStmtResult Init = getDerived().TransformStmt(S->getInit());
3623 if (Init.isInvalid())
3624 return SemaRef.StmtError();
3626 // Transform the condition
3627 OwningExprResult Cond(SemaRef);
3628 VarDecl *ConditionVar = 0;
3629 if (S->getConditionVariable()) {
3631 = cast_or_null<VarDecl>(
3632 getDerived().TransformDefinition(
3633 S->getConditionVariable()->getLocation(),
3634 S->getConditionVariable()));
3636 return SemaRef.StmtError();
3638 Cond = getDerived().TransformExpr(S->getCond());
3640 if (Cond.isInvalid())
3641 return SemaRef.StmtError();
3644 // Transform the increment
3645 OwningExprResult Inc = getDerived().TransformExpr(S->getInc());
3646 if (Inc.isInvalid())
3647 return SemaRef.StmtError();
3649 // Transform the body
3650 OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3651 if (Body.isInvalid())
3652 return SemaRef.StmtError();
3654 if (!getDerived().AlwaysRebuild() &&
3655 Init.get() == S->getInit() &&
3656 Cond.get() == S->getCond() &&
3657 Inc.get() == S->getInc() &&
3658 Body.get() == S->getBody())
3659 return SemaRef.Owned(S->Retain());
3661 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
3662 move(Init), getSema().MakeFullExpr(Cond),
3664 getSema().MakeFullExpr(Inc),
3665 S->getRParenLoc(), move(Body));
3668 template<typename Derived>
3669 Sema::OwningStmtResult
3670 TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
3671 // Goto statements must always be rebuilt, to resolve the label.
3672 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
3676 template<typename Derived>
3677 Sema::OwningStmtResult
3678 TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
3679 OwningExprResult Target = getDerived().TransformExpr(S->getTarget());
3680 if (Target.isInvalid())
3681 return SemaRef.StmtError();
3683 if (!getDerived().AlwaysRebuild() &&
3684 Target.get() == S->getTarget())
3685 return SemaRef.Owned(S->Retain());
3687 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
3691 template<typename Derived>
3692 Sema::OwningStmtResult
3693 TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
3694 return SemaRef.Owned(S->Retain());
3697 template<typename Derived>
3698 Sema::OwningStmtResult
3699 TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
3700 return SemaRef.Owned(S->Retain());
3703 template<typename Derived>
3704 Sema::OwningStmtResult
3705 TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
3706 Sema::OwningExprResult Result = getDerived().TransformExpr(S->getRetValue());
3707 if (Result.isInvalid())
3708 return SemaRef.StmtError();
3710 // FIXME: We always rebuild the return statement because there is no way
3711 // to tell whether the return type of the function has changed.
3712 return getDerived().RebuildReturnStmt(S->getReturnLoc(), move(Result));
3715 template<typename Derived>
3716 Sema::OwningStmtResult
3717 TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
3718 bool DeclChanged = false;
3719 llvm::SmallVector<Decl *, 4> Decls;
3720 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end();
3722 Decl *Transformed = getDerived().TransformDefinition((*D)->getLocation(),
3725 return SemaRef.StmtError();
3727 if (Transformed != *D)
3730 Decls.push_back(Transformed);
3733 if (!getDerived().AlwaysRebuild() && !DeclChanged)
3734 return SemaRef.Owned(S->Retain());
3736 return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(),
3737 S->getStartLoc(), S->getEndLoc());
3740 template<typename Derived>
3741 Sema::OwningStmtResult
3742 TreeTransform<Derived>::TransformSwitchCase(SwitchCase *S) {
3743 assert(false && "SwitchCase is abstract and cannot be transformed");
3744 return SemaRef.Owned(S->Retain());
3747 template<typename Derived>
3748 Sema::OwningStmtResult
3749 TreeTransform<Derived>::TransformAsmStmt(AsmStmt *S) {
3751 ASTOwningVector<&ActionBase::DeleteExpr> Constraints(getSema());
3752 ASTOwningVector<&ActionBase::DeleteExpr> Exprs(getSema());
3753 llvm::SmallVector<IdentifierInfo *, 4> Names;
3755 OwningExprResult AsmString(SemaRef);
3756 ASTOwningVector<&ActionBase::DeleteExpr> Clobbers(getSema());
3758 bool ExprsChanged = false;
3760 // Go through the outputs.
3761 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) {
3762 Names.push_back(S->getOutputIdentifier(I));
3764 // No need to transform the constraint literal.
3765 Constraints.push_back(S->getOutputConstraintLiteral(I)->Retain());
3767 // Transform the output expr.
3768 Expr *OutputExpr = S->getOutputExpr(I);
3769 OwningExprResult Result = getDerived().TransformExpr(OutputExpr);
3770 if (Result.isInvalid())
3771 return SemaRef.StmtError();
3773 ExprsChanged |= Result.get() != OutputExpr;
3775 Exprs.push_back(Result.takeAs<Expr>());
3778 // Go through the inputs.
3779 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) {
3780 Names.push_back(S->getInputIdentifier(I));
3782 // No need to transform the constraint literal.
3783 Constraints.push_back(S->getInputConstraintLiteral(I)->Retain());
3785 // Transform the input expr.
3786 Expr *InputExpr = S->getInputExpr(I);
3787 OwningExprResult Result = getDerived().TransformExpr(InputExpr);
3788 if (Result.isInvalid())
3789 return SemaRef.StmtError();
3791 ExprsChanged |= Result.get() != InputExpr;
3793 Exprs.push_back(Result.takeAs<Expr>());
3796 if (!getDerived().AlwaysRebuild() && !ExprsChanged)
3797 return SemaRef.Owned(S->Retain());
3799 // Go through the clobbers.
3800 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I)
3801 Clobbers.push_back(S->getClobber(I)->Retain());
3803 // No need to transform the asm string literal.
3804 AsmString = SemaRef.Owned(S->getAsmString());
3806 return getDerived().RebuildAsmStmt(S->getAsmLoc(),
3812 move_arg(Constraints),
3821 template<typename Derived>
3822 Sema::OwningStmtResult
3823 TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
3824 // Transform the body of the @try.
3825 OwningStmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
3826 if (TryBody.isInvalid())
3827 return SemaRef.StmtError();
3829 // Transform the @catch statements (if present).
3830 bool AnyCatchChanged = false;
3831 ASTOwningVector<&ActionBase::DeleteStmt> CatchStmts(SemaRef);
3832 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
3833 OwningStmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I));
3834 if (Catch.isInvalid())
3835 return SemaRef.StmtError();
3836 if (Catch.get() != S->getCatchStmt(I))
3837 AnyCatchChanged = true;
3838 CatchStmts.push_back(Catch.release());
3841 // Transform the @finally statement (if present).
3842 OwningStmtResult Finally(SemaRef);
3843 if (S->getFinallyStmt()) {
3844 Finally = getDerived().TransformStmt(S->getFinallyStmt());
3845 if (Finally.isInvalid())
3846 return SemaRef.StmtError();
3849 // If nothing changed, just retain this statement.
3850 if (!getDerived().AlwaysRebuild() &&
3851 TryBody.get() == S->getTryBody() &&
3853 Finally.get() == S->getFinallyStmt())
3854 return SemaRef.Owned(S->Retain());
3856 // Build a new statement.
3857 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), move(TryBody),
3858 move_arg(CatchStmts), move(Finally));
3861 template<typename Derived>
3862 Sema::OwningStmtResult
3863 TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
3864 // Transform the @catch parameter, if there is one.
3866 if (VarDecl *FromVar = S->getCatchParamDecl()) {
3867 TypeSourceInfo *TSInfo = 0;
3868 if (FromVar->getTypeSourceInfo()) {
3869 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
3871 return SemaRef.StmtError();
3876 T = TSInfo->getType();
3878 T = getDerived().TransformType(FromVar->getType());
3880 return SemaRef.StmtError();
3883 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T);
3885 return SemaRef.StmtError();
3888 OwningStmtResult Body = getDerived().TransformStmt(S->getCatchBody());
3889 if (Body.isInvalid())
3890 return SemaRef.StmtError();
3892 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
3897 template<typename Derived>
3898 Sema::OwningStmtResult
3899 TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
3900 // Transform the body.
3901 OwningStmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
3902 if (Body.isInvalid())
3903 return SemaRef.StmtError();
3905 // If nothing changed, just retain this statement.
3906 if (!getDerived().AlwaysRebuild() &&
3907 Body.get() == S->getFinallyBody())
3908 return SemaRef.Owned(S->Retain());
3910 // Build a new statement.
3911 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
3915 template<typename Derived>
3916 Sema::OwningStmtResult
3917 TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
3918 OwningExprResult Operand(SemaRef);
3919 if (S->getThrowExpr()) {
3920 Operand = getDerived().TransformExpr(S->getThrowExpr());
3921 if (Operand.isInvalid())
3922 return getSema().StmtError();
3925 if (!getDerived().AlwaysRebuild() &&
3926 Operand.get() == S->getThrowExpr())
3927 return getSema().Owned(S->Retain());
3929 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), move(Operand));
3932 template<typename Derived>
3933 Sema::OwningStmtResult
3934 TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
3935 ObjCAtSynchronizedStmt *S) {
3936 // Transform the object we are locking.
3937 OwningExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
3938 if (Object.isInvalid())
3939 return SemaRef.StmtError();
3941 // Transform the body.
3942 OwningStmtResult Body = getDerived().TransformStmt(S->getSynchBody());
3943 if (Body.isInvalid())
3944 return SemaRef.StmtError();
3946 // If nothing change, just retain the current statement.
3947 if (!getDerived().AlwaysRebuild() &&
3948 Object.get() == S->getSynchExpr() &&
3949 Body.get() == S->getSynchBody())
3950 return SemaRef.Owned(S->Retain());
3952 // Build a new statement.
3953 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
3954 move(Object), move(Body));
3957 template<typename Derived>
3958 Sema::OwningStmtResult
3959 TreeTransform<Derived>::TransformObjCForCollectionStmt(
3960 ObjCForCollectionStmt *S) {
3961 // Transform the element statement.
3962 OwningStmtResult Element = getDerived().TransformStmt(S->getElement());
3963 if (Element.isInvalid())
3964 return SemaRef.StmtError();
3966 // Transform the collection expression.
3967 OwningExprResult Collection = getDerived().TransformExpr(S->getCollection());
3968 if (Collection.isInvalid())
3969 return SemaRef.StmtError();
3971 // Transform the body.
3972 OwningStmtResult Body = getDerived().TransformStmt(S->getBody());
3973 if (Body.isInvalid())
3974 return SemaRef.StmtError();
3976 // If nothing changed, just retain this statement.
3977 if (!getDerived().AlwaysRebuild() &&
3978 Element.get() == S->getElement() &&
3979 Collection.get() == S->getCollection() &&
3980 Body.get() == S->getBody())
3981 return SemaRef.Owned(S->Retain());
3983 // Build a new statement.
3984 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
3985 /*FIXME:*/S->getForLoc(),
3993 template<typename Derived>
3994 Sema::OwningStmtResult
3995 TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
3996 // Transform the exception declaration, if any.
3998 if (S->getExceptionDecl()) {
3999 VarDecl *ExceptionDecl = S->getExceptionDecl();
4000 TemporaryBase Rebase(*this, ExceptionDecl->getLocation(),
4001 ExceptionDecl->getDeclName());
4003 QualType T = getDerived().TransformType(ExceptionDecl->getType());
4005 return SemaRef.StmtError();
4007 Var = getDerived().RebuildExceptionDecl(ExceptionDecl,
4009 ExceptionDecl->getTypeSourceInfo(),
4010 ExceptionDecl->getIdentifier(),
4011 ExceptionDecl->getLocation(),
4012 /*FIXME: Inaccurate*/
4013 SourceRange(ExceptionDecl->getLocation()));
4014 if (!Var || Var->isInvalidDecl()) {
4016 Var->Destroy(SemaRef.Context);
4017 return SemaRef.StmtError();
4021 // Transform the actual exception handler.
4022 OwningStmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
4023 if (Handler.isInvalid()) {
4025 Var->Destroy(SemaRef.Context);
4026 return SemaRef.StmtError();
4029 if (!getDerived().AlwaysRebuild() &&
4031 Handler.get() == S->getHandlerBlock())
4032 return SemaRef.Owned(S->Retain());
4034 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(),
4039 template<typename Derived>
4040 Sema::OwningStmtResult
4041 TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
4042 // Transform the try block itself.
4043 OwningStmtResult TryBlock
4044 = getDerived().TransformCompoundStmt(S->getTryBlock());
4045 if (TryBlock.isInvalid())
4046 return SemaRef.StmtError();
4048 // Transform the handlers.
4049 bool HandlerChanged = false;
4050 ASTOwningVector<&ActionBase::DeleteStmt> Handlers(SemaRef);
4051 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) {
4052 OwningStmtResult Handler
4053 = getDerived().TransformCXXCatchStmt(S->getHandler(I));
4054 if (Handler.isInvalid())
4055 return SemaRef.StmtError();
4057 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I);
4058 Handlers.push_back(Handler.takeAs<Stmt>());
4061 if (!getDerived().AlwaysRebuild() &&
4062 TryBlock.get() == S->getTryBlock() &&
4064 return SemaRef.Owned(S->Retain());
4066 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), move(TryBlock),
4067 move_arg(Handlers));
4070 //===----------------------------------------------------------------------===//
4071 // Expression transformation
4072 //===----------------------------------------------------------------------===//
4073 template<typename Derived>
4074 Sema::OwningExprResult
4075 TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) {
4076 return SemaRef.Owned(E->Retain());
4079 template<typename Derived>
4080 Sema::OwningExprResult
4081 TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) {
4082 NestedNameSpecifier *Qualifier = 0;
4083 if (E->getQualifier()) {
4084 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
4085 E->getQualifierRange());
4087 return SemaRef.ExprError();
4091 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
4094 return SemaRef.ExprError();
4096 if (!getDerived().AlwaysRebuild() &&
4097 Qualifier == E->getQualifier() &&
4098 ND == E->getDecl() &&
4099 !E->hasExplicitTemplateArgumentList()) {
4101 // Mark it referenced in the new context regardless.
4102 // FIXME: this is a bit instantiation-specific.
4103 SemaRef.MarkDeclarationReferenced(E->getLocation(), ND);
4105 return SemaRef.Owned(E->Retain());
4108 TemplateArgumentListInfo TransArgs, *TemplateArgs = 0;
4109 if (E->hasExplicitTemplateArgumentList()) {
4110 TemplateArgs = &TransArgs;
4111 TransArgs.setLAngleLoc(E->getLAngleLoc());
4112 TransArgs.setRAngleLoc(E->getRAngleLoc());
4113 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
4114 TemplateArgumentLoc Loc;
4115 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc))
4116 return SemaRef.ExprError();
4117 TransArgs.addArgument(Loc);
4121 return getDerived().RebuildDeclRefExpr(Qualifier, E->getQualifierRange(),
4122 ND, E->getLocation(), TemplateArgs);
4125 template<typename Derived>
4126 Sema::OwningExprResult
4127 TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) {
4128 return SemaRef.Owned(E->Retain());
4131 template<typename Derived>
4132 Sema::OwningExprResult
4133 TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) {
4134 return SemaRef.Owned(E->Retain());
4137 template<typename Derived>
4138 Sema::OwningExprResult
4139 TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) {
4140 return SemaRef.Owned(E->Retain());
4143 template<typename Derived>
4144 Sema::OwningExprResult
4145 TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) {
4146 return SemaRef.Owned(E->Retain());
4149 template<typename Derived>
4150 Sema::OwningExprResult
4151 TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) {
4152 return SemaRef.Owned(E->Retain());
4155 template<typename Derived>
4156 Sema::OwningExprResult
4157 TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
4158 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
4159 if (SubExpr.isInvalid())
4160 return SemaRef.ExprError();
4162 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
4163 return SemaRef.Owned(E->Retain());
4165 return getDerived().RebuildParenExpr(move(SubExpr), E->getLParen(),
4169 template<typename Derived>
4170 Sema::OwningExprResult
4171 TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) {
4172 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
4173 if (SubExpr.isInvalid())
4174 return SemaRef.ExprError();
4176 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
4177 return SemaRef.Owned(E->Retain());
4179 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(),
4184 template<typename Derived>
4185 Sema::OwningExprResult
4186 TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) {
4187 // Transform the type.
4188 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
4190 return getSema().ExprError();
4192 // Transform all of the components into components similar to what the
4194 // FIXME: It would be slightly more efficient in the non-dependent case to
4195 // just map FieldDecls, rather than requiring the rebuilder to look for
4196 // the fields again. However, __builtin_offsetof is rare enough in
4197 // template code that we don't care.
4198 bool ExprChanged = false;
4199 typedef Action::OffsetOfComponent Component;
4200 typedef OffsetOfExpr::OffsetOfNode Node;
4201 llvm::SmallVector<Component, 4> Components;
4202 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
4203 const Node &ON = E->getComponent(I);
4205 Comp.isBrackets = true;
4206 Comp.LocStart = ON.getRange().getBegin();
4207 Comp.LocEnd = ON.getRange().getEnd();
4208 switch (ON.getKind()) {
4210 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex());
4211 OwningExprResult Index = getDerived().TransformExpr(FromIndex);
4212 if (Index.isInvalid())
4213 return getSema().ExprError();
4215 ExprChanged = ExprChanged || Index.get() != FromIndex;
4216 Comp.isBrackets = true;
4217 Comp.U.E = Index.takeAs<Expr>(); // FIXME: leaked
4222 case Node::Identifier:
4223 Comp.isBrackets = false;
4224 Comp.U.IdentInfo = ON.getFieldName();
4225 if (!Comp.U.IdentInfo)
4231 // Will be recomputed during the rebuild.
4235 Components.push_back(Comp);
4238 // If nothing changed, retain the existing expression.
4239 if (!getDerived().AlwaysRebuild() &&
4240 Type == E->getTypeSourceInfo() &&
4242 return SemaRef.Owned(E->Retain());
4244 // Build a new offsetof expression.
4245 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type,
4246 Components.data(), Components.size(),
4250 template<typename Derived>
4251 Sema::OwningExprResult
4252 TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
4253 if (E->isArgumentType()) {
4254 TypeSourceInfo *OldT = E->getArgumentTypeInfo();
4256 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
4258 return SemaRef.ExprError();
4260 if (!getDerived().AlwaysRebuild() && OldT == NewT)
4261 return SemaRef.Owned(E->Retain());
4263 return getDerived().RebuildSizeOfAlignOf(NewT, E->getOperatorLoc(),
4265 E->getSourceRange());
4268 Sema::OwningExprResult SubExpr(SemaRef);
4270 // C++0x [expr.sizeof]p1:
4271 // The operand is either an expression, which is an unevaluated operand
4273 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
4275 SubExpr = getDerived().TransformExpr(E->getArgumentExpr());
4276 if (SubExpr.isInvalid())
4277 return SemaRef.ExprError();
4279 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
4280 return SemaRef.Owned(E->Retain());
4283 return getDerived().RebuildSizeOfAlignOf(move(SubExpr), E->getOperatorLoc(),
4285 E->getSourceRange());
4288 template<typename Derived>
4289 Sema::OwningExprResult
4290 TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
4291 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS());
4292 if (LHS.isInvalid())
4293 return SemaRef.ExprError();
4295 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS());
4296 if (RHS.isInvalid())
4297 return SemaRef.ExprError();
4300 if (!getDerived().AlwaysRebuild() &&
4301 LHS.get() == E->getLHS() &&
4302 RHS.get() == E->getRHS())
4303 return SemaRef.Owned(E->Retain());
4305 return getDerived().RebuildArraySubscriptExpr(move(LHS),
4306 /*FIXME:*/E->getLHS()->getLocStart(),
4308 E->getRBracketLoc());
4311 template<typename Derived>
4312 Sema::OwningExprResult
4313 TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
4314 // Transform the callee.
4315 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee());
4316 if (Callee.isInvalid())
4317 return SemaRef.ExprError();
4319 // Transform arguments.
4320 bool ArgChanged = false;
4321 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
4322 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs;
4323 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
4324 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I));
4325 if (Arg.isInvalid())
4326 return SemaRef.ExprError();
4328 // FIXME: Wrong source location information for the ','.
4329 FakeCommaLocs.push_back(
4330 SemaRef.PP.getLocForEndOfToken(E->getArg(I)->getSourceRange().getEnd()));
4332 ArgChanged = ArgChanged || Arg.get() != E->getArg(I);
4333 Args.push_back(Arg.takeAs<Expr>());
4336 if (!getDerived().AlwaysRebuild() &&
4337 Callee.get() == E->getCallee() &&
4339 return SemaRef.Owned(E->Retain());
4341 // FIXME: Wrong source location information for the '('.
4342 SourceLocation FakeLParenLoc
4343 = ((Expr *)Callee.get())->getSourceRange().getBegin();
4344 return getDerived().RebuildCallExpr(move(Callee), FakeLParenLoc,
4346 FakeCommaLocs.data(),
4350 template<typename Derived>
4351 Sema::OwningExprResult
4352 TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
4353 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
4354 if (Base.isInvalid())
4355 return SemaRef.ExprError();
4357 NestedNameSpecifier *Qualifier = 0;
4358 if (E->hasQualifier()) {
4360 = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
4361 E->getQualifierRange());
4363 return SemaRef.ExprError();
4367 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
4368 E->getMemberDecl()));
4370 return SemaRef.ExprError();
4372 NamedDecl *FoundDecl = E->getFoundDecl();
4373 if (FoundDecl == E->getMemberDecl()) {
4376 FoundDecl = cast_or_null<NamedDecl>(
4377 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl));
4379 return SemaRef.ExprError();
4382 if (!getDerived().AlwaysRebuild() &&
4383 Base.get() == E->getBase() &&
4384 Qualifier == E->getQualifier() &&
4385 Member == E->getMemberDecl() &&
4386 FoundDecl == E->getFoundDecl() &&
4387 !E->hasExplicitTemplateArgumentList()) {
4389 // Mark it referenced in the new context regardless.
4390 // FIXME: this is a bit instantiation-specific.
4391 SemaRef.MarkDeclarationReferenced(E->getMemberLoc(), Member);
4392 return SemaRef.Owned(E->Retain());
4395 TemplateArgumentListInfo TransArgs;
4396 if (E->hasExplicitTemplateArgumentList()) {
4397 TransArgs.setLAngleLoc(E->getLAngleLoc());
4398 TransArgs.setRAngleLoc(E->getRAngleLoc());
4399 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
4400 TemplateArgumentLoc Loc;
4401 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc))
4402 return SemaRef.ExprError();
4403 TransArgs.addArgument(Loc);
4407 // FIXME: Bogus source location for the operator
4408 SourceLocation FakeOperatorLoc
4409 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd());
4411 // FIXME: to do this check properly, we will need to preserve the
4412 // first-qualifier-in-scope here, just in case we had a dependent
4413 // base (and therefore couldn't do the check) and a
4414 // nested-name-qualifier (and therefore could do the lookup).
4415 NamedDecl *FirstQualifierInScope = 0;
4417 return getDerived().RebuildMemberExpr(move(Base), FakeOperatorLoc,
4420 E->getQualifierRange(),
4424 (E->hasExplicitTemplateArgumentList()
4426 FirstQualifierInScope);
4429 template<typename Derived>
4430 Sema::OwningExprResult
4431 TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
4432 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS());
4433 if (LHS.isInvalid())
4434 return SemaRef.ExprError();
4436 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS());
4437 if (RHS.isInvalid())
4438 return SemaRef.ExprError();
4440 if (!getDerived().AlwaysRebuild() &&
4441 LHS.get() == E->getLHS() &&
4442 RHS.get() == E->getRHS())
4443 return SemaRef.Owned(E->Retain());
4445 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
4446 move(LHS), move(RHS));
4449 template<typename Derived>
4450 Sema::OwningExprResult
4451 TreeTransform<Derived>::TransformCompoundAssignOperator(
4452 CompoundAssignOperator *E) {
4453 return getDerived().TransformBinaryOperator(E);
4456 template<typename Derived>
4457 Sema::OwningExprResult
4458 TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) {
4459 OwningExprResult Cond = getDerived().TransformExpr(E->getCond());
4460 if (Cond.isInvalid())
4461 return SemaRef.ExprError();
4463 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS());
4464 if (LHS.isInvalid())
4465 return SemaRef.ExprError();
4467 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS());
4468 if (RHS.isInvalid())
4469 return SemaRef.ExprError();
4471 if (!getDerived().AlwaysRebuild() &&
4472 Cond.get() == E->getCond() &&
4473 LHS.get() == E->getLHS() &&
4474 RHS.get() == E->getRHS())
4475 return SemaRef.Owned(E->Retain());
4477 return getDerived().RebuildConditionalOperator(move(Cond),
4478 E->getQuestionLoc(),
4484 template<typename Derived>
4485 Sema::OwningExprResult
4486 TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) {
4487 // Implicit casts are eliminated during transformation, since they
4488 // will be recomputed by semantic analysis after transformation.
4489 return getDerived().TransformExpr(E->getSubExprAsWritten());
4492 template<typename Derived>
4493 Sema::OwningExprResult
4494 TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
4495 TypeSourceInfo *OldT;
4496 TypeSourceInfo *NewT;
4498 // FIXME: Source location isn't quite accurate.
4499 SourceLocation TypeStartLoc
4500 = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc());
4501 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName());
4503 OldT = E->getTypeInfoAsWritten();
4504 NewT = getDerived().TransformType(OldT);
4506 return SemaRef.ExprError();
4509 OwningExprResult SubExpr
4510 = getDerived().TransformExpr(E->getSubExprAsWritten());
4511 if (SubExpr.isInvalid())
4512 return SemaRef.ExprError();
4514 if (!getDerived().AlwaysRebuild() &&
4516 SubExpr.get() == E->getSubExpr())
4517 return SemaRef.Owned(E->Retain());
4519 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
4525 template<typename Derived>
4526 Sema::OwningExprResult
4527 TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) {
4528 TypeSourceInfo *OldT = E->getTypeSourceInfo();
4529 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
4531 return SemaRef.ExprError();
4533 OwningExprResult Init = getDerived().TransformExpr(E->getInitializer());
4534 if (Init.isInvalid())
4535 return SemaRef.ExprError();
4537 if (!getDerived().AlwaysRebuild() &&
4539 Init.get() == E->getInitializer())
4540 return SemaRef.Owned(E->Retain());
4542 // Note: the expression type doesn't necessarily match the
4543 // type-as-written, but that's okay, because it should always be
4544 // derivable from the initializer.
4546 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT,
4547 /*FIXME:*/E->getInitializer()->getLocEnd(),
4551 template<typename Derived>
4552 Sema::OwningExprResult
4553 TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) {
4554 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
4555 if (Base.isInvalid())
4556 return SemaRef.ExprError();
4558 if (!getDerived().AlwaysRebuild() &&
4559 Base.get() == E->getBase())
4560 return SemaRef.Owned(E->Retain());
4562 // FIXME: Bad source location
4563 SourceLocation FakeOperatorLoc
4564 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd());
4565 return getDerived().RebuildExtVectorElementExpr(move(Base), FakeOperatorLoc,
4566 E->getAccessorLoc(),
4570 template<typename Derived>
4571 Sema::OwningExprResult
4572 TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) {
4573 bool InitChanged = false;
4575 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef);
4576 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) {
4577 OwningExprResult Init = getDerived().TransformExpr(E->getInit(I));
4578 if (Init.isInvalid())
4579 return SemaRef.ExprError();
4581 InitChanged = InitChanged || Init.get() != E->getInit(I);
4582 Inits.push_back(Init.takeAs<Expr>());
4585 if (!getDerived().AlwaysRebuild() && !InitChanged)
4586 return SemaRef.Owned(E->Retain());
4588 return getDerived().RebuildInitList(E->getLBraceLoc(), move_arg(Inits),
4589 E->getRBraceLoc(), E->getType());
4592 template<typename Derived>
4593 Sema::OwningExprResult
4594 TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) {
4597 // transform the initializer value
4598 OwningExprResult Init = getDerived().TransformExpr(E->getInit());
4599 if (Init.isInvalid())
4600 return SemaRef.ExprError();
4602 // transform the designators.
4603 ASTOwningVector<&ActionBase::DeleteExpr, 4> ArrayExprs(SemaRef);
4604 bool ExprChanged = false;
4605 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(),
4606 DEnd = E->designators_end();
4608 if (D->isFieldDesignator()) {
4609 Desig.AddDesignator(Designator::getField(D->getFieldName(),
4615 if (D->isArrayDesignator()) {
4616 OwningExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D));
4617 if (Index.isInvalid())
4618 return SemaRef.ExprError();
4620 Desig.AddDesignator(Designator::getArray(Index.get(),
4621 D->getLBracketLoc()));
4623 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D);
4624 ArrayExprs.push_back(Index.release());
4628 assert(D->isArrayRangeDesignator() && "New kind of designator?");
4629 OwningExprResult Start
4630 = getDerived().TransformExpr(E->getArrayRangeStart(*D));
4631 if (Start.isInvalid())
4632 return SemaRef.ExprError();
4634 OwningExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D));
4635 if (End.isInvalid())
4636 return SemaRef.ExprError();
4638 Desig.AddDesignator(Designator::getArrayRange(Start.get(),
4640 D->getLBracketLoc(),
4641 D->getEllipsisLoc()));
4643 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) ||
4644 End.get() != E->getArrayRangeEnd(*D);
4646 ArrayExprs.push_back(Start.release());
4647 ArrayExprs.push_back(End.release());
4650 if (!getDerived().AlwaysRebuild() &&
4651 Init.get() == E->getInit() &&
4653 return SemaRef.Owned(E->Retain());
4655 return getDerived().RebuildDesignatedInitExpr(Desig, move_arg(ArrayExprs),
4656 E->getEqualOrColonLoc(),
4657 E->usesGNUSyntax(), move(Init));
4660 template<typename Derived>
4661 Sema::OwningExprResult
4662 TreeTransform<Derived>::TransformImplicitValueInitExpr(
4663 ImplicitValueInitExpr *E) {
4664 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName());
4666 // FIXME: Will we ever have proper type location here? Will we actually
4667 // need to transform the type?
4668 QualType T = getDerived().TransformType(E->getType());
4670 return SemaRef.ExprError();
4672 if (!getDerived().AlwaysRebuild() &&
4674 return SemaRef.Owned(E->Retain());
4676 return getDerived().RebuildImplicitValueInitExpr(T);
4679 template<typename Derived>
4680 Sema::OwningExprResult
4681 TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) {
4682 // FIXME: Do we want the type as written?
4686 // FIXME: Source location isn't quite accurate.
4687 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName());
4688 T = getDerived().TransformType(E->getType());
4690 return SemaRef.ExprError();
4693 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
4694 if (SubExpr.isInvalid())
4695 return SemaRef.ExprError();
4697 if (!getDerived().AlwaysRebuild() &&
4698 T == E->getType() &&
4699 SubExpr.get() == E->getSubExpr())
4700 return SemaRef.Owned(E->Retain());
4702 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), move(SubExpr),
4703 T, E->getRParenLoc());
4706 template<typename Derived>
4707 Sema::OwningExprResult
4708 TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) {
4709 bool ArgumentChanged = false;
4710 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef);
4711 for (unsigned I = 0, N = E->getNumExprs(); I != N; ++I) {
4712 OwningExprResult Init = getDerived().TransformExpr(E->getExpr(I));
4713 if (Init.isInvalid())
4714 return SemaRef.ExprError();
4716 ArgumentChanged = ArgumentChanged || Init.get() != E->getExpr(I);
4717 Inits.push_back(Init.takeAs<Expr>());
4720 return getDerived().RebuildParenListExpr(E->getLParenLoc(),
4725 /// \brief Transform an address-of-label expression.
4727 /// By default, the transformation of an address-of-label expression always
4728 /// rebuilds the expression, so that the label identifier can be resolved to
4729 /// the corresponding label statement by semantic analysis.
4730 template<typename Derived>
4731 Sema::OwningExprResult
4732 TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) {
4733 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
4737 template<typename Derived>
4738 Sema::OwningExprResult
4739 TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) {
4740 OwningStmtResult SubStmt
4741 = getDerived().TransformCompoundStmt(E->getSubStmt(), true);
4742 if (SubStmt.isInvalid())
4743 return SemaRef.ExprError();
4745 if (!getDerived().AlwaysRebuild() &&
4746 SubStmt.get() == E->getSubStmt())
4747 return SemaRef.Owned(E->Retain());
4749 return getDerived().RebuildStmtExpr(E->getLParenLoc(),
4754 template<typename Derived>
4755 Sema::OwningExprResult
4756 TreeTransform<Derived>::TransformTypesCompatibleExpr(TypesCompatibleExpr *E) {
4759 // FIXME: Source location isn't quite accurate.
4760 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName());
4762 T1 = getDerived().TransformType(E->getArgType1());
4764 return SemaRef.ExprError();
4766 T2 = getDerived().TransformType(E->getArgType2());
4768 return SemaRef.ExprError();
4771 if (!getDerived().AlwaysRebuild() &&
4772 T1 == E->getArgType1() &&
4773 T2 == E->getArgType2())
4774 return SemaRef.Owned(E->Retain());
4776 return getDerived().RebuildTypesCompatibleExpr(E->getBuiltinLoc(),
4777 T1, T2, E->getRParenLoc());
4780 template<typename Derived>
4781 Sema::OwningExprResult
4782 TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) {
4783 OwningExprResult Cond = getDerived().TransformExpr(E->getCond());
4784 if (Cond.isInvalid())
4785 return SemaRef.ExprError();
4787 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS());
4788 if (LHS.isInvalid())
4789 return SemaRef.ExprError();
4791 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS());
4792 if (RHS.isInvalid())
4793 return SemaRef.ExprError();
4795 if (!getDerived().AlwaysRebuild() &&
4796 Cond.get() == E->getCond() &&
4797 LHS.get() == E->getLHS() &&
4798 RHS.get() == E->getRHS())
4799 return SemaRef.Owned(E->Retain());
4801 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(),
4802 move(Cond), move(LHS), move(RHS),
4806 template<typename Derived>
4807 Sema::OwningExprResult
4808 TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) {
4809 return SemaRef.Owned(E->Retain());
4812 template<typename Derived>
4813 Sema::OwningExprResult
4814 TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
4815 switch (E->getOperator()) {
4819 case OO_Array_Delete:
4820 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr");
4821 return SemaRef.ExprError();
4824 // This is a call to an object's operator().
4825 assert(E->getNumArgs() >= 1 && "Object call is missing arguments");
4827 // Transform the object itself.
4828 OwningExprResult Object = getDerived().TransformExpr(E->getArg(0));
4829 if (Object.isInvalid())
4830 return SemaRef.ExprError();
4832 // FIXME: Poor location information
4833 SourceLocation FakeLParenLoc
4834 = SemaRef.PP.getLocForEndOfToken(
4835 static_cast<Expr *>(Object.get())->getLocEnd());
4837 // Transform the call arguments.
4838 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
4839 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs;
4840 for (unsigned I = 1, N = E->getNumArgs(); I != N; ++I) {
4841 if (getDerived().DropCallArgument(E->getArg(I)))
4844 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I));
4845 if (Arg.isInvalid())
4846 return SemaRef.ExprError();
4848 // FIXME: Poor source location information.
4849 SourceLocation FakeCommaLoc
4850 = SemaRef.PP.getLocForEndOfToken(
4851 static_cast<Expr *>(Arg.get())->getLocEnd());
4852 FakeCommaLocs.push_back(FakeCommaLoc);
4853 Args.push_back(Arg.release());
4856 return getDerived().RebuildCallExpr(move(Object), FakeLParenLoc,
4858 FakeCommaLocs.data(),
4862 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4864 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
4865 #include "clang/Basic/OperatorKinds.def"
4870 case OO_Conditional:
4871 llvm_unreachable("conditional operator is not actually overloadable");
4872 return SemaRef.ExprError();
4875 case NUM_OVERLOADED_OPERATORS:
4876 llvm_unreachable("not an overloaded operator?");
4877 return SemaRef.ExprError();
4880 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee());
4881 if (Callee.isInvalid())
4882 return SemaRef.ExprError();
4884 OwningExprResult First = getDerived().TransformExpr(E->getArg(0));
4885 if (First.isInvalid())
4886 return SemaRef.ExprError();
4888 OwningExprResult Second(SemaRef);
4889 if (E->getNumArgs() == 2) {
4890 Second = getDerived().TransformExpr(E->getArg(1));
4891 if (Second.isInvalid())
4892 return SemaRef.ExprError();
4895 if (!getDerived().AlwaysRebuild() &&
4896 Callee.get() == E->getCallee() &&
4897 First.get() == E->getArg(0) &&
4898 (E->getNumArgs() != 2 || Second.get() == E->getArg(1)))
4899 return SemaRef.Owned(E->Retain());
4901 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(),
4902 E->getOperatorLoc(),
4908 template<typename Derived>
4909 Sema::OwningExprResult
4910 TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) {
4911 return getDerived().TransformCallExpr(E);
4914 template<typename Derived>
4915 Sema::OwningExprResult
4916 TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) {
4917 TypeSourceInfo *OldT;
4918 TypeSourceInfo *NewT;
4920 // FIXME: Source location isn't quite accurate.
4921 SourceLocation TypeStartLoc
4922 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc());
4923 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName());
4925 OldT = E->getTypeInfoAsWritten();
4926 NewT = getDerived().TransformType(OldT);
4928 return SemaRef.ExprError();
4931 OwningExprResult SubExpr
4932 = getDerived().TransformExpr(E->getSubExprAsWritten());
4933 if (SubExpr.isInvalid())
4934 return SemaRef.ExprError();
4936 if (!getDerived().AlwaysRebuild() &&
4938 SubExpr.get() == E->getSubExpr())
4939 return SemaRef.Owned(E->Retain());
4941 // FIXME: Poor source location information here.
4942 SourceLocation FakeLAngleLoc
4943 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc());
4944 SourceLocation FakeRAngleLoc = E->getSubExpr()->getSourceRange().getBegin();
4945 SourceLocation FakeRParenLoc
4946 = SemaRef.PP.getLocForEndOfToken(
4947 E->getSubExpr()->getSourceRange().getEnd());
4948 return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(),
4958 template<typename Derived>
4959 Sema::OwningExprResult
4960 TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) {
4961 return getDerived().TransformCXXNamedCastExpr(E);
4964 template<typename Derived>
4965 Sema::OwningExprResult
4966 TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
4967 return getDerived().TransformCXXNamedCastExpr(E);
4970 template<typename Derived>
4971 Sema::OwningExprResult
4972 TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
4973 CXXReinterpretCastExpr *E) {
4974 return getDerived().TransformCXXNamedCastExpr(E);
4977 template<typename Derived>
4978 Sema::OwningExprResult
4979 TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) {
4980 return getDerived().TransformCXXNamedCastExpr(E);
4983 template<typename Derived>
4984 Sema::OwningExprResult
4985 TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
4986 CXXFunctionalCastExpr *E) {
4987 TypeSourceInfo *OldT;
4988 TypeSourceInfo *NewT;
4990 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
4992 OldT = E->getTypeInfoAsWritten();
4993 NewT = getDerived().TransformType(OldT);
4995 return SemaRef.ExprError();
4998 OwningExprResult SubExpr
4999 = getDerived().TransformExpr(E->getSubExprAsWritten());
5000 if (SubExpr.isInvalid())
5001 return SemaRef.ExprError();
5003 if (!getDerived().AlwaysRebuild() &&
5005 SubExpr.get() == E->getSubExpr())
5006 return SemaRef.Owned(E->Retain());
5008 // FIXME: The end of the type's source range is wrong
5009 return getDerived().RebuildCXXFunctionalCastExpr(
5010 /*FIXME:*/SourceRange(E->getTypeBeginLoc()),
5012 /*FIXME:*/E->getSubExpr()->getLocStart(),
5017 template<typename Derived>
5018 Sema::OwningExprResult
5019 TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) {
5020 if (E->isTypeOperand()) {
5021 TypeSourceInfo *TInfo
5022 = getDerived().TransformType(E->getTypeOperandSourceInfo());
5024 return SemaRef.ExprError();
5026 if (!getDerived().AlwaysRebuild() &&
5027 TInfo == E->getTypeOperandSourceInfo())
5028 return SemaRef.Owned(E->Retain());
5030 return getDerived().RebuildCXXTypeidExpr(E->getType(),
5036 // We don't know whether the expression is potentially evaluated until
5037 // after we perform semantic analysis, so the expression is potentially
5038 // potentially evaluated.
5039 EnterExpressionEvaluationContext Unevaluated(SemaRef,
5040 Action::PotentiallyPotentiallyEvaluated);
5042 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
5043 if (SubExpr.isInvalid())
5044 return SemaRef.ExprError();
5046 if (!getDerived().AlwaysRebuild() &&
5047 SubExpr.get() == E->getExprOperand())
5048 return SemaRef.Owned(E->Retain());
5050 return getDerived().RebuildCXXTypeidExpr(E->getType(),
5056 template<typename Derived>
5057 Sema::OwningExprResult
5058 TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
5059 return SemaRef.Owned(E->Retain());
5062 template<typename Derived>
5063 Sema::OwningExprResult
5064 TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
5065 CXXNullPtrLiteralExpr *E) {
5066 return SemaRef.Owned(E->Retain());
5069 template<typename Derived>
5070 Sema::OwningExprResult
5071 TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) {
5072 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName());
5074 QualType T = getDerived().TransformType(E->getType());
5076 return SemaRef.ExprError();
5078 if (!getDerived().AlwaysRebuild() &&
5080 return SemaRef.Owned(E->Retain());
5082 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit());
5085 template<typename Derived>
5086 Sema::OwningExprResult
5087 TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) {
5088 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
5089 if (SubExpr.isInvalid())
5090 return SemaRef.ExprError();
5092 if (!getDerived().AlwaysRebuild() &&
5093 SubExpr.get() == E->getSubExpr())
5094 return SemaRef.Owned(E->Retain());
5096 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), move(SubExpr));
5099 template<typename Derived>
5100 Sema::OwningExprResult
5101 TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
5103 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(),
5106 return SemaRef.ExprError();
5108 if (!getDerived().AlwaysRebuild() &&
5109 Param == E->getParam())
5110 return SemaRef.Owned(E->Retain());
5112 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param);
5115 template<typename Derived>
5116 Sema::OwningExprResult
5117 TreeTransform<Derived>::TransformCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) {
5118 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
5120 QualType T = getDerived().TransformType(E->getType());
5122 return SemaRef.ExprError();
5124 if (!getDerived().AlwaysRebuild() &&
5126 return SemaRef.Owned(E->Retain());
5128 return getDerived().RebuildCXXZeroInitValueExpr(E->getTypeBeginLoc(),
5129 /*FIXME:*/E->getTypeBeginLoc(),
5134 template<typename Derived>
5135 Sema::OwningExprResult
5136 TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) {
5137 // Transform the type that we're allocating
5138 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName());
5139 QualType AllocType = getDerived().TransformType(E->getAllocatedType());
5140 if (AllocType.isNull())
5141 return SemaRef.ExprError();
5143 // Transform the size of the array we're allocating (if any).
5144 OwningExprResult ArraySize = getDerived().TransformExpr(E->getArraySize());
5145 if (ArraySize.isInvalid())
5146 return SemaRef.ExprError();
5148 // Transform the placement arguments (if any).
5149 bool ArgumentChanged = false;
5150 ASTOwningVector<&ActionBase::DeleteExpr> PlacementArgs(SemaRef);
5151 for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) {
5152 OwningExprResult Arg = getDerived().TransformExpr(E->getPlacementArg(I));
5153 if (Arg.isInvalid())
5154 return SemaRef.ExprError();
5156 ArgumentChanged = ArgumentChanged || Arg.get() != E->getPlacementArg(I);
5157 PlacementArgs.push_back(Arg.take());
5160 // transform the constructor arguments (if any).
5161 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(SemaRef);
5162 for (unsigned I = 0, N = E->getNumConstructorArgs(); I != N; ++I) {
5163 OwningExprResult Arg = getDerived().TransformExpr(E->getConstructorArg(I));
5164 if (Arg.isInvalid())
5165 return SemaRef.ExprError();
5167 ArgumentChanged = ArgumentChanged || Arg.get() != E->getConstructorArg(I);
5168 ConstructorArgs.push_back(Arg.take());
5171 // Transform constructor, new operator, and delete operator.
5172 CXXConstructorDecl *Constructor = 0;
5173 if (E->getConstructor()) {
5174 Constructor = cast_or_null<CXXConstructorDecl>(
5175 getDerived().TransformDecl(E->getLocStart(),
5176 E->getConstructor()));
5178 return SemaRef.ExprError();
5181 FunctionDecl *OperatorNew = 0;
5182 if (E->getOperatorNew()) {
5183 OperatorNew = cast_or_null<FunctionDecl>(
5184 getDerived().TransformDecl(E->getLocStart(),
5185 E->getOperatorNew()));
5187 return SemaRef.ExprError();
5190 FunctionDecl *OperatorDelete = 0;
5191 if (E->getOperatorDelete()) {
5192 OperatorDelete = cast_or_null<FunctionDecl>(
5193 getDerived().TransformDecl(E->getLocStart(),
5194 E->getOperatorDelete()));
5195 if (!OperatorDelete)
5196 return SemaRef.ExprError();
5199 if (!getDerived().AlwaysRebuild() &&
5200 AllocType == E->getAllocatedType() &&
5201 ArraySize.get() == E->getArraySize() &&
5202 Constructor == E->getConstructor() &&
5203 OperatorNew == E->getOperatorNew() &&
5204 OperatorDelete == E->getOperatorDelete() &&
5206 // Mark any declarations we need as referenced.
5207 // FIXME: instantiation-specific.
5209 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor);
5211 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorNew);
5213 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorDelete);
5214 return SemaRef.Owned(E->Retain());
5217 if (!ArraySize.get()) {
5218 // If no array size was specified, but the new expression was
5219 // instantiated with an array type (e.g., "new T" where T is
5220 // instantiated with "int[4]"), extract the outer bound from the
5221 // array type as our array size. We do this with constant and
5222 // dependently-sized array types.
5223 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType);
5226 } else if (const ConstantArrayType *ConsArrayT
5227 = dyn_cast<ConstantArrayType>(ArrayT)) {
5229 = SemaRef.Owned(new (SemaRef.Context) IntegerLiteral(
5230 ConsArrayT->getSize(),
5231 SemaRef.Context.getSizeType(),
5232 /*FIXME:*/E->getLocStart()));
5233 AllocType = ConsArrayT->getElementType();
5234 } else if (const DependentSizedArrayType *DepArrayT
5235 = dyn_cast<DependentSizedArrayType>(ArrayT)) {
5236 if (DepArrayT->getSizeExpr()) {
5237 ArraySize = SemaRef.Owned(DepArrayT->getSizeExpr()->Retain());
5238 AllocType = DepArrayT->getElementType();
5242 return getDerived().RebuildCXXNewExpr(E->getLocStart(),
5244 /*FIXME:*/E->getLocStart(),
5245 move_arg(PlacementArgs),
5246 /*FIXME:*/E->getLocStart(),
5249 /*FIXME:*/E->getLocStart(),
5250 /*FIXME:*/SourceRange(),
5252 /*FIXME:*/E->getLocStart(),
5253 move_arg(ConstructorArgs),
5257 template<typename Derived>
5258 Sema::OwningExprResult
5259 TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) {
5260 OwningExprResult Operand = getDerived().TransformExpr(E->getArgument());
5261 if (Operand.isInvalid())
5262 return SemaRef.ExprError();
5264 // Transform the delete operator, if known.
5265 FunctionDecl *OperatorDelete = 0;
5266 if (E->getOperatorDelete()) {
5267 OperatorDelete = cast_or_null<FunctionDecl>(
5268 getDerived().TransformDecl(E->getLocStart(),
5269 E->getOperatorDelete()));
5270 if (!OperatorDelete)
5271 return SemaRef.ExprError();
5274 if (!getDerived().AlwaysRebuild() &&
5275 Operand.get() == E->getArgument() &&
5276 OperatorDelete == E->getOperatorDelete()) {
5277 // Mark any declarations we need as referenced.
5278 // FIXME: instantiation-specific.
5280 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorDelete);
5281 return SemaRef.Owned(E->Retain());
5284 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(),
5285 E->isGlobalDelete(),
5290 template<typename Derived>
5291 Sema::OwningExprResult
5292 TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
5293 CXXPseudoDestructorExpr *E) {
5294 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
5295 if (Base.isInvalid())
5296 return SemaRef.ExprError();
5298 Sema::TypeTy *ObjectTypePtr = 0;
5299 bool MayBePseudoDestructor = false;
5300 Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base),
5301 E->getOperatorLoc(),
5302 E->isArrow()? tok::arrow : tok::period,
5304 MayBePseudoDestructor);
5305 if (Base.isInvalid())
5306 return SemaRef.ExprError();
5308 QualType ObjectType = QualType::getFromOpaquePtr(ObjectTypePtr);
5309 NestedNameSpecifier *Qualifier
5310 = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
5311 E->getQualifierRange(),
5313 if (E->getQualifier() && !Qualifier)
5314 return SemaRef.ExprError();
5316 PseudoDestructorTypeStorage Destroyed;
5317 if (E->getDestroyedTypeInfo()) {
5318 TypeSourceInfo *DestroyedTypeInfo
5319 = getDerived().TransformType(E->getDestroyedTypeInfo(), ObjectType);
5320 if (!DestroyedTypeInfo)
5321 return SemaRef.ExprError();
5322 Destroyed = DestroyedTypeInfo;
5323 } else if (ObjectType->isDependentType()) {
5324 // We aren't likely to be able to resolve the identifier down to a type
5325 // now anyway, so just retain the identifier.
5326 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(),
5327 E->getDestroyedTypeLoc());
5329 // Look for a destructor known with the given name.
5332 SS.setScopeRep(Qualifier);
5333 SS.setRange(E->getQualifierRange());
5336 Sema::TypeTy *T = SemaRef.getDestructorName(E->getTildeLoc(),
5337 *E->getDestroyedTypeIdentifier(),
5338 E->getDestroyedTypeLoc(),
5343 return SemaRef.ExprError();
5346 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T),
5347 E->getDestroyedTypeLoc());
5350 TypeSourceInfo *ScopeTypeInfo = 0;
5351 if (E->getScopeTypeInfo()) {
5352 ScopeTypeInfo = getDerived().TransformType(E->getScopeTypeInfo(),
5355 return SemaRef.ExprError();
5358 return getDerived().RebuildCXXPseudoDestructorExpr(move(Base),
5359 E->getOperatorLoc(),
5362 E->getQualifierRange(),
5364 E->getColonColonLoc(),
5369 template<typename Derived>
5370 Sema::OwningExprResult
5371 TreeTransform<Derived>::TransformUnresolvedLookupExpr(
5372 UnresolvedLookupExpr *Old) {
5373 TemporaryBase Rebase(*this, Old->getNameLoc(), DeclarationName());
5375 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(),
5376 Sema::LookupOrdinaryName);
5378 // Transform all the decls.
5379 for (UnresolvedLookupExpr::decls_iterator I = Old->decls_begin(),
5380 E = Old->decls_end(); I != E; ++I) {
5381 NamedDecl *InstD = static_cast<NamedDecl*>(
5382 getDerived().TransformDecl(Old->getNameLoc(),
5385 // Silently ignore these if a UsingShadowDecl instantiated to nothing.
5386 // This can happen because of dependent hiding.
5387 if (isa<UsingShadowDecl>(*I))
5390 return SemaRef.ExprError();
5393 // Expand using declarations.
5394 if (isa<UsingDecl>(InstD)) {
5395 UsingDecl *UD = cast<UsingDecl>(InstD);
5396 for (UsingDecl::shadow_iterator I = UD->shadow_begin(),
5397 E = UD->shadow_end(); I != E; ++I)
5405 // Resolve a kind, but don't do any further analysis. If it's
5406 // ambiguous, the callee needs to deal with it.
5409 // Rebuild the nested-name qualifier, if present.
5411 NestedNameSpecifier *Qualifier = 0;
5412 if (Old->getQualifier()) {
5413 Qualifier = getDerived().TransformNestedNameSpecifier(Old->getQualifier(),
5414 Old->getQualifierRange());
5416 return SemaRef.ExprError();
5418 SS.setScopeRep(Qualifier);
5419 SS.setRange(Old->getQualifierRange());
5422 if (Old->getNamingClass()) {
5423 CXXRecordDecl *NamingClass
5424 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
5426 Old->getNamingClass()));
5428 return SemaRef.ExprError();
5430 R.setNamingClass(NamingClass);
5433 // If we have no template arguments, it's a normal declaration name.
5434 if (!Old->hasExplicitTemplateArgs())
5435 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL());
5437 // If we have template arguments, rebuild them, then rebuild the
5438 // templateid expression.
5439 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc());
5440 for (unsigned I = 0, N = Old->getNumTemplateArgs(); I != N; ++I) {
5441 TemplateArgumentLoc Loc;
5442 if (getDerived().TransformTemplateArgument(Old->getTemplateArgs()[I], Loc))
5443 return SemaRef.ExprError();
5444 TransArgs.addArgument(Loc);
5447 return getDerived().RebuildTemplateIdExpr(SS, R, Old->requiresADL(),
5451 template<typename Derived>
5452 Sema::OwningExprResult
5453 TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
5454 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName());
5456 QualType T = getDerived().TransformType(E->getQueriedType());
5458 return SemaRef.ExprError();
5460 if (!getDerived().AlwaysRebuild() &&
5461 T == E->getQueriedType())
5462 return SemaRef.Owned(E->Retain());
5464 // FIXME: Bad location information
5465 SourceLocation FakeLParenLoc
5466 = SemaRef.PP.getLocForEndOfToken(E->getLocStart());
5468 return getDerived().RebuildUnaryTypeTrait(E->getTrait(),
5470 /*FIXME:*/FakeLParenLoc,
5475 template<typename Derived>
5476 Sema::OwningExprResult
5477 TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
5478 DependentScopeDeclRefExpr *E) {
5479 NestedNameSpecifier *NNS
5480 = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
5481 E->getQualifierRange());
5483 return SemaRef.ExprError();
5485 DeclarationName Name
5486 = getDerived().TransformDeclarationName(E->getDeclName(), E->getLocation());
5488 return SemaRef.ExprError();
5490 if (!E->hasExplicitTemplateArgs()) {
5491 if (!getDerived().AlwaysRebuild() &&
5492 NNS == E->getQualifier() &&
5493 Name == E->getDeclName())
5494 return SemaRef.Owned(E->Retain());
5496 return getDerived().RebuildDependentScopeDeclRefExpr(NNS,
5497 E->getQualifierRange(),
5498 Name, E->getLocation(),
5499 /*TemplateArgs*/ 0);
5502 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
5503 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
5504 TemplateArgumentLoc Loc;
5505 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc))
5506 return SemaRef.ExprError();
5507 TransArgs.addArgument(Loc);
5510 return getDerived().RebuildDependentScopeDeclRefExpr(NNS,
5511 E->getQualifierRange(),
5512 Name, E->getLocation(),
5516 template<typename Derived>
5517 Sema::OwningExprResult
5518 TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) {
5519 // CXXConstructExprs are always implicit, so when we have a
5520 // 1-argument construction we just transform that argument.
5521 if (E->getNumArgs() == 1 ||
5522 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1))))
5523 return getDerived().TransformExpr(E->getArg(0));
5525 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName());
5527 QualType T = getDerived().TransformType(E->getType());
5529 return SemaRef.ExprError();
5531 CXXConstructorDecl *Constructor
5532 = cast_or_null<CXXConstructorDecl>(
5533 getDerived().TransformDecl(E->getLocStart(),
5534 E->getConstructor()));
5536 return SemaRef.ExprError();
5538 bool ArgumentChanged = false;
5539 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
5540 for (CXXConstructExpr::arg_iterator Arg = E->arg_begin(),
5541 ArgEnd = E->arg_end();
5542 Arg != ArgEnd; ++Arg) {
5543 if (getDerived().DropCallArgument(*Arg)) {
5544 ArgumentChanged = true;
5548 OwningExprResult TransArg = getDerived().TransformExpr(*Arg);
5549 if (TransArg.isInvalid())
5550 return SemaRef.ExprError();
5552 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg;
5553 Args.push_back(TransArg.takeAs<Expr>());
5556 if (!getDerived().AlwaysRebuild() &&
5557 T == E->getType() &&
5558 Constructor == E->getConstructor() &&
5560 // Mark the constructor as referenced.
5561 // FIXME: Instantiation-specific
5562 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor);
5563 return SemaRef.Owned(E->Retain());
5566 return getDerived().RebuildCXXConstructExpr(T, /*FIXME:*/E->getLocStart(),
5567 Constructor, E->isElidable(),
5571 /// \brief Transform a C++ temporary-binding expression.
5573 /// Since CXXBindTemporaryExpr nodes are implicitly generated, we just
5574 /// transform the subexpression and return that.
5575 template<typename Derived>
5576 Sema::OwningExprResult
5577 TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
5578 return getDerived().TransformExpr(E->getSubExpr());
5581 /// \brief Transform a C++ reference-binding expression.
5583 /// Since CXXBindReferenceExpr nodes are implicitly generated, we just
5584 /// transform the subexpression and return that.
5585 template<typename Derived>
5586 Sema::OwningExprResult
5587 TreeTransform<Derived>::TransformCXXBindReferenceExpr(CXXBindReferenceExpr *E) {
5588 return getDerived().TransformExpr(E->getSubExpr());
5591 /// \brief Transform a C++ expression that contains temporaries that should
5592 /// be destroyed after the expression is evaluated.
5594 /// Since CXXExprWithTemporaries nodes are implicitly generated, we
5595 /// just transform the subexpression and return that.
5596 template<typename Derived>
5597 Sema::OwningExprResult
5598 TreeTransform<Derived>::TransformCXXExprWithTemporaries(
5599 CXXExprWithTemporaries *E) {
5600 return getDerived().TransformExpr(E->getSubExpr());
5603 template<typename Derived>
5604 Sema::OwningExprResult
5605 TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
5606 CXXTemporaryObjectExpr *E) {
5607 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
5608 QualType T = getDerived().TransformType(E->getType());
5610 return SemaRef.ExprError();
5612 CXXConstructorDecl *Constructor
5613 = cast_or_null<CXXConstructorDecl>(
5614 getDerived().TransformDecl(E->getLocStart(),
5615 E->getConstructor()));
5617 return SemaRef.ExprError();
5619 bool ArgumentChanged = false;
5620 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
5621 Args.reserve(E->getNumArgs());
5622 for (CXXTemporaryObjectExpr::arg_iterator Arg = E->arg_begin(),
5623 ArgEnd = E->arg_end();
5624 Arg != ArgEnd; ++Arg) {
5625 if (getDerived().DropCallArgument(*Arg)) {
5626 ArgumentChanged = true;
5630 OwningExprResult TransArg = getDerived().TransformExpr(*Arg);
5631 if (TransArg.isInvalid())
5632 return SemaRef.ExprError();
5634 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg;
5635 Args.push_back((Expr *)TransArg.release());
5638 if (!getDerived().AlwaysRebuild() &&
5639 T == E->getType() &&
5640 Constructor == E->getConstructor() &&
5642 // FIXME: Instantiation-specific
5643 SemaRef.MarkDeclarationReferenced(E->getTypeBeginLoc(), Constructor);
5644 return SemaRef.MaybeBindToTemporary(E->Retain());
5647 // FIXME: Bogus location information
5648 SourceLocation CommaLoc;
5649 if (Args.size() > 1) {
5650 Expr *First = (Expr *)Args[0];
5652 = SemaRef.PP.getLocForEndOfToken(First->getSourceRange().getEnd());
5654 return getDerived().RebuildCXXTemporaryObjectExpr(E->getTypeBeginLoc(),
5656 /*FIXME:*/E->getTypeBeginLoc(),
5662 template<typename Derived>
5663 Sema::OwningExprResult
5664 TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
5665 CXXUnresolvedConstructExpr *E) {
5666 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
5667 QualType T = getDerived().TransformType(E->getTypeAsWritten());
5669 return SemaRef.ExprError();
5671 bool ArgumentChanged = false;
5672 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
5673 llvm::SmallVector<SourceLocation, 8> FakeCommaLocs;
5674 for (CXXUnresolvedConstructExpr::arg_iterator Arg = E->arg_begin(),
5675 ArgEnd = E->arg_end();
5676 Arg != ArgEnd; ++Arg) {
5677 OwningExprResult TransArg = getDerived().TransformExpr(*Arg);
5678 if (TransArg.isInvalid())
5679 return SemaRef.ExprError();
5681 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg;
5682 FakeCommaLocs.push_back(
5683 SemaRef.PP.getLocForEndOfToken((*Arg)->getLocEnd()));
5684 Args.push_back(TransArg.takeAs<Expr>());
5687 if (!getDerived().AlwaysRebuild() &&
5688 T == E->getTypeAsWritten() &&
5690 return SemaRef.Owned(E->Retain());
5692 // FIXME: we're faking the locations of the commas
5693 return getDerived().RebuildCXXUnresolvedConstructExpr(E->getTypeBeginLoc(),
5697 FakeCommaLocs.data(),
5701 template<typename Derived>
5702 Sema::OwningExprResult
5703 TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
5704 CXXDependentScopeMemberExpr *E) {
5705 // Transform the base of the expression.
5706 OwningExprResult Base(SemaRef, (Expr*) 0);
5709 QualType ObjectType;
5710 if (!E->isImplicitAccess()) {
5711 OldBase = E->getBase();
5712 Base = getDerived().TransformExpr(OldBase);
5713 if (Base.isInvalid())
5714 return SemaRef.ExprError();
5716 // Start the member reference and compute the object's type.
5717 Sema::TypeTy *ObjectTy = 0;
5718 bool MayBePseudoDestructor = false;
5719 Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base),
5720 E->getOperatorLoc(),
5721 E->isArrow()? tok::arrow : tok::period,
5723 MayBePseudoDestructor);
5724 if (Base.isInvalid())
5725 return SemaRef.ExprError();
5727 ObjectType = QualType::getFromOpaquePtr(ObjectTy);
5728 BaseType = ((Expr*) Base.get())->getType();
5731 BaseType = getDerived().TransformType(E->getBaseType());
5732 ObjectType = BaseType->getAs<PointerType>()->getPointeeType();
5735 // Transform the first part of the nested-name-specifier that qualifies
5737 NamedDecl *FirstQualifierInScope
5738 = getDerived().TransformFirstQualifierInScope(
5739 E->getFirstQualifierFoundInScope(),
5740 E->getQualifierRange().getBegin());
5742 NestedNameSpecifier *Qualifier = 0;
5743 if (E->getQualifier()) {
5744 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
5745 E->getQualifierRange(),
5747 FirstQualifierInScope);
5749 return SemaRef.ExprError();
5752 DeclarationName Name
5753 = getDerived().TransformDeclarationName(E->getMember(), E->getMemberLoc(),
5756 return SemaRef.ExprError();
5758 if (!E->hasExplicitTemplateArgs()) {
5759 // This is a reference to a member without an explicitly-specified
5760 // template argument list. Optimize for this common case.
5761 if (!getDerived().AlwaysRebuild() &&
5762 Base.get() == OldBase &&
5763 BaseType == E->getBaseType() &&
5764 Qualifier == E->getQualifier() &&
5765 Name == E->getMember() &&
5766 FirstQualifierInScope == E->getFirstQualifierFoundInScope())
5767 return SemaRef.Owned(E->Retain());
5769 return getDerived().RebuildCXXDependentScopeMemberExpr(move(Base),
5772 E->getOperatorLoc(),
5774 E->getQualifierRange(),
5775 FirstQualifierInScope,
5778 /*TemplateArgs*/ 0);
5781 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
5782 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
5783 TemplateArgumentLoc Loc;
5784 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc))
5785 return SemaRef.ExprError();
5786 TransArgs.addArgument(Loc);
5789 return getDerived().RebuildCXXDependentScopeMemberExpr(move(Base),
5792 E->getOperatorLoc(),
5794 E->getQualifierRange(),
5795 FirstQualifierInScope,
5801 template<typename Derived>
5802 Sema::OwningExprResult
5803 TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) {
5804 // Transform the base of the expression.
5805 OwningExprResult Base(SemaRef, (Expr*) 0);
5807 if (!Old->isImplicitAccess()) {
5808 Base = getDerived().TransformExpr(Old->getBase());
5809 if (Base.isInvalid())
5810 return SemaRef.ExprError();
5811 BaseType = ((Expr*) Base.get())->getType();
5813 BaseType = getDerived().TransformType(Old->getBaseType());
5816 NestedNameSpecifier *Qualifier = 0;
5817 if (Old->getQualifier()) {
5819 = getDerived().TransformNestedNameSpecifier(Old->getQualifier(),
5820 Old->getQualifierRange());
5822 return SemaRef.ExprError();
5825 LookupResult R(SemaRef, Old->getMemberName(), Old->getMemberLoc(),
5826 Sema::LookupOrdinaryName);
5828 // Transform all the decls.
5829 for (UnresolvedMemberExpr::decls_iterator I = Old->decls_begin(),
5830 E = Old->decls_end(); I != E; ++I) {
5831 NamedDecl *InstD = static_cast<NamedDecl*>(
5832 getDerived().TransformDecl(Old->getMemberLoc(),
5835 // Silently ignore these if a UsingShadowDecl instantiated to nothing.
5836 // This can happen because of dependent hiding.
5837 if (isa<UsingShadowDecl>(*I))
5840 return SemaRef.ExprError();
5843 // Expand using declarations.
5844 if (isa<UsingDecl>(InstD)) {
5845 UsingDecl *UD = cast<UsingDecl>(InstD);
5846 for (UsingDecl::shadow_iterator I = UD->shadow_begin(),
5847 E = UD->shadow_end(); I != E; ++I)
5857 // Determine the naming class.
5858 if (!Old->getNamingClass()) {
5859 CXXRecordDecl *NamingClass
5860 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
5861 Old->getMemberLoc(),
5862 Old->getNamingClass()));
5864 return SemaRef.ExprError();
5866 R.setNamingClass(NamingClass);
5869 TemplateArgumentListInfo TransArgs;
5870 if (Old->hasExplicitTemplateArgs()) {
5871 TransArgs.setLAngleLoc(Old->getLAngleLoc());
5872 TransArgs.setRAngleLoc(Old->getRAngleLoc());
5873 for (unsigned I = 0, N = Old->getNumTemplateArgs(); I != N; ++I) {
5874 TemplateArgumentLoc Loc;
5875 if (getDerived().TransformTemplateArgument(Old->getTemplateArgs()[I],
5877 return SemaRef.ExprError();
5878 TransArgs.addArgument(Loc);
5882 // FIXME: to do this check properly, we will need to preserve the
5883 // first-qualifier-in-scope here, just in case we had a dependent
5884 // base (and therefore couldn't do the check) and a
5885 // nested-name-qualifier (and therefore could do the lookup).
5886 NamedDecl *FirstQualifierInScope = 0;
5888 return getDerived().RebuildUnresolvedMemberExpr(move(Base),
5890 Old->getOperatorLoc(),
5893 Old->getQualifierRange(),
5894 FirstQualifierInScope,
5896 (Old->hasExplicitTemplateArgs()
5900 template<typename Derived>
5901 Sema::OwningExprResult
5902 TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) {
5903 return SemaRef.Owned(E->Retain());
5906 template<typename Derived>
5907 Sema::OwningExprResult
5908 TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) {
5909 TypeSourceInfo *EncodedTypeInfo
5910 = getDerived().TransformType(E->getEncodedTypeSourceInfo());
5911 if (!EncodedTypeInfo)
5912 return SemaRef.ExprError();
5914 if (!getDerived().AlwaysRebuild() &&
5915 EncodedTypeInfo == E->getEncodedTypeSourceInfo())
5916 return SemaRef.Owned(E->Retain());
5918 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(),
5923 template<typename Derived>
5924 Sema::OwningExprResult
5925 TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) {
5926 // Transform arguments.
5927 bool ArgChanged = false;
5928 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef);
5929 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
5930 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I));
5931 if (Arg.isInvalid())
5932 return SemaRef.ExprError();
5934 ArgChanged = ArgChanged || Arg.get() != E->getArg(I);
5935 Args.push_back(Arg.takeAs<Expr>());
5938 if (E->getReceiverKind() == ObjCMessageExpr::Class) {
5939 // Class message: transform the receiver type.
5940 TypeSourceInfo *ReceiverTypeInfo
5941 = getDerived().TransformType(E->getClassReceiverTypeInfo());
5942 if (!ReceiverTypeInfo)
5943 return SemaRef.ExprError();
5945 // If nothing changed, just retain the existing message send.
5946 if (!getDerived().AlwaysRebuild() &&
5947 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged)
5948 return SemaRef.Owned(E->Retain());
5950 // Build a new class message send.
5951 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo,
5959 // Instance message: transform the receiver
5960 assert(E->getReceiverKind() == ObjCMessageExpr::Instance &&
5961 "Only class and instance messages may be instantiated");
5962 OwningExprResult Receiver
5963 = getDerived().TransformExpr(E->getInstanceReceiver());
5964 if (Receiver.isInvalid())
5965 return SemaRef.ExprError();
5967 // If nothing changed, just retain the existing message send.
5968 if (!getDerived().AlwaysRebuild() &&
5969 Receiver.get() == E->getInstanceReceiver() && !ArgChanged)
5970 return SemaRef.Owned(E->Retain());
5972 // Build a new instance message send.
5973 return getDerived().RebuildObjCMessageExpr(move(Receiver),
5981 template<typename Derived>
5982 Sema::OwningExprResult
5983 TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) {
5984 return SemaRef.Owned(E->Retain());
5987 template<typename Derived>
5988 Sema::OwningExprResult
5989 TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) {
5990 return SemaRef.Owned(E->Retain());
5993 template<typename Derived>
5994 Sema::OwningExprResult
5995 TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) {
5996 // Transform the base expression.
5997 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
5998 if (Base.isInvalid())
5999 return SemaRef.ExprError();
6001 // We don't need to transform the ivar; it will never change.
6003 // If nothing changed, just retain the existing expression.
6004 if (!getDerived().AlwaysRebuild() &&
6005 Base.get() == E->getBase())
6006 return SemaRef.Owned(E->Retain());
6008 return getDerived().RebuildObjCIvarRefExpr(move(Base), E->getDecl(),
6010 E->isArrow(), E->isFreeIvar());
6013 template<typename Derived>
6014 Sema::OwningExprResult
6015 TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
6016 // Transform the base expression.
6017 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
6018 if (Base.isInvalid())
6019 return SemaRef.ExprError();
6021 // We don't need to transform the property; it will never change.
6023 // If nothing changed, just retain the existing expression.
6024 if (!getDerived().AlwaysRebuild() &&
6025 Base.get() == E->getBase())
6026 return SemaRef.Owned(E->Retain());
6028 return getDerived().RebuildObjCPropertyRefExpr(move(Base), E->getProperty(),
6032 template<typename Derived>
6033 Sema::OwningExprResult
6034 TreeTransform<Derived>::TransformObjCImplicitSetterGetterRefExpr(
6035 ObjCImplicitSetterGetterRefExpr *E) {
6036 // If this implicit setter/getter refers to class methods, it cannot have any
6037 // dependent parts. Just retain the existing declaration.
6038 if (E->getInterfaceDecl())
6039 return SemaRef.Owned(E->Retain());
6041 // Transform the base expression.
6042 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
6043 if (Base.isInvalid())
6044 return SemaRef.ExprError();
6046 // We don't need to transform the getters/setters; they will never change.
6048 // If nothing changed, just retain the existing expression.
6049 if (!getDerived().AlwaysRebuild() &&
6050 Base.get() == E->getBase())
6051 return SemaRef.Owned(E->Retain());
6053 return getDerived().RebuildObjCImplicitSetterGetterRefExpr(
6054 E->getGetterMethod(),
6056 E->getSetterMethod(),
6062 template<typename Derived>
6063 Sema::OwningExprResult
6064 TreeTransform<Derived>::TransformObjCSuperExpr(ObjCSuperExpr *E) {
6065 // Can never occur in a dependent context.
6066 return SemaRef.Owned(E->Retain());
6069 template<typename Derived>
6070 Sema::OwningExprResult
6071 TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) {
6072 // Transform the base expression.
6073 OwningExprResult Base = getDerived().TransformExpr(E->getBase());
6074 if (Base.isInvalid())
6075 return SemaRef.ExprError();
6077 // If nothing changed, just retain the existing expression.
6078 if (!getDerived().AlwaysRebuild() &&
6079 Base.get() == E->getBase())
6080 return SemaRef.Owned(E->Retain());
6082 return getDerived().RebuildObjCIsaExpr(move(Base), E->getIsaMemberLoc(),
6086 template<typename Derived>
6087 Sema::OwningExprResult
6088 TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) {
6089 bool ArgumentChanged = false;
6090 ASTOwningVector<&ActionBase::DeleteExpr> SubExprs(SemaRef);
6091 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) {
6092 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExpr(I));
6093 if (SubExpr.isInvalid())
6094 return SemaRef.ExprError();
6096 ArgumentChanged = ArgumentChanged || SubExpr.get() != E->getExpr(I);
6097 SubExprs.push_back(SubExpr.takeAs<Expr>());
6100 if (!getDerived().AlwaysRebuild() &&
6102 return SemaRef.Owned(E->Retain());
6104 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(),
6109 template<typename Derived>
6110 Sema::OwningExprResult
6111 TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) {
6112 // FIXME: Implement this!
6113 assert(false && "Cannot transform block expressions yet");
6114 return SemaRef.Owned(E->Retain());
6117 template<typename Derived>
6118 Sema::OwningExprResult
6119 TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E) {
6120 // FIXME: Implement this!
6121 assert(false && "Cannot transform block-related expressions yet");
6122 return SemaRef.Owned(E->Retain());
6125 //===----------------------------------------------------------------------===//
6126 // Type reconstruction
6127 //===----------------------------------------------------------------------===//
6129 template<typename Derived>
6130 QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType,
6131 SourceLocation Star) {
6132 return SemaRef.BuildPointerType(PointeeType, Qualifiers(), Star,
6133 getDerived().getBaseEntity());
6136 template<typename Derived>
6137 QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType,
6138 SourceLocation Star) {
6139 return SemaRef.BuildBlockPointerType(PointeeType, Qualifiers(), Star,
6140 getDerived().getBaseEntity());
6143 template<typename Derived>
6145 TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType,
6146 bool WrittenAsLValue,
6147 SourceLocation Sigil) {
6148 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, Qualifiers(),
6149 Sigil, getDerived().getBaseEntity());
6152 template<typename Derived>
6154 TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType,
6156 SourceLocation Sigil) {
6157 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Qualifiers(),
6158 Sigil, getDerived().getBaseEntity());
6161 template<typename Derived>
6163 TreeTransform<Derived>::RebuildArrayType(QualType ElementType,
6164 ArrayType::ArraySizeModifier SizeMod,
6165 const llvm::APInt *Size,
6167 unsigned IndexTypeQuals,
6168 SourceRange BracketsRange) {
6169 if (SizeExpr || !Size)
6170 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr,
6171 IndexTypeQuals, BracketsRange,
6172 getDerived().getBaseEntity());
6174 QualType Types[] = {
6175 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy,
6176 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy,
6177 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty
6179 const unsigned NumTypes = sizeof(Types) / sizeof(QualType);
6181 for (unsigned I = 0; I != NumTypes; ++I)
6182 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) {
6183 SizeType = Types[I];
6187 IntegerLiteral ArraySize(*Size, SizeType, /*FIXME*/BracketsRange.getBegin());
6188 return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize,
6189 IndexTypeQuals, BracketsRange,
6190 getDerived().getBaseEntity());
6193 template<typename Derived>
6195 TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType,
6196 ArrayType::ArraySizeModifier SizeMod,
6197 const llvm::APInt &Size,
6198 unsigned IndexTypeQuals,
6199 SourceRange BracketsRange) {
6200 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0,
6201 IndexTypeQuals, BracketsRange);
6204 template<typename Derived>
6206 TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType,
6207 ArrayType::ArraySizeModifier SizeMod,
6208 unsigned IndexTypeQuals,
6209 SourceRange BracketsRange) {
6210 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0,
6211 IndexTypeQuals, BracketsRange);
6214 template<typename Derived>
6216 TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType,
6217 ArrayType::ArraySizeModifier SizeMod,
6219 unsigned IndexTypeQuals,
6220 SourceRange BracketsRange) {
6221 return getDerived().RebuildArrayType(ElementType, SizeMod, 0,
6222 SizeExpr.takeAs<Expr>(),
6223 IndexTypeQuals, BracketsRange);
6226 template<typename Derived>
6228 TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType,
6229 ArrayType::ArraySizeModifier SizeMod,
6231 unsigned IndexTypeQuals,
6232 SourceRange BracketsRange) {
6233 return getDerived().RebuildArrayType(ElementType, SizeMod, 0,
6234 SizeExpr.takeAs<Expr>(),
6235 IndexTypeQuals, BracketsRange);
6238 template<typename Derived>
6239 QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType,
6240 unsigned NumElements,
6241 bool IsAltiVec, bool IsPixel) {
6242 // FIXME: semantic checking!
6243 return SemaRef.Context.getVectorType(ElementType, NumElements,
6244 IsAltiVec, IsPixel);
6247 template<typename Derived>
6248 QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType,
6249 unsigned NumElements,
6250 SourceLocation AttributeLoc) {
6251 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
6253 IntegerLiteral *VectorSize
6254 = new (SemaRef.Context) IntegerLiteral(numElements, SemaRef.Context.IntTy,
6256 return SemaRef.BuildExtVectorType(ElementType, SemaRef.Owned(VectorSize),
6260 template<typename Derived>
6262 TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType,
6264 SourceLocation AttributeLoc) {
6265 return SemaRef.BuildExtVectorType(ElementType, move(SizeExpr), AttributeLoc);
6268 template<typename Derived>
6269 QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T,
6270 QualType *ParamTypes,
6271 unsigned NumParamTypes,
6274 return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic,
6276 getDerived().getBaseLocation(),
6277 getDerived().getBaseEntity());
6280 template<typename Derived>
6281 QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) {
6282 return SemaRef.Context.getFunctionNoProtoType(T);
6285 template<typename Derived>
6286 QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(Decl *D) {
6287 assert(D && "no decl found");
6288 if (D->isInvalidDecl()) return QualType();
6290 // FIXME: Doesn't account for ObjCInterfaceDecl!
6292 if (isa<UsingDecl>(D)) {
6293 UsingDecl *Using = cast<UsingDecl>(D);
6294 assert(Using->isTypeName() &&
6295 "UnresolvedUsingTypenameDecl transformed to non-typename using");
6297 // A valid resolved using typename decl points to exactly one type decl.
6298 assert(++Using->shadow_begin() == Using->shadow_end());
6299 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl());
6302 assert(isa<UnresolvedUsingTypenameDecl>(D) &&
6303 "UnresolvedUsingTypenameDecl transformed to non-using decl");
6304 Ty = cast<UnresolvedUsingTypenameDecl>(D);
6307 return SemaRef.Context.getTypeDeclType(Ty);
6310 template<typename Derived>
6311 QualType TreeTransform<Derived>::RebuildTypeOfExprType(ExprArg E) {
6312 return SemaRef.BuildTypeofExprType(E.takeAs<Expr>());
6315 template<typename Derived>
6316 QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) {
6317 return SemaRef.Context.getTypeOfType(Underlying);
6320 template<typename Derived>
6321 QualType TreeTransform<Derived>::RebuildDecltypeType(ExprArg E) {
6322 return SemaRef.BuildDecltypeType(E.takeAs<Expr>());
6325 template<typename Derived>
6326 QualType TreeTransform<Derived>::RebuildTemplateSpecializationType(
6327 TemplateName Template,
6328 SourceLocation TemplateNameLoc,
6329 const TemplateArgumentListInfo &TemplateArgs) {
6330 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
6333 template<typename Derived>
6334 NestedNameSpecifier *
6335 TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
6338 QualType ObjectType,
6339 NamedDecl *FirstQualifierInScope) {
6341 // FIXME: The source location information is all wrong.
6343 SS.setScopeRep(Prefix);
6344 return static_cast<NestedNameSpecifier *>(
6345 SemaRef.BuildCXXNestedNameSpecifier(0, SS, Range.getEnd(),
6348 FirstQualifierInScope,
6352 template<typename Derived>
6353 NestedNameSpecifier *
6354 TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
6356 NamespaceDecl *NS) {
6357 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, NS);
6360 template<typename Derived>
6361 NestedNameSpecifier *
6362 TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix,
6366 if (T->isDependentType() || T->isRecordType() ||
6367 (SemaRef.getLangOptions().CPlusPlus0x && T->isEnumeralType())) {
6368 assert(!T.hasLocalQualifiers() && "Can't get cv-qualifiers here");
6369 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, TemplateKW,
6373 SemaRef.Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T;
6377 template<typename Derived>
6379 TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier,
6381 TemplateDecl *Template) {
6382 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW,
6386 template<typename Derived>
6388 TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier,
6389 const IdentifierInfo &II,
6390 QualType ObjectType) {
6392 SS.setRange(SourceRange(getDerived().getBaseLocation()));
6393 SS.setScopeRep(Qualifier);
6395 Name.setIdentifier(&II, /*FIXME:*/getDerived().getBaseLocation());
6396 return getSema().ActOnDependentTemplateName(
6397 /*FIXME:*/getDerived().getBaseLocation(),
6400 ObjectType.getAsOpaquePtr(),
6401 /*EnteringContext=*/false)
6402 .template getAsVal<TemplateName>();
6405 template<typename Derived>
6407 TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier,
6408 OverloadedOperatorKind Operator,
6409 QualType ObjectType) {
6411 SS.setRange(SourceRange(getDerived().getBaseLocation()));
6412 SS.setScopeRep(Qualifier);
6414 SourceLocation SymbolLocations[3]; // FIXME: Bogus location information.
6415 Name.setOperatorFunctionId(/*FIXME:*/getDerived().getBaseLocation(),
6416 Operator, SymbolLocations);
6417 return getSema().ActOnDependentTemplateName(
6418 /*FIXME:*/getDerived().getBaseLocation(),
6421 ObjectType.getAsOpaquePtr(),
6422 /*EnteringContext=*/false)
6423 .template getAsVal<TemplateName>();
6426 template<typename Derived>
6427 Sema::OwningExprResult
6428 TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
6429 SourceLocation OpLoc,
6433 Expr *FirstExpr = (Expr *)First.get();
6434 Expr *SecondExpr = (Expr *)Second.get();
6435 Expr *CalleeExpr = ((Expr *)Callee.get())->IgnoreParenCasts();
6436 bool isPostIncDec = SecondExpr && (Op == OO_PlusPlus || Op == OO_MinusMinus);
6438 // Determine whether this should be a builtin operation.
6439 if (Op == OO_Subscript) {
6440 if (!FirstExpr->getType()->isOverloadableType() &&
6441 !SecondExpr->getType()->isOverloadableType())
6442 return getSema().CreateBuiltinArraySubscriptExpr(move(First),
6443 CalleeExpr->getLocStart(),
6444 move(Second), OpLoc);
6445 } else if (Op == OO_Arrow) {
6446 // -> is never a builtin operation.
6447 return SemaRef.BuildOverloadedArrowExpr(0, move(First), OpLoc);
6448 } else if (SecondExpr == 0 || isPostIncDec) {
6449 if (!FirstExpr->getType()->isOverloadableType()) {
6450 // The argument is not of overloadable type, so try to create a
6451 // built-in unary operation.
6452 UnaryOperator::Opcode Opc
6453 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
6455 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, move(First));
6458 if (!FirstExpr->getType()->isOverloadableType() &&
6459 !SecondExpr->getType()->isOverloadableType()) {
6460 // Neither of the arguments is an overloadable type, so try to
6461 // create a built-in binary operation.
6462 BinaryOperator::Opcode Opc = BinaryOperator::getOverloadedOpcode(Op);
6463 OwningExprResult Result
6464 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, FirstExpr, SecondExpr);
6465 if (Result.isInvalid())
6466 return SemaRef.ExprError();
6470 return move(Result);
6474 // Compute the transformed set of functions (and function templates) to be
6475 // used during overload resolution.
6476 UnresolvedSet<16> Functions;
6478 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(CalleeExpr)) {
6479 assert(ULE->requiresADL());
6481 // FIXME: Do we have to check
6482 // IsAcceptableNonMemberOperatorCandidate for each of these?
6483 Functions.append(ULE->decls_begin(), ULE->decls_end());
6485 Functions.addDecl(cast<DeclRefExpr>(CalleeExpr)->getDecl());
6488 // Add any functions found via argument-dependent lookup.
6489 Expr *Args[2] = { FirstExpr, SecondExpr };
6490 unsigned NumArgs = 1 + (SecondExpr != 0);
6492 // Create the overloaded operator invocation for unary operators.
6493 if (NumArgs == 1 || isPostIncDec) {
6494 UnaryOperator::Opcode Opc
6495 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
6496 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(First));
6499 if (Op == OO_Subscript)
6500 return SemaRef.CreateOverloadedArraySubscriptExpr(CalleeExpr->getLocStart(),
6505 // Create the overloaded operator invocation for binary operators.
6506 BinaryOperator::Opcode Opc =
6507 BinaryOperator::getOverloadedOpcode(Op);
6508 OwningExprResult Result
6509 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]);
6510 if (Result.isInvalid())
6511 return SemaRef.ExprError();
6515 return move(Result);
6518 template<typename Derived>
6519 Sema::OwningExprResult
6520 TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(ExprArg Base,
6521 SourceLocation OperatorLoc,
6523 NestedNameSpecifier *Qualifier,
6524 SourceRange QualifierRange,
6525 TypeSourceInfo *ScopeType,
6526 SourceLocation CCLoc,
6527 SourceLocation TildeLoc,
6528 PseudoDestructorTypeStorage Destroyed) {
6531 SS.setRange(QualifierRange);
6532 SS.setScopeRep(Qualifier);
6535 Expr *BaseE = (Expr *)Base.get();
6536 QualType BaseType = BaseE->getType();
6537 if (BaseE->isTypeDependent() || Destroyed.getIdentifier() ||
6538 (!isArrow && !BaseType->getAs<RecordType>()) ||
6539 (isArrow && BaseType->getAs<PointerType>() &&
6540 !BaseType->getAs<PointerType>()->getPointeeType()
6541 ->template getAs<RecordType>())){
6542 // This pseudo-destructor expression is still a pseudo-destructor.
6543 return SemaRef.BuildPseudoDestructorExpr(move(Base), OperatorLoc,
6544 isArrow? tok::arrow : tok::period,
6545 SS, ScopeType, CCLoc, TildeLoc,
6550 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo();
6551 DeclarationName Name
6552 = SemaRef.Context.DeclarationNames.getCXXDestructorName(
6553 SemaRef.Context.getCanonicalType(DestroyedType->getType()));
6555 // FIXME: the ScopeType should be tacked onto SS.
6557 return getSema().BuildMemberReferenceExpr(move(Base), BaseType,
6558 OperatorLoc, isArrow,
6559 SS, /*FIXME: FirstQualifier*/ 0,
6560 Name, Destroyed.getLocation(),
6561 /*TemplateArgs*/ 0);
6564 } // end namespace clang
6566 #endif // LLVM_CLANG_SEMA_TREETRANSFORM_H