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 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
15 #define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
17 #include "TypeLocBuilder.h"
18 #include "clang/AST/Decl.h"
19 #include "clang/AST/DeclObjC.h"
20 #include "clang/AST/DeclTemplate.h"
21 #include "clang/AST/Expr.h"
22 #include "clang/AST/ExprCXX.h"
23 #include "clang/AST/ExprObjC.h"
24 #include "clang/AST/ExprOpenMP.h"
25 #include "clang/AST/Stmt.h"
26 #include "clang/AST/StmtCXX.h"
27 #include "clang/AST/StmtObjC.h"
28 #include "clang/AST/StmtOpenMP.h"
29 #include "clang/Sema/Designator.h"
30 #include "clang/Sema/Lookup.h"
31 #include "clang/Sema/Ownership.h"
32 #include "clang/Sema/ParsedTemplate.h"
33 #include "clang/Sema/ScopeInfo.h"
34 #include "clang/Sema/SemaDiagnostic.h"
35 #include "clang/Sema/SemaInternal.h"
36 #include "llvm/ADT/ArrayRef.h"
37 #include "llvm/Support/ErrorHandling.h"
43 /// \brief A semantic tree transformation that allows one to transform one
44 /// abstract syntax tree into another.
46 /// A new tree transformation is defined by creating a new subclass \c X of
47 /// \c TreeTransform<X> and then overriding certain operations to provide
48 /// behavior specific to that transformation. For example, template
49 /// instantiation is implemented as a tree transformation where the
50 /// transformation of TemplateTypeParmType nodes involves substituting the
51 /// template arguments for their corresponding template parameters; a similar
52 /// transformation is performed for non-type template parameters and
53 /// template template parameters.
55 /// This tree-transformation template uses static polymorphism to allow
56 /// subclasses to customize any of its operations. Thus, a subclass can
57 /// override any of the transformation or rebuild operators by providing an
58 /// operation with the same signature as the default implementation. The
59 /// overridding function should not be virtual.
61 /// Semantic tree transformations are split into two stages, either of which
62 /// can be replaced by a subclass. The "transform" step transforms an AST node
63 /// or the parts of an AST node using the various transformation functions,
64 /// then passes the pieces on to the "rebuild" step, which constructs a new AST
65 /// node of the appropriate kind from the pieces. The default transformation
66 /// routines recursively transform the operands to composite AST nodes (e.g.,
67 /// the pointee type of a PointerType node) and, if any of those operand nodes
68 /// were changed by the transformation, invokes the rebuild operation to create
71 /// Subclasses can customize the transformation at various levels. The
72 /// most coarse-grained transformations involve replacing TransformType(),
73 /// TransformExpr(), TransformDecl(), TransformNestedNameSpecifierLoc(),
74 /// TransformTemplateName(), or TransformTemplateArgument() with entirely
75 /// new implementations.
77 /// For more fine-grained transformations, subclasses can replace any of the
78 /// \c TransformXXX functions (where XXX is the name of an AST node, e.g.,
79 /// PointerType, StmtExpr) to alter the transformation. As mentioned previously,
80 /// replacing TransformTemplateTypeParmType() allows template instantiation
81 /// to substitute template arguments for their corresponding template
82 /// parameters. Additionally, subclasses can override the \c RebuildXXX
83 /// functions to control how AST nodes are rebuilt when their operands change.
84 /// By default, \c TreeTransform will invoke semantic analysis to rebuild
85 /// AST nodes. However, certain other tree transformations (e.g, cloning) may
86 /// be able to use more efficient rebuild steps.
88 /// There are a handful of other functions that can be overridden, allowing one
89 /// to avoid traversing nodes that don't need any transformation
90 /// (\c AlreadyTransformed()), force rebuilding AST nodes even when their
91 /// operands have not changed (\c AlwaysRebuild()), and customize the
92 /// default locations and entity names used for type-checking
93 /// (\c getBaseLocation(), \c getBaseEntity()).
94 template<typename Derived>
96 /// \brief Private RAII object that helps us forget and then re-remember
97 /// the template argument corresponding to a partially-substituted parameter
99 class ForgetPartiallySubstitutedPackRAII {
101 TemplateArgument Old;
104 ForgetPartiallySubstitutedPackRAII(Derived &Self) : Self(Self) {
105 Old = Self.ForgetPartiallySubstitutedPack();
108 ~ForgetPartiallySubstitutedPackRAII() {
109 Self.RememberPartiallySubstitutedPack(Old);
116 /// \brief The set of local declarations that have been transformed, for
117 /// cases where we are forced to build new declarations within the transformer
118 /// rather than in the subclass (e.g., lambda closure types).
119 llvm::DenseMap<Decl *, Decl *> TransformedLocalDecls;
122 /// \brief Initializes a new tree transformer.
123 TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { }
125 /// \brief Retrieves a reference to the derived class.
126 Derived &getDerived() { return static_cast<Derived&>(*this); }
128 /// \brief Retrieves a reference to the derived class.
129 const Derived &getDerived() const {
130 return static_cast<const Derived&>(*this);
133 static inline ExprResult Owned(Expr *E) { return E; }
134 static inline StmtResult Owned(Stmt *S) { return S; }
136 /// \brief Retrieves a reference to the semantic analysis object used for
137 /// this tree transform.
138 Sema &getSema() const { return SemaRef; }
140 /// \brief Whether the transformation should always rebuild AST nodes, even
141 /// if none of the children have changed.
143 /// Subclasses may override this function to specify when the transformation
144 /// should rebuild all AST nodes.
146 /// We must always rebuild all AST nodes when performing variadic template
147 /// pack expansion, in order to avoid violating the AST invariant that each
148 /// statement node appears at most once in its containing declaration.
149 bool AlwaysRebuild() { return SemaRef.ArgumentPackSubstitutionIndex != -1; }
151 /// \brief Returns the location of the entity being transformed, if that
152 /// information was not available elsewhere in the AST.
154 /// By default, returns no source-location information. Subclasses can
155 /// provide an alternative implementation that provides better location
157 SourceLocation getBaseLocation() { return SourceLocation(); }
159 /// \brief Returns the name of the entity being transformed, if that
160 /// information was not available elsewhere in the AST.
162 /// By default, returns an empty name. Subclasses can provide an alternative
163 /// implementation with a more precise name.
164 DeclarationName getBaseEntity() { return DeclarationName(); }
166 /// \brief Sets the "base" location and entity when that
167 /// information is known based on another transformation.
169 /// By default, the source location and entity are ignored. Subclasses can
170 /// override this function to provide a customized implementation.
171 void setBase(SourceLocation Loc, DeclarationName Entity) { }
173 /// \brief RAII object that temporarily sets the base location and entity
174 /// used for reporting diagnostics in types.
175 class TemporaryBase {
177 SourceLocation OldLocation;
178 DeclarationName OldEntity;
181 TemporaryBase(TreeTransform &Self, SourceLocation Location,
182 DeclarationName Entity) : Self(Self) {
183 OldLocation = Self.getDerived().getBaseLocation();
184 OldEntity = Self.getDerived().getBaseEntity();
186 if (Location.isValid())
187 Self.getDerived().setBase(Location, Entity);
191 Self.getDerived().setBase(OldLocation, OldEntity);
195 /// \brief Determine whether the given type \p T has already been
198 /// Subclasses can provide an alternative implementation of this routine
199 /// to short-circuit evaluation when it is known that a given type will
200 /// not change. For example, template instantiation need not traverse
201 /// non-dependent types.
202 bool AlreadyTransformed(QualType T) {
206 /// \brief Determine whether the given call argument should be dropped, e.g.,
207 /// because it is a default argument.
209 /// Subclasses can provide an alternative implementation of this routine to
210 /// determine which kinds of call arguments get dropped. By default,
211 /// CXXDefaultArgument nodes are dropped (prior to transformation).
212 bool DropCallArgument(Expr *E) {
213 return E->isDefaultArgument();
216 /// \brief Determine whether we should expand a pack expansion with the
217 /// given set of parameter packs into separate arguments by repeatedly
218 /// transforming the pattern.
220 /// By default, the transformer never tries to expand pack expansions.
221 /// Subclasses can override this routine to provide different behavior.
223 /// \param EllipsisLoc The location of the ellipsis that identifies the
226 /// \param PatternRange The source range that covers the entire pattern of
227 /// the pack expansion.
229 /// \param Unexpanded The set of unexpanded parameter packs within the
232 /// \param ShouldExpand Will be set to \c true if the transformer should
233 /// expand the corresponding pack expansions into separate arguments. When
234 /// set, \c NumExpansions must also be set.
236 /// \param RetainExpansion Whether the caller should add an unexpanded
237 /// pack expansion after all of the expanded arguments. This is used
238 /// when extending explicitly-specified template argument packs per
239 /// C++0x [temp.arg.explicit]p9.
241 /// \param NumExpansions The number of separate arguments that will be in
242 /// the expanded form of the corresponding pack expansion. This is both an
243 /// input and an output parameter, which can be set by the caller if the
244 /// number of expansions is known a priori (e.g., due to a prior substitution)
245 /// and will be set by the callee when the number of expansions is known.
246 /// The callee must set this value when \c ShouldExpand is \c true; it may
247 /// set this value in other cases.
249 /// \returns true if an error occurred (e.g., because the parameter packs
250 /// are to be instantiated with arguments of different lengths), false
251 /// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions)
253 bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
254 SourceRange PatternRange,
255 ArrayRef<UnexpandedParameterPack> Unexpanded,
257 bool &RetainExpansion,
258 Optional<unsigned> &NumExpansions) {
259 ShouldExpand = false;
263 /// \brief "Forget" about the partially-substituted pack template argument,
264 /// when performing an instantiation that must preserve the parameter pack
267 /// This routine is meant to be overridden by the template instantiator.
268 TemplateArgument ForgetPartiallySubstitutedPack() {
269 return TemplateArgument();
272 /// \brief "Remember" the partially-substituted pack template argument
273 /// after performing an instantiation that must preserve the parameter pack
276 /// This routine is meant to be overridden by the template instantiator.
277 void RememberPartiallySubstitutedPack(TemplateArgument Arg) { }
279 /// \brief Note to the derived class when a function parameter pack is
281 void ExpandingFunctionParameterPack(ParmVarDecl *Pack) { }
283 /// \brief Transforms the given type into another type.
285 /// By default, this routine transforms a type by creating a
286 /// TypeSourceInfo for it and delegating to the appropriate
287 /// function. This is expensive, but we don't mind, because
288 /// this method is deprecated anyway; all users should be
289 /// switched to storing TypeSourceInfos.
291 /// \returns the transformed type.
292 QualType TransformType(QualType T);
294 /// \brief Transforms the given type-with-location into a new
295 /// type-with-location.
297 /// By default, this routine transforms a type by delegating to the
298 /// appropriate TransformXXXType to build a new type. Subclasses
299 /// may override this function (to take over all type
300 /// transformations) or some set of the TransformXXXType functions
301 /// to alter the transformation.
302 TypeSourceInfo *TransformType(TypeSourceInfo *DI);
304 /// \brief Transform the given type-with-location into a new
305 /// type, collecting location information in the given builder
308 QualType TransformType(TypeLocBuilder &TLB, TypeLoc TL);
310 /// \brief Transform the given statement.
312 /// By default, this routine transforms a statement by delegating to the
313 /// appropriate TransformXXXStmt function to transform a specific kind of
314 /// statement or the TransformExpr() function to transform an expression.
315 /// Subclasses may override this function to transform statements using some
318 /// \returns the transformed statement.
319 StmtResult TransformStmt(Stmt *S);
321 /// \brief Transform the given statement.
323 /// By default, this routine transforms a statement by delegating to the
324 /// appropriate TransformOMPXXXClause function to transform a specific kind
325 /// of clause. Subclasses may override this function to transform statements
326 /// using some other mechanism.
328 /// \returns the transformed OpenMP clause.
329 OMPClause *TransformOMPClause(OMPClause *S);
331 /// \brief Transform the given attribute.
333 /// By default, this routine transforms a statement by delegating to the
334 /// appropriate TransformXXXAttr function to transform a specific kind
335 /// of attribute. Subclasses may override this function to transform
336 /// attributed statements using some other mechanism.
338 /// \returns the transformed attribute
339 const Attr *TransformAttr(const Attr *S);
341 /// \brief Transform the specified attribute.
343 /// Subclasses should override the transformation of attributes with a pragma
344 /// spelling to transform expressions stored within the attribute.
346 /// \returns the transformed attribute.
348 #define PRAGMA_SPELLING_ATTR(X) \
349 const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; }
350 #include "clang/Basic/AttrList.inc"
352 /// \brief Transform the given expression.
354 /// By default, this routine transforms an expression by delegating to the
355 /// appropriate TransformXXXExpr function to build a new expression.
356 /// Subclasses may override this function to transform expressions using some
359 /// \returns the transformed expression.
360 ExprResult TransformExpr(Expr *E);
362 /// \brief Transform the given initializer.
364 /// By default, this routine transforms an initializer by stripping off the
365 /// semantic nodes added by initialization, then passing the result to
366 /// TransformExpr or TransformExprs.
368 /// \returns the transformed initializer.
369 ExprResult TransformInitializer(Expr *Init, bool NotCopyInit);
371 /// \brief Transform the given list of expressions.
373 /// This routine transforms a list of expressions by invoking
374 /// \c TransformExpr() for each subexpression. However, it also provides
375 /// support for variadic templates by expanding any pack expansions (if the
376 /// derived class permits such expansion) along the way. When pack expansions
377 /// are present, the number of outputs may not equal the number of inputs.
379 /// \param Inputs The set of expressions to be transformed.
381 /// \param NumInputs The number of expressions in \c Inputs.
383 /// \param IsCall If \c true, then this transform is being performed on
384 /// function-call arguments, and any arguments that should be dropped, will
387 /// \param Outputs The transformed input expressions will be added to this
390 /// \param ArgChanged If non-NULL, will be set \c true if any argument changed
391 /// due to transformation.
393 /// \returns true if an error occurred, false otherwise.
394 bool TransformExprs(Expr *const *Inputs, unsigned NumInputs, bool IsCall,
395 SmallVectorImpl<Expr *> &Outputs,
396 bool *ArgChanged = nullptr);
398 /// \brief Transform the given declaration, which is referenced from a type
401 /// By default, acts as the identity function on declarations, unless the
402 /// transformer has had to transform the declaration itself. Subclasses
403 /// may override this function to provide alternate behavior.
404 Decl *TransformDecl(SourceLocation Loc, Decl *D) {
405 llvm::DenseMap<Decl *, Decl *>::iterator Known
406 = TransformedLocalDecls.find(D);
407 if (Known != TransformedLocalDecls.end())
408 return Known->second;
413 /// \brief Transform the attributes associated with the given declaration and
414 /// place them on the new declaration.
416 /// By default, this operation does nothing. Subclasses may override this
417 /// behavior to transform attributes.
418 void transformAttrs(Decl *Old, Decl *New) { }
420 /// \brief Note that a local declaration has been transformed by this
423 /// Local declarations are typically transformed via a call to
424 /// TransformDefinition. However, in some cases (e.g., lambda expressions),
425 /// the transformer itself has to transform the declarations. This routine
426 /// can be overridden by a subclass that keeps track of such mappings.
427 void transformedLocalDecl(Decl *Old, Decl *New) {
428 TransformedLocalDecls[Old] = New;
431 /// \brief Transform the definition of the given declaration.
433 /// By default, invokes TransformDecl() to transform the declaration.
434 /// Subclasses may override this function to provide alternate behavior.
435 Decl *TransformDefinition(SourceLocation Loc, Decl *D) {
436 return getDerived().TransformDecl(Loc, D);
439 /// \brief Transform the given declaration, which was the first part of a
440 /// nested-name-specifier in a member access expression.
442 /// This specific declaration transformation only applies to the first
443 /// identifier in a nested-name-specifier of a member access expression, e.g.,
444 /// the \c T in \c x->T::member
446 /// By default, invokes TransformDecl() to transform the declaration.
447 /// Subclasses may override this function to provide alternate behavior.
448 NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc) {
449 return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D));
452 /// \brief Transform the given nested-name-specifier with source-location
455 /// By default, transforms all of the types and declarations within the
456 /// nested-name-specifier. Subclasses may override this function to provide
457 /// alternate behavior.
458 NestedNameSpecifierLoc
459 TransformNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
460 QualType ObjectType = QualType(),
461 NamedDecl *FirstQualifierInScope = nullptr);
463 /// \brief Transform the given declaration name.
465 /// By default, transforms the types of conversion function, constructor,
466 /// and destructor names and then (if needed) rebuilds the declaration name.
467 /// Identifiers and selectors are returned unmodified. Sublcasses may
468 /// override this function to provide alternate behavior.
470 TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo);
472 /// \brief Transform the given template name.
474 /// \param SS The nested-name-specifier that qualifies the template
475 /// name. This nested-name-specifier must already have been transformed.
477 /// \param Name The template name to transform.
479 /// \param NameLoc The source location of the template name.
481 /// \param ObjectType If we're translating a template name within a member
482 /// access expression, this is the type of the object whose member template
483 /// is being referenced.
485 /// \param FirstQualifierInScope If the first part of a nested-name-specifier
486 /// also refers to a name within the current (lexical) scope, this is the
487 /// declaration it refers to.
489 /// By default, transforms the template name by transforming the declarations
490 /// and nested-name-specifiers that occur within the template name.
491 /// Subclasses may override this function to provide alternate behavior.
493 TransformTemplateName(CXXScopeSpec &SS, TemplateName Name,
494 SourceLocation NameLoc,
495 QualType ObjectType = QualType(),
496 NamedDecl *FirstQualifierInScope = nullptr);
498 /// \brief Transform the given template argument.
500 /// By default, this operation transforms the type, expression, or
501 /// declaration stored within the template argument and constructs a
502 /// new template argument from the transformed result. Subclasses may
503 /// override this function to provide alternate behavior.
505 /// Returns true if there was an error.
506 bool TransformTemplateArgument(const TemplateArgumentLoc &Input,
507 TemplateArgumentLoc &Output,
508 bool Uneval = false);
510 /// \brief Transform the given set of template arguments.
512 /// By default, this operation transforms all of the template arguments
513 /// in the input set using \c TransformTemplateArgument(), and appends
514 /// the transformed arguments to the output list.
516 /// Note that this overload of \c TransformTemplateArguments() is merely
517 /// a convenience function. Subclasses that wish to override this behavior
518 /// should override the iterator-based member template version.
520 /// \param Inputs The set of template arguments to be transformed.
522 /// \param NumInputs The number of template arguments in \p Inputs.
524 /// \param Outputs The set of transformed template arguments output by this
527 /// Returns true if an error occurred.
528 bool TransformTemplateArguments(const TemplateArgumentLoc *Inputs,
530 TemplateArgumentListInfo &Outputs,
531 bool Uneval = false) {
532 return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs,
536 /// \brief Transform the given set of template arguments.
538 /// By default, this operation transforms all of the template arguments
539 /// in the input set using \c TransformTemplateArgument(), and appends
540 /// the transformed arguments to the output list.
542 /// \param First An iterator to the first template argument.
544 /// \param Last An iterator one step past the last template argument.
546 /// \param Outputs The set of transformed template arguments output by this
549 /// Returns true if an error occurred.
550 template<typename InputIterator>
551 bool TransformTemplateArguments(InputIterator First,
553 TemplateArgumentListInfo &Outputs,
554 bool Uneval = false);
556 /// \brief Fakes up a TemplateArgumentLoc for a given TemplateArgument.
557 void InventTemplateArgumentLoc(const TemplateArgument &Arg,
558 TemplateArgumentLoc &ArgLoc);
560 /// \brief Fakes up a TypeSourceInfo for a type.
561 TypeSourceInfo *InventTypeSourceInfo(QualType T) {
562 return SemaRef.Context.getTrivialTypeSourceInfo(T,
563 getDerived().getBaseLocation());
566 #define ABSTRACT_TYPELOC(CLASS, PARENT)
567 #define TYPELOC(CLASS, PARENT) \
568 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
569 #include "clang/AST/TypeLocNodes.def"
571 template<typename Fn>
572 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
573 FunctionProtoTypeLoc TL,
574 CXXRecordDecl *ThisContext,
575 unsigned ThisTypeQuals,
576 Fn TransformExceptionSpec);
578 bool TransformExceptionSpec(SourceLocation Loc,
579 FunctionProtoType::ExceptionSpecInfo &ESI,
580 SmallVectorImpl<QualType> &Exceptions,
583 StmtResult TransformSEHHandler(Stmt *Handler);
586 TransformTemplateSpecializationType(TypeLocBuilder &TLB,
587 TemplateSpecializationTypeLoc TL,
588 TemplateName Template);
591 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
592 DependentTemplateSpecializationTypeLoc TL,
593 TemplateName Template,
596 QualType TransformDependentTemplateSpecializationType(
597 TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
598 NestedNameSpecifierLoc QualifierLoc);
600 /// \brief Transforms the parameters of a function type into the
603 /// The result vectors should be kept in sync; null entries in the
604 /// variables vector are acceptable.
606 /// Return true on error.
607 bool TransformFunctionTypeParams(SourceLocation Loc,
608 ParmVarDecl **Params, unsigned NumParams,
609 const QualType *ParamTypes,
610 SmallVectorImpl<QualType> &PTypes,
611 SmallVectorImpl<ParmVarDecl*> *PVars);
613 /// \brief Transforms a single function-type parameter. Return null
616 /// \param indexAdjustment - A number to add to the parameter's
617 /// scope index; can be negative
618 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
620 Optional<unsigned> NumExpansions,
621 bool ExpectParameterPack);
623 QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);
625 StmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr);
626 ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *E);
628 TemplateParameterList *TransformTemplateParameterList(
629 TemplateParameterList *TPL) {
633 ExprResult TransformAddressOfOperand(Expr *E);
635 ExprResult TransformDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E,
636 bool IsAddressOfOperand,
637 TypeSourceInfo **RecoveryTSI);
639 ExprResult TransformParenDependentScopeDeclRefExpr(
640 ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool IsAddressOfOperand,
641 TypeSourceInfo **RecoveryTSI);
643 StmtResult TransformOMPExecutableDirective(OMPExecutableDirective *S);
645 // FIXME: We use LLVM_ATTRIBUTE_NOINLINE because inlining causes a ridiculous
646 // amount of stack usage with clang.
647 #define STMT(Node, Parent) \
648 LLVM_ATTRIBUTE_NOINLINE \
649 StmtResult Transform##Node(Node *S);
650 #define EXPR(Node, Parent) \
651 LLVM_ATTRIBUTE_NOINLINE \
652 ExprResult Transform##Node(Node *E);
653 #define ABSTRACT_STMT(Stmt)
654 #include "clang/AST/StmtNodes.inc"
656 #define OPENMP_CLAUSE(Name, Class) \
657 LLVM_ATTRIBUTE_NOINLINE \
658 OMPClause *Transform ## Class(Class *S);
659 #include "clang/Basic/OpenMPKinds.def"
661 /// \brief Build a new pointer type given its pointee type.
663 /// By default, performs semantic analysis when building the pointer type.
664 /// Subclasses may override this routine to provide different behavior.
665 QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);
667 /// \brief Build a new block pointer type given its pointee type.
669 /// By default, performs semantic analysis when building the block pointer
670 /// type. Subclasses may override this routine to provide different behavior.
671 QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);
673 /// \brief Build a new reference type given the type it references.
675 /// By default, performs semantic analysis when building the
676 /// reference type. Subclasses may override this routine to provide
677 /// different behavior.
679 /// \param LValue whether the type was written with an lvalue sigil
680 /// or an rvalue sigil.
681 QualType RebuildReferenceType(QualType ReferentType,
683 SourceLocation Sigil);
685 /// \brief Build a new member pointer type given the pointee type and the
686 /// class type it refers into.
688 /// By default, performs semantic analysis when building the member pointer
689 /// type. Subclasses may override this routine to provide different behavior.
690 QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
691 SourceLocation Sigil);
693 /// \brief Build an Objective-C object type.
695 /// By default, performs semantic analysis when building the object type.
696 /// Subclasses may override this routine to provide different behavior.
697 QualType RebuildObjCObjectType(QualType BaseType,
699 SourceLocation TypeArgsLAngleLoc,
700 ArrayRef<TypeSourceInfo *> TypeArgs,
701 SourceLocation TypeArgsRAngleLoc,
702 SourceLocation ProtocolLAngleLoc,
703 ArrayRef<ObjCProtocolDecl *> Protocols,
704 ArrayRef<SourceLocation> ProtocolLocs,
705 SourceLocation ProtocolRAngleLoc);
707 /// \brief Build a new Objective-C object pointer type given the pointee type.
709 /// By default, directly builds the pointer type, with no additional semantic
711 QualType RebuildObjCObjectPointerType(QualType PointeeType,
712 SourceLocation Star);
714 /// \brief Build a new array type given the element type, size
715 /// modifier, size of the array (if known), size expression, and index type
718 /// By default, performs semantic analysis when building the array type.
719 /// Subclasses may override this routine to provide different behavior.
720 /// Also by default, all of the other Rebuild*Array
721 QualType RebuildArrayType(QualType ElementType,
722 ArrayType::ArraySizeModifier SizeMod,
723 const llvm::APInt *Size,
725 unsigned IndexTypeQuals,
726 SourceRange BracketsRange);
728 /// \brief Build a new constant array type given the element type, size
729 /// modifier, (known) size of the array, and index type qualifiers.
731 /// By default, performs semantic analysis when building the array type.
732 /// Subclasses may override this routine to provide different behavior.
733 QualType RebuildConstantArrayType(QualType ElementType,
734 ArrayType::ArraySizeModifier SizeMod,
735 const llvm::APInt &Size,
736 unsigned IndexTypeQuals,
737 SourceRange BracketsRange);
739 /// \brief Build a new incomplete array type given the element type, size
740 /// modifier, and index type qualifiers.
742 /// By default, performs semantic analysis when building the array type.
743 /// Subclasses may override this routine to provide different behavior.
744 QualType RebuildIncompleteArrayType(QualType ElementType,
745 ArrayType::ArraySizeModifier SizeMod,
746 unsigned IndexTypeQuals,
747 SourceRange BracketsRange);
749 /// \brief Build a new variable-length array type given the element type,
750 /// size modifier, size expression, and index type qualifiers.
752 /// By default, performs semantic analysis when building the array type.
753 /// Subclasses may override this routine to provide different behavior.
754 QualType RebuildVariableArrayType(QualType ElementType,
755 ArrayType::ArraySizeModifier SizeMod,
757 unsigned IndexTypeQuals,
758 SourceRange BracketsRange);
760 /// \brief Build a new dependent-sized array type given the element type,
761 /// size modifier, size expression, and index type qualifiers.
763 /// By default, performs semantic analysis when building the array type.
764 /// Subclasses may override this routine to provide different behavior.
765 QualType RebuildDependentSizedArrayType(QualType ElementType,
766 ArrayType::ArraySizeModifier SizeMod,
768 unsigned IndexTypeQuals,
769 SourceRange BracketsRange);
771 /// \brief Build a new vector type given the element type and
772 /// number of elements.
774 /// By default, performs semantic analysis when building the vector type.
775 /// Subclasses may override this routine to provide different behavior.
776 QualType RebuildVectorType(QualType ElementType, unsigned NumElements,
777 VectorType::VectorKind VecKind);
779 /// \brief Build a new extended vector type given the element type and
780 /// number of elements.
782 /// By default, performs semantic analysis when building the vector type.
783 /// Subclasses may override this routine to provide different behavior.
784 QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements,
785 SourceLocation AttributeLoc);
787 /// \brief Build a new potentially dependently-sized extended vector type
788 /// given the element type and number of elements.
790 /// By default, performs semantic analysis when building the vector type.
791 /// Subclasses may override this routine to provide different behavior.
792 QualType RebuildDependentSizedExtVectorType(QualType ElementType,
794 SourceLocation AttributeLoc);
796 /// \brief Build a new function type.
798 /// By default, performs semantic analysis when building the function type.
799 /// Subclasses may override this routine to provide different behavior.
800 QualType RebuildFunctionProtoType(QualType T,
801 MutableArrayRef<QualType> ParamTypes,
802 const FunctionProtoType::ExtProtoInfo &EPI);
804 /// \brief Build a new unprototyped function type.
805 QualType RebuildFunctionNoProtoType(QualType ResultType);
807 /// \brief Rebuild an unresolved typename type, given the decl that
808 /// the UnresolvedUsingTypenameDecl was transformed to.
809 QualType RebuildUnresolvedUsingType(Decl *D);
811 /// \brief Build a new typedef type.
812 QualType RebuildTypedefType(TypedefNameDecl *Typedef) {
813 return SemaRef.Context.getTypeDeclType(Typedef);
816 /// \brief Build a new class/struct/union type.
817 QualType RebuildRecordType(RecordDecl *Record) {
818 return SemaRef.Context.getTypeDeclType(Record);
821 /// \brief Build a new Enum type.
822 QualType RebuildEnumType(EnumDecl *Enum) {
823 return SemaRef.Context.getTypeDeclType(Enum);
826 /// \brief Build a new typeof(expr) type.
828 /// By default, performs semantic analysis when building the typeof type.
829 /// Subclasses may override this routine to provide different behavior.
830 QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc);
832 /// \brief Build a new typeof(type) type.
834 /// By default, builds a new TypeOfType with the given underlying type.
835 QualType RebuildTypeOfType(QualType Underlying);
837 /// \brief Build a new unary transform type.
838 QualType RebuildUnaryTransformType(QualType BaseType,
839 UnaryTransformType::UTTKind UKind,
842 /// \brief Build a new C++11 decltype type.
844 /// By default, performs semantic analysis when building the decltype type.
845 /// Subclasses may override this routine to provide different behavior.
846 QualType RebuildDecltypeType(Expr *Underlying, SourceLocation Loc);
848 /// \brief Build a new C++11 auto type.
850 /// By default, builds a new AutoType with the given deduced type.
851 QualType RebuildAutoType(QualType Deduced, AutoTypeKeyword Keyword) {
852 // Note, IsDependent is always false here: we implicitly convert an 'auto'
853 // which has been deduced to a dependent type into an undeduced 'auto', so
854 // that we'll retry deduction after the transformation.
855 return SemaRef.Context.getAutoType(Deduced, Keyword,
856 /*IsDependent*/ false);
859 /// \brief Build a new template specialization type.
861 /// By default, performs semantic analysis when building the template
862 /// specialization type. Subclasses may override this routine to provide
863 /// different behavior.
864 QualType RebuildTemplateSpecializationType(TemplateName Template,
865 SourceLocation TemplateLoc,
866 TemplateArgumentListInfo &Args);
868 /// \brief Build a new parenthesized type.
870 /// By default, builds a new ParenType type from the inner type.
871 /// Subclasses may override this routine to provide different behavior.
872 QualType RebuildParenType(QualType InnerType) {
873 return SemaRef.Context.getParenType(InnerType);
876 /// \brief Build a new qualified name type.
878 /// By default, builds a new ElaboratedType type from the keyword,
879 /// the nested-name-specifier and the named type.
880 /// Subclasses may override this routine to provide different behavior.
881 QualType RebuildElaboratedType(SourceLocation KeywordLoc,
882 ElaboratedTypeKeyword Keyword,
883 NestedNameSpecifierLoc QualifierLoc,
885 return SemaRef.Context.getElaboratedType(Keyword,
886 QualifierLoc.getNestedNameSpecifier(),
890 /// \brief Build a new typename type that refers to a template-id.
892 /// By default, builds a new DependentNameType type from the
893 /// nested-name-specifier and the given type. Subclasses may override
894 /// this routine to provide different behavior.
895 QualType RebuildDependentTemplateSpecializationType(
896 ElaboratedTypeKeyword Keyword,
897 NestedNameSpecifierLoc QualifierLoc,
898 const IdentifierInfo *Name,
899 SourceLocation NameLoc,
900 TemplateArgumentListInfo &Args) {
901 // Rebuild the template name.
902 // TODO: avoid TemplateName abstraction
904 SS.Adopt(QualifierLoc);
905 TemplateName InstName
906 = getDerived().RebuildTemplateName(SS, *Name, NameLoc, QualType(),
909 if (InstName.isNull())
912 // If it's still dependent, make a dependent specialization.
913 if (InstName.getAsDependentTemplateName())
914 return SemaRef.Context.getDependentTemplateSpecializationType(Keyword,
915 QualifierLoc.getNestedNameSpecifier(),
919 // Otherwise, make an elaborated type wrapping a non-dependent
922 getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
923 if (T.isNull()) return QualType();
925 if (Keyword == ETK_None && QualifierLoc.getNestedNameSpecifier() == nullptr)
928 return SemaRef.Context.getElaboratedType(Keyword,
929 QualifierLoc.getNestedNameSpecifier(),
933 /// \brief Build a new typename type that refers to an identifier.
935 /// By default, performs semantic analysis when building the typename type
936 /// (or elaborated type). Subclasses may override this routine to provide
937 /// different behavior.
938 QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword,
939 SourceLocation KeywordLoc,
940 NestedNameSpecifierLoc QualifierLoc,
941 const IdentifierInfo *Id,
942 SourceLocation IdLoc) {
944 SS.Adopt(QualifierLoc);
946 if (QualifierLoc.getNestedNameSpecifier()->isDependent()) {
947 // If the name is still dependent, just build a new dependent name type.
948 if (!SemaRef.computeDeclContext(SS))
949 return SemaRef.Context.getDependentNameType(Keyword,
950 QualifierLoc.getNestedNameSpecifier(),
954 if (Keyword == ETK_None || Keyword == ETK_Typename)
955 return SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc,
958 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
960 // We had a dependent elaborated-type-specifier that has been transformed
961 // into a non-dependent elaborated-type-specifier. Find the tag we're
963 LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
964 DeclContext *DC = SemaRef.computeDeclContext(SS, false);
968 if (SemaRef.RequireCompleteDeclContext(SS, DC))
971 TagDecl *Tag = nullptr;
972 SemaRef.LookupQualifiedName(Result, DC);
973 switch (Result.getResultKind()) {
974 case LookupResult::NotFound:
975 case LookupResult::NotFoundInCurrentInstantiation:
978 case LookupResult::Found:
979 Tag = Result.getAsSingle<TagDecl>();
982 case LookupResult::FoundOverloaded:
983 case LookupResult::FoundUnresolvedValue:
984 llvm_unreachable("Tag lookup cannot find non-tags");
986 case LookupResult::Ambiguous:
987 // Let the LookupResult structure handle ambiguities.
992 // Check where the name exists but isn't a tag type and use that to emit
993 // better diagnostics.
994 LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
995 SemaRef.LookupQualifiedName(Result, DC);
996 switch (Result.getResultKind()) {
997 case LookupResult::Found:
998 case LookupResult::FoundOverloaded:
999 case LookupResult::FoundUnresolvedValue: {
1000 NamedDecl *SomeDecl = Result.getRepresentativeDecl();
1002 if (isa<TypedefDecl>(SomeDecl)) Kind = 1;
1003 else if (isa<TypeAliasDecl>(SomeDecl)) Kind = 2;
1004 else if (isa<ClassTemplateDecl>(SomeDecl)) Kind = 3;
1005 SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) << Kind;
1006 SemaRef.Diag(SomeDecl->getLocation(), diag::note_declared_at);
1010 SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope)
1011 << Kind << Id << DC << QualifierLoc.getSourceRange();
1017 if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind, /*isDefinition*/false,
1019 SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id;
1020 SemaRef.Diag(Tag->getLocation(), diag::note_previous_use);
1024 // Build the elaborated-type-specifier type.
1025 QualType T = SemaRef.Context.getTypeDeclType(Tag);
1026 return SemaRef.Context.getElaboratedType(Keyword,
1027 QualifierLoc.getNestedNameSpecifier(),
1031 /// \brief Build a new pack expansion type.
1033 /// By default, builds a new PackExpansionType type from the given pattern.
1034 /// Subclasses may override this routine to provide different behavior.
1035 QualType RebuildPackExpansionType(QualType Pattern,
1036 SourceRange PatternRange,
1037 SourceLocation EllipsisLoc,
1038 Optional<unsigned> NumExpansions) {
1039 return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc,
1043 /// \brief Build a new atomic type given its value type.
1045 /// By default, performs semantic analysis when building the atomic type.
1046 /// Subclasses may override this routine to provide different behavior.
1047 QualType RebuildAtomicType(QualType ValueType, SourceLocation KWLoc);
1049 /// \brief Build a new pipe type given its value type.
1050 QualType RebuildPipeType(QualType ValueType, SourceLocation KWLoc);
1052 /// \brief Build a new template name given a nested name specifier, a flag
1053 /// indicating whether the "template" keyword was provided, and the template
1054 /// that the template name refers to.
1056 /// By default, builds the new template name directly. Subclasses may override
1057 /// this routine to provide different behavior.
1058 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1060 TemplateDecl *Template);
1062 /// \brief Build a new template name given a nested name specifier and the
1063 /// name that is referred to as a template.
1065 /// By default, performs semantic analysis to determine whether the name can
1066 /// be resolved to a specific template, then builds the appropriate kind of
1067 /// template name. Subclasses may override this routine to provide different
1069 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1070 const IdentifierInfo &Name,
1071 SourceLocation NameLoc,
1072 QualType ObjectType,
1073 NamedDecl *FirstQualifierInScope);
1075 /// \brief Build a new template name given a nested name specifier and the
1076 /// overloaded operator name that is referred to as a template.
1078 /// By default, performs semantic analysis to determine whether the name can
1079 /// be resolved to a specific template, then builds the appropriate kind of
1080 /// template name. Subclasses may override this routine to provide different
1082 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1083 OverloadedOperatorKind Operator,
1084 SourceLocation NameLoc,
1085 QualType ObjectType);
1087 /// \brief Build a new template name given a template template parameter pack
1090 /// By default, performs semantic analysis to determine whether the name can
1091 /// be resolved to a specific template, then builds the appropriate kind of
1092 /// template name. Subclasses may override this routine to provide different
1094 TemplateName RebuildTemplateName(TemplateTemplateParmDecl *Param,
1095 const TemplateArgument &ArgPack) {
1096 return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
1099 /// \brief Build a new compound statement.
1101 /// By default, performs semantic analysis to build the new statement.
1102 /// Subclasses may override this routine to provide different behavior.
1103 StmtResult RebuildCompoundStmt(SourceLocation LBraceLoc,
1104 MultiStmtArg Statements,
1105 SourceLocation RBraceLoc,
1107 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements,
1111 /// \brief Build a new case statement.
1113 /// By default, performs semantic analysis to build the new statement.
1114 /// Subclasses may override this routine to provide different behavior.
1115 StmtResult RebuildCaseStmt(SourceLocation CaseLoc,
1117 SourceLocation EllipsisLoc,
1119 SourceLocation ColonLoc) {
1120 return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS,
1124 /// \brief Attach the body to a new case statement.
1126 /// By default, performs semantic analysis to build the new statement.
1127 /// Subclasses may override this routine to provide different behavior.
1128 StmtResult RebuildCaseStmtBody(Stmt *S, Stmt *Body) {
1129 getSema().ActOnCaseStmtBody(S, Body);
1133 /// \brief Build a new default statement.
1135 /// By default, performs semantic analysis to build the new statement.
1136 /// Subclasses may override this routine to provide different behavior.
1137 StmtResult RebuildDefaultStmt(SourceLocation DefaultLoc,
1138 SourceLocation ColonLoc,
1140 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt,
1141 /*CurScope=*/nullptr);
1144 /// \brief Build a new label statement.
1146 /// By default, performs semantic analysis to build the new statement.
1147 /// Subclasses may override this routine to provide different behavior.
1148 StmtResult RebuildLabelStmt(SourceLocation IdentLoc, LabelDecl *L,
1149 SourceLocation ColonLoc, Stmt *SubStmt) {
1150 return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt);
1153 /// \brief Build a new label statement.
1155 /// By default, performs semantic analysis to build the new statement.
1156 /// Subclasses may override this routine to provide different behavior.
1157 StmtResult RebuildAttributedStmt(SourceLocation AttrLoc,
1158 ArrayRef<const Attr*> Attrs,
1160 return SemaRef.ActOnAttributedStmt(AttrLoc, Attrs, SubStmt);
1163 /// \brief Build a new "if" statement.
1165 /// By default, performs semantic analysis to build the new statement.
1166 /// Subclasses may override this routine to provide different behavior.
1167 StmtResult RebuildIfStmt(SourceLocation IfLoc, Sema::FullExprArg Cond,
1168 VarDecl *CondVar, Stmt *Then,
1169 SourceLocation ElseLoc, Stmt *Else) {
1170 return getSema().ActOnIfStmt(IfLoc, Cond, CondVar, Then, ElseLoc, Else);
1173 /// \brief Start building a new switch statement.
1175 /// By default, performs semantic analysis to build the new statement.
1176 /// Subclasses may override this routine to provide different behavior.
1177 StmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc,
1178 Expr *Cond, VarDecl *CondVar) {
1179 return getSema().ActOnStartOfSwitchStmt(SwitchLoc, Cond,
1183 /// \brief Attach the body to the switch statement.
1185 /// By default, performs semantic analysis to build the new statement.
1186 /// Subclasses may override this routine to provide different behavior.
1187 StmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc,
1188 Stmt *Switch, Stmt *Body) {
1189 return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body);
1192 /// \brief Build a new while statement.
1194 /// By default, performs semantic analysis to build the new statement.
1195 /// Subclasses may override this routine to provide different behavior.
1196 StmtResult RebuildWhileStmt(SourceLocation WhileLoc, Sema::FullExprArg Cond,
1197 VarDecl *CondVar, Stmt *Body) {
1198 return getSema().ActOnWhileStmt(WhileLoc, Cond, CondVar, Body);
1201 /// \brief Build a new do-while statement.
1203 /// By default, performs semantic analysis to build the new statement.
1204 /// Subclasses may override this routine to provide different behavior.
1205 StmtResult RebuildDoStmt(SourceLocation DoLoc, Stmt *Body,
1206 SourceLocation WhileLoc, SourceLocation LParenLoc,
1207 Expr *Cond, SourceLocation RParenLoc) {
1208 return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
1212 /// \brief Build a new for statement.
1214 /// By default, performs semantic analysis to build the new statement.
1215 /// Subclasses may override this routine to provide different behavior.
1216 StmtResult RebuildForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1217 Stmt *Init, Sema::FullExprArg Cond,
1218 VarDecl *CondVar, Sema::FullExprArg Inc,
1219 SourceLocation RParenLoc, Stmt *Body) {
1220 return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
1221 CondVar, Inc, RParenLoc, Body);
1224 /// \brief Build a new goto statement.
1226 /// By default, performs semantic analysis to build the new statement.
1227 /// Subclasses may override this routine to provide different behavior.
1228 StmtResult RebuildGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc,
1230 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label);
1233 /// \brief Build a new indirect goto statement.
1235 /// By default, performs semantic analysis to build the new statement.
1236 /// Subclasses may override this routine to provide different behavior.
1237 StmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc,
1238 SourceLocation StarLoc,
1240 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target);
1243 /// \brief Build a new return statement.
1245 /// By default, performs semantic analysis to build the new statement.
1246 /// Subclasses may override this routine to provide different behavior.
1247 StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, Expr *Result) {
1248 return getSema().BuildReturnStmt(ReturnLoc, Result);
1251 /// \brief Build a new declaration statement.
1253 /// By default, performs semantic analysis to build the new statement.
1254 /// Subclasses may override this routine to provide different behavior.
1255 StmtResult RebuildDeclStmt(MutableArrayRef<Decl *> Decls,
1256 SourceLocation StartLoc, SourceLocation EndLoc) {
1257 Sema::DeclGroupPtrTy DG = getSema().BuildDeclaratorGroup(Decls);
1258 return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc);
1261 /// \brief Build a new inline asm statement.
1263 /// By default, performs semantic analysis to build the new statement.
1264 /// Subclasses may override this routine to provide different behavior.
1265 StmtResult RebuildGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
1266 bool IsVolatile, unsigned NumOutputs,
1267 unsigned NumInputs, IdentifierInfo **Names,
1268 MultiExprArg Constraints, MultiExprArg Exprs,
1269 Expr *AsmString, MultiExprArg Clobbers,
1270 SourceLocation RParenLoc) {
1271 return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
1272 NumInputs, Names, Constraints, Exprs,
1273 AsmString, Clobbers, RParenLoc);
1276 /// \brief Build a new MS style inline asm statement.
1278 /// By default, performs semantic analysis to build the new statement.
1279 /// Subclasses may override this routine to provide different behavior.
1280 StmtResult RebuildMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
1281 ArrayRef<Token> AsmToks,
1282 StringRef AsmString,
1283 unsigned NumOutputs, unsigned NumInputs,
1284 ArrayRef<StringRef> Constraints,
1285 ArrayRef<StringRef> Clobbers,
1286 ArrayRef<Expr*> Exprs,
1287 SourceLocation EndLoc) {
1288 return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString,
1289 NumOutputs, NumInputs,
1290 Constraints, Clobbers, Exprs, EndLoc);
1293 /// \brief Build a new co_return statement.
1295 /// By default, performs semantic analysis to build the new statement.
1296 /// Subclasses may override this routine to provide different behavior.
1297 StmtResult RebuildCoreturnStmt(SourceLocation CoreturnLoc, Expr *Result) {
1298 return getSema().BuildCoreturnStmt(CoreturnLoc, Result);
1301 /// \brief Build a new co_await expression.
1303 /// By default, performs semantic analysis to build the new expression.
1304 /// Subclasses may override this routine to provide different behavior.
1305 ExprResult RebuildCoawaitExpr(SourceLocation CoawaitLoc, Expr *Result) {
1306 return getSema().BuildCoawaitExpr(CoawaitLoc, Result);
1309 /// \brief Build a new co_yield expression.
1311 /// By default, performs semantic analysis to build the new expression.
1312 /// Subclasses may override this routine to provide different behavior.
1313 ExprResult RebuildCoyieldExpr(SourceLocation CoyieldLoc, Expr *Result) {
1314 return getSema().BuildCoyieldExpr(CoyieldLoc, Result);
1317 /// \brief Build a new Objective-C \@try statement.
1319 /// By default, performs semantic analysis to build the new statement.
1320 /// Subclasses may override this routine to provide different behavior.
1321 StmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc,
1323 MultiStmtArg CatchStmts,
1325 return getSema().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts,
1329 /// \brief Rebuild an Objective-C exception declaration.
1331 /// By default, performs semantic analysis to build the new declaration.
1332 /// Subclasses may override this routine to provide different behavior.
1333 VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
1334 TypeSourceInfo *TInfo, QualType T) {
1335 return getSema().BuildObjCExceptionDecl(TInfo, T,
1336 ExceptionDecl->getInnerLocStart(),
1337 ExceptionDecl->getLocation(),
1338 ExceptionDecl->getIdentifier());
1341 /// \brief Build a new Objective-C \@catch statement.
1343 /// By default, performs semantic analysis to build the new statement.
1344 /// Subclasses may override this routine to provide different behavior.
1345 StmtResult RebuildObjCAtCatchStmt(SourceLocation AtLoc,
1346 SourceLocation RParenLoc,
1349 return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
1353 /// \brief Build a new Objective-C \@finally statement.
1355 /// By default, performs semantic analysis to build the new statement.
1356 /// Subclasses may override this routine to provide different behavior.
1357 StmtResult RebuildObjCAtFinallyStmt(SourceLocation AtLoc,
1359 return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body);
1362 /// \brief Build a new Objective-C \@throw statement.
1364 /// By default, performs semantic analysis to build the new statement.
1365 /// Subclasses may override this routine to provide different behavior.
1366 StmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc,
1368 return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
1371 /// \brief Build a new OpenMP executable directive.
1373 /// By default, performs semantic analysis to build the new statement.
1374 /// Subclasses may override this routine to provide different behavior.
1375 StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind,
1376 DeclarationNameInfo DirName,
1377 OpenMPDirectiveKind CancelRegion,
1378 ArrayRef<OMPClause *> Clauses,
1379 Stmt *AStmt, SourceLocation StartLoc,
1380 SourceLocation EndLoc) {
1381 return getSema().ActOnOpenMPExecutableDirective(
1382 Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
1385 /// \brief Build a new OpenMP 'if' clause.
1387 /// By default, performs semantic analysis to build the new OpenMP clause.
1388 /// Subclasses may override this routine to provide different behavior.
1389 OMPClause *RebuildOMPIfClause(OpenMPDirectiveKind NameModifier,
1390 Expr *Condition, SourceLocation StartLoc,
1391 SourceLocation LParenLoc,
1392 SourceLocation NameModifierLoc,
1393 SourceLocation ColonLoc,
1394 SourceLocation EndLoc) {
1395 return getSema().ActOnOpenMPIfClause(NameModifier, Condition, StartLoc,
1396 LParenLoc, NameModifierLoc, ColonLoc,
1400 /// \brief Build a new OpenMP 'final' clause.
1402 /// By default, performs semantic analysis to build the new OpenMP clause.
1403 /// Subclasses may override this routine to provide different behavior.
1404 OMPClause *RebuildOMPFinalClause(Expr *Condition, SourceLocation StartLoc,
1405 SourceLocation LParenLoc,
1406 SourceLocation EndLoc) {
1407 return getSema().ActOnOpenMPFinalClause(Condition, StartLoc, LParenLoc,
1411 /// \brief Build a new OpenMP 'num_threads' clause.
1413 /// By default, performs semantic analysis to build the new OpenMP clause.
1414 /// Subclasses may override this routine to provide different behavior.
1415 OMPClause *RebuildOMPNumThreadsClause(Expr *NumThreads,
1416 SourceLocation StartLoc,
1417 SourceLocation LParenLoc,
1418 SourceLocation EndLoc) {
1419 return getSema().ActOnOpenMPNumThreadsClause(NumThreads, StartLoc,
1423 /// \brief Build a new OpenMP 'safelen' clause.
1425 /// By default, performs semantic analysis to build the new OpenMP clause.
1426 /// Subclasses may override this routine to provide different behavior.
1427 OMPClause *RebuildOMPSafelenClause(Expr *Len, SourceLocation StartLoc,
1428 SourceLocation LParenLoc,
1429 SourceLocation EndLoc) {
1430 return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc);
1433 /// \brief Build a new OpenMP 'simdlen' clause.
1435 /// By default, performs semantic analysis to build the new OpenMP clause.
1436 /// Subclasses may override this routine to provide different behavior.
1437 OMPClause *RebuildOMPSimdlenClause(Expr *Len, SourceLocation StartLoc,
1438 SourceLocation LParenLoc,
1439 SourceLocation EndLoc) {
1440 return getSema().ActOnOpenMPSimdlenClause(Len, StartLoc, LParenLoc, EndLoc);
1443 /// \brief Build a new OpenMP 'collapse' clause.
1445 /// By default, performs semantic analysis to build the new OpenMP clause.
1446 /// Subclasses may override this routine to provide different behavior.
1447 OMPClause *RebuildOMPCollapseClause(Expr *Num, SourceLocation StartLoc,
1448 SourceLocation LParenLoc,
1449 SourceLocation EndLoc) {
1450 return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc,
1454 /// \brief Build a new OpenMP 'default' clause.
1456 /// By default, performs semantic analysis to build the new OpenMP clause.
1457 /// Subclasses may override this routine to provide different behavior.
1458 OMPClause *RebuildOMPDefaultClause(OpenMPDefaultClauseKind Kind,
1459 SourceLocation KindKwLoc,
1460 SourceLocation StartLoc,
1461 SourceLocation LParenLoc,
1462 SourceLocation EndLoc) {
1463 return getSema().ActOnOpenMPDefaultClause(Kind, KindKwLoc,
1464 StartLoc, LParenLoc, EndLoc);
1467 /// \brief Build a new OpenMP 'proc_bind' clause.
1469 /// By default, performs semantic analysis to build the new OpenMP clause.
1470 /// Subclasses may override this routine to provide different behavior.
1471 OMPClause *RebuildOMPProcBindClause(OpenMPProcBindClauseKind Kind,
1472 SourceLocation KindKwLoc,
1473 SourceLocation StartLoc,
1474 SourceLocation LParenLoc,
1475 SourceLocation EndLoc) {
1476 return getSema().ActOnOpenMPProcBindClause(Kind, KindKwLoc,
1477 StartLoc, LParenLoc, EndLoc);
1480 /// \brief Build a new OpenMP 'schedule' clause.
1482 /// By default, performs semantic analysis to build the new OpenMP clause.
1483 /// Subclasses may override this routine to provide different behavior.
1484 OMPClause *RebuildOMPScheduleClause(
1485 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
1486 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
1487 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
1488 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) {
1489 return getSema().ActOnOpenMPScheduleClause(
1490 M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
1494 /// \brief Build a new OpenMP 'ordered' clause.
1496 /// By default, performs semantic analysis to build the new OpenMP clause.
1497 /// Subclasses may override this routine to provide different behavior.
1498 OMPClause *RebuildOMPOrderedClause(SourceLocation StartLoc,
1499 SourceLocation EndLoc,
1500 SourceLocation LParenLoc, Expr *Num) {
1501 return getSema().ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Num);
1504 /// \brief Build a new OpenMP 'private' clause.
1506 /// By default, performs semantic analysis to build the new OpenMP clause.
1507 /// Subclasses may override this routine to provide different behavior.
1508 OMPClause *RebuildOMPPrivateClause(ArrayRef<Expr *> VarList,
1509 SourceLocation StartLoc,
1510 SourceLocation LParenLoc,
1511 SourceLocation EndLoc) {
1512 return getSema().ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc,
1516 /// \brief Build a new OpenMP 'firstprivate' clause.
1518 /// By default, performs semantic analysis to build the new OpenMP clause.
1519 /// Subclasses may override this routine to provide different behavior.
1520 OMPClause *RebuildOMPFirstprivateClause(ArrayRef<Expr *> VarList,
1521 SourceLocation StartLoc,
1522 SourceLocation LParenLoc,
1523 SourceLocation EndLoc) {
1524 return getSema().ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc,
1528 /// \brief Build a new OpenMP 'lastprivate' clause.
1530 /// By default, performs semantic analysis to build the new OpenMP clause.
1531 /// Subclasses may override this routine to provide different behavior.
1532 OMPClause *RebuildOMPLastprivateClause(ArrayRef<Expr *> VarList,
1533 SourceLocation StartLoc,
1534 SourceLocation LParenLoc,
1535 SourceLocation EndLoc) {
1536 return getSema().ActOnOpenMPLastprivateClause(VarList, StartLoc, LParenLoc,
1540 /// \brief Build a new OpenMP 'shared' clause.
1542 /// By default, performs semantic analysis to build the new OpenMP clause.
1543 /// Subclasses may override this routine to provide different behavior.
1544 OMPClause *RebuildOMPSharedClause(ArrayRef<Expr *> VarList,
1545 SourceLocation StartLoc,
1546 SourceLocation LParenLoc,
1547 SourceLocation EndLoc) {
1548 return getSema().ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc,
1552 /// \brief Build a new OpenMP 'reduction' clause.
1554 /// By default, performs semantic analysis to build the new statement.
1555 /// Subclasses may override this routine to provide different behavior.
1556 OMPClause *RebuildOMPReductionClause(ArrayRef<Expr *> VarList,
1557 SourceLocation StartLoc,
1558 SourceLocation LParenLoc,
1559 SourceLocation ColonLoc,
1560 SourceLocation EndLoc,
1561 CXXScopeSpec &ReductionIdScopeSpec,
1562 const DeclarationNameInfo &ReductionId) {
1563 return getSema().ActOnOpenMPReductionClause(
1564 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1568 /// \brief Build a new OpenMP 'linear' clause.
1570 /// By default, performs semantic analysis to build the new OpenMP clause.
1571 /// Subclasses may override this routine to provide different behavior.
1572 OMPClause *RebuildOMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
1573 SourceLocation StartLoc,
1574 SourceLocation LParenLoc,
1575 OpenMPLinearClauseKind Modifier,
1576 SourceLocation ModifierLoc,
1577 SourceLocation ColonLoc,
1578 SourceLocation EndLoc) {
1579 return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc,
1580 Modifier, ModifierLoc, ColonLoc,
1584 /// \brief Build a new OpenMP 'aligned' clause.
1586 /// By default, performs semantic analysis to build the new OpenMP clause.
1587 /// Subclasses may override this routine to provide different behavior.
1588 OMPClause *RebuildOMPAlignedClause(ArrayRef<Expr *> VarList, Expr *Alignment,
1589 SourceLocation StartLoc,
1590 SourceLocation LParenLoc,
1591 SourceLocation ColonLoc,
1592 SourceLocation EndLoc) {
1593 return getSema().ActOnOpenMPAlignedClause(VarList, Alignment, StartLoc,
1594 LParenLoc, ColonLoc, EndLoc);
1597 /// \brief Build a new OpenMP 'copyin' clause.
1599 /// By default, performs semantic analysis to build the new OpenMP clause.
1600 /// Subclasses may override this routine to provide different behavior.
1601 OMPClause *RebuildOMPCopyinClause(ArrayRef<Expr *> VarList,
1602 SourceLocation StartLoc,
1603 SourceLocation LParenLoc,
1604 SourceLocation EndLoc) {
1605 return getSema().ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc,
1609 /// \brief Build a new OpenMP 'copyprivate' clause.
1611 /// By default, performs semantic analysis to build the new OpenMP clause.
1612 /// Subclasses may override this routine to provide different behavior.
1613 OMPClause *RebuildOMPCopyprivateClause(ArrayRef<Expr *> VarList,
1614 SourceLocation StartLoc,
1615 SourceLocation LParenLoc,
1616 SourceLocation EndLoc) {
1617 return getSema().ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc,
1621 /// \brief Build a new OpenMP 'flush' pseudo clause.
1623 /// By default, performs semantic analysis to build the new OpenMP clause.
1624 /// Subclasses may override this routine to provide different behavior.
1625 OMPClause *RebuildOMPFlushClause(ArrayRef<Expr *> VarList,
1626 SourceLocation StartLoc,
1627 SourceLocation LParenLoc,
1628 SourceLocation EndLoc) {
1629 return getSema().ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc,
1633 /// \brief Build a new OpenMP 'depend' pseudo clause.
1635 /// By default, performs semantic analysis to build the new OpenMP clause.
1636 /// Subclasses may override this routine to provide different behavior.
1638 RebuildOMPDependClause(OpenMPDependClauseKind DepKind, SourceLocation DepLoc,
1639 SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
1640 SourceLocation StartLoc, SourceLocation LParenLoc,
1641 SourceLocation EndLoc) {
1642 return getSema().ActOnOpenMPDependClause(DepKind, DepLoc, ColonLoc, VarList,
1643 StartLoc, LParenLoc, EndLoc);
1646 /// \brief Build a new OpenMP 'device' clause.
1648 /// By default, performs semantic analysis to build the new statement.
1649 /// Subclasses may override this routine to provide different behavior.
1650 OMPClause *RebuildOMPDeviceClause(Expr *Device, SourceLocation StartLoc,
1651 SourceLocation LParenLoc,
1652 SourceLocation EndLoc) {
1653 return getSema().ActOnOpenMPDeviceClause(Device, StartLoc, LParenLoc,
1657 /// \brief Build a new OpenMP 'map' clause.
1659 /// By default, performs semantic analysis to build the new OpenMP clause.
1660 /// Subclasses may override this routine to provide different behavior.
1661 OMPClause *RebuildOMPMapClause(
1662 OpenMPMapClauseKind MapTypeModifier, OpenMPMapClauseKind MapType,
1663 SourceLocation MapLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
1664 SourceLocation StartLoc, SourceLocation LParenLoc,
1665 SourceLocation EndLoc) {
1666 return getSema().ActOnOpenMPMapClause(MapTypeModifier, MapType, MapLoc,
1667 ColonLoc, VarList,StartLoc,
1671 /// \brief Build a new OpenMP 'num_teams' clause.
1673 /// By default, performs semantic analysis to build the new statement.
1674 /// Subclasses may override this routine to provide different behavior.
1675 OMPClause *RebuildOMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc,
1676 SourceLocation LParenLoc,
1677 SourceLocation EndLoc) {
1678 return getSema().ActOnOpenMPNumTeamsClause(NumTeams, StartLoc, LParenLoc,
1682 /// \brief Build a new OpenMP 'thread_limit' clause.
1684 /// By default, performs semantic analysis to build the new statement.
1685 /// Subclasses may override this routine to provide different behavior.
1686 OMPClause *RebuildOMPThreadLimitClause(Expr *ThreadLimit,
1687 SourceLocation StartLoc,
1688 SourceLocation LParenLoc,
1689 SourceLocation EndLoc) {
1690 return getSema().ActOnOpenMPThreadLimitClause(ThreadLimit, StartLoc,
1694 /// \brief Build a new OpenMP 'priority' clause.
1696 /// By default, performs semantic analysis to build the new statement.
1697 /// Subclasses may override this routine to provide different behavior.
1698 OMPClause *RebuildOMPPriorityClause(Expr *Priority, SourceLocation StartLoc,
1699 SourceLocation LParenLoc,
1700 SourceLocation EndLoc) {
1701 return getSema().ActOnOpenMPPriorityClause(Priority, StartLoc, LParenLoc,
1705 /// \brief Build a new OpenMP 'grainsize' clause.
1707 /// By default, performs semantic analysis to build the new statement.
1708 /// Subclasses may override this routine to provide different behavior.
1709 OMPClause *RebuildOMPGrainsizeClause(Expr *Grainsize, SourceLocation StartLoc,
1710 SourceLocation LParenLoc,
1711 SourceLocation EndLoc) {
1712 return getSema().ActOnOpenMPGrainsizeClause(Grainsize, StartLoc, LParenLoc,
1716 /// \brief Build a new OpenMP 'num_tasks' clause.
1718 /// By default, performs semantic analysis to build the new statement.
1719 /// Subclasses may override this routine to provide different behavior.
1720 OMPClause *RebuildOMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc,
1721 SourceLocation LParenLoc,
1722 SourceLocation EndLoc) {
1723 return getSema().ActOnOpenMPNumTasksClause(NumTasks, StartLoc, LParenLoc,
1727 /// \brief Build a new OpenMP 'hint' clause.
1729 /// By default, performs semantic analysis to build the new statement.
1730 /// Subclasses may override this routine to provide different behavior.
1731 OMPClause *RebuildOMPHintClause(Expr *Hint, SourceLocation StartLoc,
1732 SourceLocation LParenLoc,
1733 SourceLocation EndLoc) {
1734 return getSema().ActOnOpenMPHintClause(Hint, StartLoc, LParenLoc, EndLoc);
1737 /// \brief Rebuild the operand to an Objective-C \@synchronized statement.
1739 /// By default, performs semantic analysis to build the new statement.
1740 /// Subclasses may override this routine to provide different behavior.
1741 ExprResult RebuildObjCAtSynchronizedOperand(SourceLocation atLoc,
1743 return getSema().ActOnObjCAtSynchronizedOperand(atLoc, object);
1746 /// \brief Build a new Objective-C \@synchronized statement.
1748 /// By default, performs semantic analysis to build the new statement.
1749 /// Subclasses may override this routine to provide different behavior.
1750 StmtResult RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc,
1751 Expr *Object, Stmt *Body) {
1752 return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body);
1755 /// \brief Build a new Objective-C \@autoreleasepool statement.
1757 /// By default, performs semantic analysis to build the new statement.
1758 /// Subclasses may override this routine to provide different behavior.
1759 StmtResult RebuildObjCAutoreleasePoolStmt(SourceLocation AtLoc,
1761 return getSema().ActOnObjCAutoreleasePoolStmt(AtLoc, Body);
1764 /// \brief Build a new Objective-C fast enumeration statement.
1766 /// By default, performs semantic analysis to build the new statement.
1767 /// Subclasses may override this routine to provide different behavior.
1768 StmtResult RebuildObjCForCollectionStmt(SourceLocation ForLoc,
1771 SourceLocation RParenLoc,
1773 StmtResult ForEachStmt = getSema().ActOnObjCForCollectionStmt(ForLoc,
1777 if (ForEachStmt.isInvalid())
1780 return getSema().FinishObjCForCollectionStmt(ForEachStmt.get(), Body);
1783 /// \brief Build a new C++ exception declaration.
1785 /// By default, performs semantic analysis to build the new decaration.
1786 /// Subclasses may override this routine to provide different behavior.
1787 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
1788 TypeSourceInfo *Declarator,
1789 SourceLocation StartLoc,
1790 SourceLocation IdLoc,
1791 IdentifierInfo *Id) {
1792 VarDecl *Var = getSema().BuildExceptionDeclaration(nullptr, Declarator,
1793 StartLoc, IdLoc, Id);
1795 getSema().CurContext->addDecl(Var);
1799 /// \brief Build a new C++ catch statement.
1801 /// By default, performs semantic analysis to build the new statement.
1802 /// Subclasses may override this routine to provide different behavior.
1803 StmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc,
1804 VarDecl *ExceptionDecl,
1806 return Owned(new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl,
1810 /// \brief Build a new C++ try statement.
1812 /// By default, performs semantic analysis to build the new statement.
1813 /// Subclasses may override this routine to provide different behavior.
1814 StmtResult RebuildCXXTryStmt(SourceLocation TryLoc, Stmt *TryBlock,
1815 ArrayRef<Stmt *> Handlers) {
1816 return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers);
1819 /// \brief Build a new C++0x range-based for statement.
1821 /// By default, performs semantic analysis to build the new statement.
1822 /// Subclasses may override this routine to provide different behavior.
1823 StmtResult RebuildCXXForRangeStmt(SourceLocation ForLoc,
1824 SourceLocation CoawaitLoc,
1825 SourceLocation ColonLoc,
1826 Stmt *Range, Stmt *BeginEnd,
1827 Expr *Cond, Expr *Inc,
1829 SourceLocation RParenLoc) {
1830 // If we've just learned that the range is actually an Objective-C
1831 // collection, treat this as an Objective-C fast enumeration loop.
1832 if (DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) {
1833 if (RangeStmt->isSingleDecl()) {
1834 if (VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
1835 if (RangeVar->isInvalidDecl())
1838 Expr *RangeExpr = RangeVar->getInit();
1839 if (!RangeExpr->isTypeDependent() &&
1840 RangeExpr->getType()->isObjCObjectPointerType())
1841 return getSema().ActOnObjCForCollectionStmt(ForLoc, LoopVar, RangeExpr,
1847 return getSema().BuildCXXForRangeStmt(ForLoc, CoawaitLoc, ColonLoc,
1849 Cond, Inc, LoopVar, RParenLoc,
1850 Sema::BFRK_Rebuild);
1853 /// \brief Build a new C++0x range-based for statement.
1855 /// By default, performs semantic analysis to build the new statement.
1856 /// Subclasses may override this routine to provide different behavior.
1857 StmtResult RebuildMSDependentExistsStmt(SourceLocation KeywordLoc,
1859 NestedNameSpecifierLoc QualifierLoc,
1860 DeclarationNameInfo NameInfo,
1862 return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
1863 QualifierLoc, NameInfo, Nested);
1866 /// \brief Attach body to a C++0x range-based for statement.
1868 /// By default, performs semantic analysis to finish the new statement.
1869 /// Subclasses may override this routine to provide different behavior.
1870 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body) {
1871 return getSema().FinishCXXForRangeStmt(ForRange, Body);
1874 StmtResult RebuildSEHTryStmt(bool IsCXXTry, SourceLocation TryLoc,
1875 Stmt *TryBlock, Stmt *Handler) {
1876 return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler);
1879 StmtResult RebuildSEHExceptStmt(SourceLocation Loc, Expr *FilterExpr,
1881 return getSema().ActOnSEHExceptBlock(Loc, FilterExpr, Block);
1884 StmtResult RebuildSEHFinallyStmt(SourceLocation Loc, Stmt *Block) {
1885 return SEHFinallyStmt::Create(getSema().getASTContext(), Loc, Block);
1888 /// \brief Build a new predefined expression.
1890 /// By default, performs semantic analysis to build the new expression.
1891 /// Subclasses may override this routine to provide different behavior.
1892 ExprResult RebuildPredefinedExpr(SourceLocation Loc,
1893 PredefinedExpr::IdentType IT) {
1894 return getSema().BuildPredefinedExpr(Loc, IT);
1897 /// \brief Build a new expression that references a declaration.
1899 /// By default, performs semantic analysis to build the new expression.
1900 /// Subclasses may override this routine to provide different behavior.
1901 ExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS,
1904 return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
1908 /// \brief Build a new expression that references a declaration.
1910 /// By default, performs semantic analysis to build the new expression.
1911 /// Subclasses may override this routine to provide different behavior.
1912 ExprResult RebuildDeclRefExpr(NestedNameSpecifierLoc QualifierLoc,
1914 const DeclarationNameInfo &NameInfo,
1915 TemplateArgumentListInfo *TemplateArgs) {
1917 SS.Adopt(QualifierLoc);
1919 // FIXME: loses template args.
1921 return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD);
1924 /// \brief Build a new expression in parentheses.
1926 /// By default, performs semantic analysis to build the new expression.
1927 /// Subclasses may override this routine to provide different behavior.
1928 ExprResult RebuildParenExpr(Expr *SubExpr, SourceLocation LParen,
1929 SourceLocation RParen) {
1930 return getSema().ActOnParenExpr(LParen, RParen, SubExpr);
1933 /// \brief Build a new pseudo-destructor expression.
1935 /// By default, performs semantic analysis to build the new expression.
1936 /// Subclasses may override this routine to provide different behavior.
1937 ExprResult RebuildCXXPseudoDestructorExpr(Expr *Base,
1938 SourceLocation OperatorLoc,
1941 TypeSourceInfo *ScopeType,
1942 SourceLocation CCLoc,
1943 SourceLocation TildeLoc,
1944 PseudoDestructorTypeStorage Destroyed);
1946 /// \brief Build a new unary operator expression.
1948 /// By default, performs semantic analysis to build the new expression.
1949 /// Subclasses may override this routine to provide different behavior.
1950 ExprResult RebuildUnaryOperator(SourceLocation OpLoc,
1951 UnaryOperatorKind Opc,
1953 return getSema().BuildUnaryOp(/*Scope=*/nullptr, OpLoc, Opc, SubExpr);
1956 /// \brief Build a new builtin offsetof expression.
1958 /// By default, performs semantic analysis to build the new expression.
1959 /// Subclasses may override this routine to provide different behavior.
1960 ExprResult RebuildOffsetOfExpr(SourceLocation OperatorLoc,
1961 TypeSourceInfo *Type,
1962 ArrayRef<Sema::OffsetOfComponent> Components,
1963 SourceLocation RParenLoc) {
1964 return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
1968 /// \brief Build a new sizeof, alignof or vec_step expression with a
1971 /// By default, performs semantic analysis to build the new expression.
1972 /// Subclasses may override this routine to provide different behavior.
1973 ExprResult RebuildUnaryExprOrTypeTrait(TypeSourceInfo *TInfo,
1974 SourceLocation OpLoc,
1975 UnaryExprOrTypeTrait ExprKind,
1977 return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R);
1980 /// \brief Build a new sizeof, alignof or vec step expression with an
1981 /// expression argument.
1983 /// By default, performs semantic analysis to build the new expression.
1984 /// Subclasses may override this routine to provide different behavior.
1985 ExprResult RebuildUnaryExprOrTypeTrait(Expr *SubExpr, SourceLocation OpLoc,
1986 UnaryExprOrTypeTrait ExprKind,
1989 = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind);
1990 if (Result.isInvalid())
1996 /// \brief Build a new array subscript expression.
1998 /// By default, performs semantic analysis to build the new expression.
1999 /// Subclasses may override this routine to provide different behavior.
2000 ExprResult RebuildArraySubscriptExpr(Expr *LHS,
2001 SourceLocation LBracketLoc,
2003 SourceLocation RBracketLoc) {
2004 return getSema().ActOnArraySubscriptExpr(/*Scope=*/nullptr, LHS,
2009 /// \brief Build a new array section expression.
2011 /// By default, performs semantic analysis to build the new expression.
2012 /// Subclasses may override this routine to provide different behavior.
2013 ExprResult RebuildOMPArraySectionExpr(Expr *Base, SourceLocation LBracketLoc,
2015 SourceLocation ColonLoc, Expr *Length,
2016 SourceLocation RBracketLoc) {
2017 return getSema().ActOnOMPArraySectionExpr(Base, LBracketLoc, LowerBound,
2018 ColonLoc, Length, RBracketLoc);
2021 /// \brief Build a new call expression.
2023 /// By default, performs semantic analysis to build the new expression.
2024 /// Subclasses may override this routine to provide different behavior.
2025 ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc,
2027 SourceLocation RParenLoc,
2028 Expr *ExecConfig = nullptr) {
2029 return getSema().ActOnCallExpr(/*Scope=*/nullptr, Callee, LParenLoc,
2030 Args, RParenLoc, ExecConfig);
2033 /// \brief Build a new member access expression.
2035 /// By default, performs semantic analysis to build the new expression.
2036 /// Subclasses may override this routine to provide different behavior.
2037 ExprResult RebuildMemberExpr(Expr *Base, SourceLocation OpLoc,
2039 NestedNameSpecifierLoc QualifierLoc,
2040 SourceLocation TemplateKWLoc,
2041 const DeclarationNameInfo &MemberNameInfo,
2043 NamedDecl *FoundDecl,
2044 const TemplateArgumentListInfo *ExplicitTemplateArgs,
2045 NamedDecl *FirstQualifierInScope) {
2046 ExprResult BaseResult = getSema().PerformMemberExprBaseConversion(Base,
2048 if (!Member->getDeclName()) {
2049 // We have a reference to an unnamed field. This is always the
2050 // base of an anonymous struct/union member access, i.e. the
2051 // field is always of record type.
2052 assert(!QualifierLoc && "Can't have an unnamed field with a qualifier!");
2053 assert(Member->getType()->isRecordType() &&
2054 "unnamed member not of record type?");
2057 getSema().PerformObjectMemberConversion(BaseResult.get(),
2058 QualifierLoc.getNestedNameSpecifier(),
2060 if (BaseResult.isInvalid())
2062 Base = BaseResult.get();
2063 ExprValueKind VK = isArrow ? VK_LValue : Base->getValueKind();
2064 MemberExpr *ME = new (getSema().Context)
2065 MemberExpr(Base, isArrow, OpLoc, Member, MemberNameInfo,
2066 cast<FieldDecl>(Member)->getType(), VK, OK_Ordinary);
2071 SS.Adopt(QualifierLoc);
2073 Base = BaseResult.get();
2074 QualType BaseType = Base->getType();
2076 // FIXME: this involves duplicating earlier analysis in a lot of
2077 // cases; we should avoid this when possible.
2078 LookupResult R(getSema(), MemberNameInfo, Sema::LookupMemberName);
2079 R.addDecl(FoundDecl);
2082 return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow,
2084 FirstQualifierInScope,
2085 R, ExplicitTemplateArgs,
2089 /// \brief Build a new binary operator expression.
2091 /// By default, performs semantic analysis to build the new expression.
2092 /// Subclasses may override this routine to provide different behavior.
2093 ExprResult RebuildBinaryOperator(SourceLocation OpLoc,
2094 BinaryOperatorKind Opc,
2095 Expr *LHS, Expr *RHS) {
2096 return getSema().BuildBinOp(/*Scope=*/nullptr, OpLoc, Opc, LHS, RHS);
2099 /// \brief Build a new conditional operator expression.
2101 /// By default, performs semantic analysis to build the new expression.
2102 /// Subclasses may override this routine to provide different behavior.
2103 ExprResult RebuildConditionalOperator(Expr *Cond,
2104 SourceLocation QuestionLoc,
2106 SourceLocation ColonLoc,
2108 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond,
2112 /// \brief Build a new C-style cast expression.
2114 /// By default, performs semantic analysis to build the new expression.
2115 /// Subclasses may override this routine to provide different behavior.
2116 ExprResult RebuildCStyleCastExpr(SourceLocation LParenLoc,
2117 TypeSourceInfo *TInfo,
2118 SourceLocation RParenLoc,
2120 return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
2124 /// \brief Build a new compound literal expression.
2126 /// By default, performs semantic analysis to build the new expression.
2127 /// Subclasses may override this routine to provide different behavior.
2128 ExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc,
2129 TypeSourceInfo *TInfo,
2130 SourceLocation RParenLoc,
2132 return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
2136 /// \brief Build a new extended vector element access expression.
2138 /// By default, performs semantic analysis to build the new expression.
2139 /// Subclasses may override this routine to provide different behavior.
2140 ExprResult RebuildExtVectorElementExpr(Expr *Base,
2141 SourceLocation OpLoc,
2142 SourceLocation AccessorLoc,
2143 IdentifierInfo &Accessor) {
2146 DeclarationNameInfo NameInfo(&Accessor, AccessorLoc);
2147 return getSema().BuildMemberReferenceExpr(Base, Base->getType(),
2148 OpLoc, /*IsArrow*/ false,
2149 SS, SourceLocation(),
2150 /*FirstQualifierInScope*/ nullptr,
2152 /* TemplateArgs */ nullptr,
2156 /// \brief Build a new initializer list expression.
2158 /// By default, performs semantic analysis to build the new expression.
2159 /// Subclasses may override this routine to provide different behavior.
2160 ExprResult RebuildInitList(SourceLocation LBraceLoc,
2162 SourceLocation RBraceLoc,
2163 QualType ResultTy) {
2165 = SemaRef.ActOnInitList(LBraceLoc, Inits, RBraceLoc);
2166 if (Result.isInvalid() || ResultTy->isDependentType())
2169 // Patch in the result type we were given, which may have been computed
2170 // when the initial InitListExpr was built.
2171 InitListExpr *ILE = cast<InitListExpr>((Expr *)Result.get());
2172 ILE->setType(ResultTy);
2176 /// \brief Build a new designated initializer expression.
2178 /// By default, performs semantic analysis to build the new expression.
2179 /// Subclasses may override this routine to provide different behavior.
2180 ExprResult RebuildDesignatedInitExpr(Designation &Desig,
2181 MultiExprArg ArrayExprs,
2182 SourceLocation EqualOrColonLoc,
2186 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
2188 if (Result.isInvalid())
2194 /// \brief Build a new value-initialized expression.
2196 /// By default, builds the implicit value initialization without performing
2197 /// any semantic analysis. Subclasses may override this routine to provide
2198 /// different behavior.
2199 ExprResult RebuildImplicitValueInitExpr(QualType T) {
2200 return new (SemaRef.Context) ImplicitValueInitExpr(T);
2203 /// \brief Build a new \c va_arg expression.
2205 /// By default, performs semantic analysis to build the new expression.
2206 /// Subclasses may override this routine to provide different behavior.
2207 ExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc,
2208 Expr *SubExpr, TypeSourceInfo *TInfo,
2209 SourceLocation RParenLoc) {
2210 return getSema().BuildVAArgExpr(BuiltinLoc,
2215 /// \brief Build a new expression list in parentheses.
2217 /// By default, performs semantic analysis to build the new expression.
2218 /// Subclasses may override this routine to provide different behavior.
2219 ExprResult RebuildParenListExpr(SourceLocation LParenLoc,
2220 MultiExprArg SubExprs,
2221 SourceLocation RParenLoc) {
2222 return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs);
2225 /// \brief Build a new address-of-label expression.
2227 /// By default, performs semantic analysis, using the name of the label
2228 /// rather than attempting to map the label statement itself.
2229 /// Subclasses may override this routine to provide different behavior.
2230 ExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc,
2231 SourceLocation LabelLoc, LabelDecl *Label) {
2232 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label);
2235 /// \brief Build a new GNU statement expression.
2237 /// By default, performs semantic analysis to build the new expression.
2238 /// Subclasses may override this routine to provide different behavior.
2239 ExprResult RebuildStmtExpr(SourceLocation LParenLoc,
2241 SourceLocation RParenLoc) {
2242 return getSema().ActOnStmtExpr(LParenLoc, SubStmt, RParenLoc);
2245 /// \brief Build a new __builtin_choose_expr expression.
2247 /// By default, performs semantic analysis to build the new expression.
2248 /// Subclasses may override this routine to provide different behavior.
2249 ExprResult RebuildChooseExpr(SourceLocation BuiltinLoc,
2250 Expr *Cond, Expr *LHS, Expr *RHS,
2251 SourceLocation RParenLoc) {
2252 return SemaRef.ActOnChooseExpr(BuiltinLoc,
2257 /// \brief Build a new generic selection expression.
2259 /// By default, performs semantic analysis to build the new expression.
2260 /// Subclasses may override this routine to provide different behavior.
2261 ExprResult RebuildGenericSelectionExpr(SourceLocation KeyLoc,
2262 SourceLocation DefaultLoc,
2263 SourceLocation RParenLoc,
2264 Expr *ControllingExpr,
2265 ArrayRef<TypeSourceInfo *> Types,
2266 ArrayRef<Expr *> Exprs) {
2267 return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
2268 ControllingExpr, Types, Exprs);
2271 /// \brief Build a new overloaded operator call expression.
2273 /// By default, performs semantic analysis to build the new expression.
2274 /// The semantic analysis provides the behavior of template instantiation,
2275 /// copying with transformations that turn what looks like an overloaded
2276 /// operator call into a use of a builtin operator, performing
2277 /// argument-dependent lookup, etc. Subclasses may override this routine to
2278 /// provide different behavior.
2279 ExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
2280 SourceLocation OpLoc,
2285 /// \brief Build a new C++ "named" cast expression, such as static_cast or
2286 /// reinterpret_cast.
2288 /// By default, this routine dispatches to one of the more-specific routines
2289 /// for a particular named case, e.g., RebuildCXXStaticCastExpr().
2290 /// Subclasses may override this routine to provide different behavior.
2291 ExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc,
2292 Stmt::StmtClass Class,
2293 SourceLocation LAngleLoc,
2294 TypeSourceInfo *TInfo,
2295 SourceLocation RAngleLoc,
2296 SourceLocation LParenLoc,
2298 SourceLocation RParenLoc) {
2300 case Stmt::CXXStaticCastExprClass:
2301 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
2302 RAngleLoc, LParenLoc,
2303 SubExpr, RParenLoc);
2305 case Stmt::CXXDynamicCastExprClass:
2306 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
2307 RAngleLoc, LParenLoc,
2308 SubExpr, RParenLoc);
2310 case Stmt::CXXReinterpretCastExprClass:
2311 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
2312 RAngleLoc, LParenLoc,
2316 case Stmt::CXXConstCastExprClass:
2317 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
2318 RAngleLoc, LParenLoc,
2319 SubExpr, RParenLoc);
2322 llvm_unreachable("Invalid C++ named cast");
2326 /// \brief Build a new C++ static_cast expression.
2328 /// By default, performs semantic analysis to build the new expression.
2329 /// Subclasses may override this routine to provide different behavior.
2330 ExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc,
2331 SourceLocation LAngleLoc,
2332 TypeSourceInfo *TInfo,
2333 SourceLocation RAngleLoc,
2334 SourceLocation LParenLoc,
2336 SourceLocation RParenLoc) {
2337 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
2339 SourceRange(LAngleLoc, RAngleLoc),
2340 SourceRange(LParenLoc, RParenLoc));
2343 /// \brief Build a new C++ dynamic_cast expression.
2345 /// By default, performs semantic analysis to build the new expression.
2346 /// Subclasses may override this routine to provide different behavior.
2347 ExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc,
2348 SourceLocation LAngleLoc,
2349 TypeSourceInfo *TInfo,
2350 SourceLocation RAngleLoc,
2351 SourceLocation LParenLoc,
2353 SourceLocation RParenLoc) {
2354 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
2356 SourceRange(LAngleLoc, RAngleLoc),
2357 SourceRange(LParenLoc, RParenLoc));
2360 /// \brief Build a new C++ reinterpret_cast expression.
2362 /// By default, performs semantic analysis to build the new expression.
2363 /// Subclasses may override this routine to provide different behavior.
2364 ExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc,
2365 SourceLocation LAngleLoc,
2366 TypeSourceInfo *TInfo,
2367 SourceLocation RAngleLoc,
2368 SourceLocation LParenLoc,
2370 SourceLocation RParenLoc) {
2371 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
2373 SourceRange(LAngleLoc, RAngleLoc),
2374 SourceRange(LParenLoc, RParenLoc));
2377 /// \brief Build a new C++ const_cast expression.
2379 /// By default, performs semantic analysis to build the new expression.
2380 /// Subclasses may override this routine to provide different behavior.
2381 ExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc,
2382 SourceLocation LAngleLoc,
2383 TypeSourceInfo *TInfo,
2384 SourceLocation RAngleLoc,
2385 SourceLocation LParenLoc,
2387 SourceLocation RParenLoc) {
2388 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
2390 SourceRange(LAngleLoc, RAngleLoc),
2391 SourceRange(LParenLoc, RParenLoc));
2394 /// \brief Build a new C++ functional-style cast expression.
2396 /// By default, performs semantic analysis to build the new expression.
2397 /// Subclasses may override this routine to provide different behavior.
2398 ExprResult RebuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo,
2399 SourceLocation LParenLoc,
2401 SourceLocation RParenLoc) {
2402 return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc,
2403 MultiExprArg(&Sub, 1),
2407 /// \brief Build a new C++ typeid(type) expression.
2409 /// By default, performs semantic analysis to build the new expression.
2410 /// Subclasses may override this routine to provide different behavior.
2411 ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
2412 SourceLocation TypeidLoc,
2413 TypeSourceInfo *Operand,
2414 SourceLocation RParenLoc) {
2415 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2420 /// \brief Build a new C++ typeid(expr) expression.
2422 /// By default, performs semantic analysis to build the new expression.
2423 /// Subclasses may override this routine to provide different behavior.
2424 ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
2425 SourceLocation TypeidLoc,
2427 SourceLocation RParenLoc) {
2428 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2432 /// \brief Build a new C++ __uuidof(type) expression.
2434 /// By default, performs semantic analysis to build the new expression.
2435 /// Subclasses may override this routine to provide different behavior.
2436 ExprResult RebuildCXXUuidofExpr(QualType TypeInfoType,
2437 SourceLocation TypeidLoc,
2438 TypeSourceInfo *Operand,
2439 SourceLocation RParenLoc) {
2440 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
2444 /// \brief Build a new C++ __uuidof(expr) expression.
2446 /// By default, performs semantic analysis to build the new expression.
2447 /// Subclasses may override this routine to provide different behavior.
2448 ExprResult RebuildCXXUuidofExpr(QualType TypeInfoType,
2449 SourceLocation TypeidLoc,
2451 SourceLocation RParenLoc) {
2452 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
2456 /// \brief Build a new C++ "this" expression.
2458 /// By default, builds a new "this" expression without performing any
2459 /// semantic analysis. Subclasses may override this routine to provide
2460 /// different behavior.
2461 ExprResult RebuildCXXThisExpr(SourceLocation ThisLoc,
2464 getSema().CheckCXXThisCapture(ThisLoc);
2465 return new (getSema().Context) CXXThisExpr(ThisLoc, ThisType, isImplicit);
2468 /// \brief Build a new C++ throw expression.
2470 /// By default, performs semantic analysis to build the new expression.
2471 /// Subclasses may override this routine to provide different behavior.
2472 ExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, Expr *Sub,
2473 bool IsThrownVariableInScope) {
2474 return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope);
2477 /// \brief Build a new C++ default-argument expression.
2479 /// By default, builds a new default-argument expression, which does not
2480 /// require any semantic analysis. Subclasses may override this routine to
2481 /// provide different behavior.
2482 ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc,
2483 ParmVarDecl *Param) {
2484 return CXXDefaultArgExpr::Create(getSema().Context, Loc, Param);
2487 /// \brief Build a new C++11 default-initialization expression.
2489 /// By default, builds a new default field initialization expression, which
2490 /// does not require any semantic analysis. Subclasses may override this
2491 /// routine to provide different behavior.
2492 ExprResult RebuildCXXDefaultInitExpr(SourceLocation Loc,
2494 return CXXDefaultInitExpr::Create(getSema().Context, Loc, Field);
2497 /// \brief Build a new C++ zero-initialization expression.
2499 /// By default, performs semantic analysis to build the new expression.
2500 /// Subclasses may override this routine to provide different behavior.
2501 ExprResult RebuildCXXScalarValueInitExpr(TypeSourceInfo *TSInfo,
2502 SourceLocation LParenLoc,
2503 SourceLocation RParenLoc) {
2504 return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc,
2508 /// \brief Build a new C++ "new" expression.
2510 /// By default, performs semantic analysis to build the new expression.
2511 /// Subclasses may override this routine to provide different behavior.
2512 ExprResult RebuildCXXNewExpr(SourceLocation StartLoc,
2514 SourceLocation PlacementLParen,
2515 MultiExprArg PlacementArgs,
2516 SourceLocation PlacementRParen,
2517 SourceRange TypeIdParens,
2518 QualType AllocatedType,
2519 TypeSourceInfo *AllocatedTypeInfo,
2521 SourceRange DirectInitRange,
2522 Expr *Initializer) {
2523 return getSema().BuildCXXNew(StartLoc, UseGlobal,
2535 /// \brief Build a new C++ "delete" expression.
2537 /// By default, performs semantic analysis to build the new expression.
2538 /// Subclasses may override this routine to provide different behavior.
2539 ExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc,
2540 bool IsGlobalDelete,
2543 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
2547 /// \brief Build a new type trait expression.
2549 /// By default, performs semantic analysis to build the new expression.
2550 /// Subclasses may override this routine to provide different behavior.
2551 ExprResult RebuildTypeTrait(TypeTrait Trait,
2552 SourceLocation StartLoc,
2553 ArrayRef<TypeSourceInfo *> Args,
2554 SourceLocation RParenLoc) {
2555 return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc);
2558 /// \brief Build a new array type trait expression.
2560 /// By default, performs semantic analysis to build the new expression.
2561 /// Subclasses may override this routine to provide different behavior.
2562 ExprResult RebuildArrayTypeTrait(ArrayTypeTrait Trait,
2563 SourceLocation StartLoc,
2564 TypeSourceInfo *TSInfo,
2566 SourceLocation RParenLoc) {
2567 return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc);
2570 /// \brief Build a new expression trait expression.
2572 /// By default, performs semantic analysis to build the new expression.
2573 /// Subclasses may override this routine to provide different behavior.
2574 ExprResult RebuildExpressionTrait(ExpressionTrait Trait,
2575 SourceLocation StartLoc,
2577 SourceLocation RParenLoc) {
2578 return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc);
2581 /// \brief Build a new (previously unresolved) declaration reference
2584 /// By default, performs semantic analysis to build the new expression.
2585 /// Subclasses may override this routine to provide different behavior.
2586 ExprResult RebuildDependentScopeDeclRefExpr(
2587 NestedNameSpecifierLoc QualifierLoc,
2588 SourceLocation TemplateKWLoc,
2589 const DeclarationNameInfo &NameInfo,
2590 const TemplateArgumentListInfo *TemplateArgs,
2591 bool IsAddressOfOperand,
2592 TypeSourceInfo **RecoveryTSI) {
2594 SS.Adopt(QualifierLoc);
2596 if (TemplateArgs || TemplateKWLoc.isValid())
2597 return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc, NameInfo,
2600 return getSema().BuildQualifiedDeclarationNameExpr(
2601 SS, NameInfo, IsAddressOfOperand, /*S*/nullptr, RecoveryTSI);
2604 /// \brief Build a new template-id expression.
2606 /// By default, performs semantic analysis to build the new expression.
2607 /// Subclasses may override this routine to provide different behavior.
2608 ExprResult RebuildTemplateIdExpr(const CXXScopeSpec &SS,
2609 SourceLocation TemplateKWLoc,
2612 const TemplateArgumentListInfo *TemplateArgs) {
2613 return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL,
2617 /// \brief Build a new object-construction expression.
2619 /// By default, performs semantic analysis to build the new expression.
2620 /// Subclasses may override this routine to provide different behavior.
2621 ExprResult RebuildCXXConstructExpr(QualType T,
2623 CXXConstructorDecl *Constructor,
2626 bool HadMultipleCandidates,
2627 bool ListInitialization,
2628 bool StdInitListInitialization,
2629 bool RequiresZeroInit,
2630 CXXConstructExpr::ConstructionKind ConstructKind,
2631 SourceRange ParenRange) {
2632 SmallVector<Expr*, 8> ConvertedArgs;
2633 if (getSema().CompleteConstructorCall(Constructor, Args, Loc,
2637 return getSema().BuildCXXConstructExpr(Loc, T, Constructor, IsElidable,
2639 HadMultipleCandidates,
2641 StdInitListInitialization,
2642 RequiresZeroInit, ConstructKind,
2646 /// \brief Build a new object-construction expression.
2648 /// By default, performs semantic analysis to build the new expression.
2649 /// Subclasses may override this routine to provide different behavior.
2650 ExprResult RebuildCXXTemporaryObjectExpr(TypeSourceInfo *TSInfo,
2651 SourceLocation LParenLoc,
2653 SourceLocation RParenLoc) {
2654 return getSema().BuildCXXTypeConstructExpr(TSInfo,
2660 /// \brief Build a new object-construction expression.
2662 /// By default, performs semantic analysis to build the new expression.
2663 /// Subclasses may override this routine to provide different behavior.
2664 ExprResult RebuildCXXUnresolvedConstructExpr(TypeSourceInfo *TSInfo,
2665 SourceLocation LParenLoc,
2667 SourceLocation RParenLoc) {
2668 return getSema().BuildCXXTypeConstructExpr(TSInfo,
2674 /// \brief Build a new member reference expression.
2676 /// By default, performs semantic analysis to build the new expression.
2677 /// Subclasses may override this routine to provide different behavior.
2678 ExprResult RebuildCXXDependentScopeMemberExpr(Expr *BaseE,
2681 SourceLocation OperatorLoc,
2682 NestedNameSpecifierLoc QualifierLoc,
2683 SourceLocation TemplateKWLoc,
2684 NamedDecl *FirstQualifierInScope,
2685 const DeclarationNameInfo &MemberNameInfo,
2686 const TemplateArgumentListInfo *TemplateArgs) {
2688 SS.Adopt(QualifierLoc);
2690 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
2691 OperatorLoc, IsArrow,
2693 FirstQualifierInScope,
2695 TemplateArgs, /*S*/nullptr);
2698 /// \brief Build a new member reference expression.
2700 /// By default, performs semantic analysis to build the new expression.
2701 /// Subclasses may override this routine to provide different behavior.
2702 ExprResult RebuildUnresolvedMemberExpr(Expr *BaseE, QualType BaseType,
2703 SourceLocation OperatorLoc,
2705 NestedNameSpecifierLoc QualifierLoc,
2706 SourceLocation TemplateKWLoc,
2707 NamedDecl *FirstQualifierInScope,
2709 const TemplateArgumentListInfo *TemplateArgs) {
2711 SS.Adopt(QualifierLoc);
2713 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
2714 OperatorLoc, IsArrow,
2716 FirstQualifierInScope,
2717 R, TemplateArgs, /*S*/nullptr);
2720 /// \brief Build a new noexcept expression.
2722 /// By default, performs semantic analysis to build the new expression.
2723 /// Subclasses may override this routine to provide different behavior.
2724 ExprResult RebuildCXXNoexceptExpr(SourceRange Range, Expr *Arg) {
2725 return SemaRef.BuildCXXNoexceptExpr(Range.getBegin(), Arg, Range.getEnd());
2728 /// \brief Build a new expression to compute the length of a parameter pack.
2729 ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc,
2731 SourceLocation PackLoc,
2732 SourceLocation RParenLoc,
2733 Optional<unsigned> Length,
2734 ArrayRef<TemplateArgument> PartialArgs) {
2735 return SizeOfPackExpr::Create(SemaRef.Context, OperatorLoc, Pack, PackLoc,
2736 RParenLoc, Length, PartialArgs);
2739 /// \brief Build a new Objective-C boxed expression.
2741 /// By default, performs semantic analysis to build the new expression.
2742 /// Subclasses may override this routine to provide different behavior.
2743 ExprResult RebuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) {
2744 return getSema().BuildObjCBoxedExpr(SR, ValueExpr);
2747 /// \brief Build a new Objective-C array literal.
2749 /// By default, performs semantic analysis to build the new expression.
2750 /// Subclasses may override this routine to provide different behavior.
2751 ExprResult RebuildObjCArrayLiteral(SourceRange Range,
2752 Expr **Elements, unsigned NumElements) {
2753 return getSema().BuildObjCArrayLiteral(Range,
2754 MultiExprArg(Elements, NumElements));
2757 ExprResult RebuildObjCSubscriptRefExpr(SourceLocation RB,
2758 Expr *Base, Expr *Key,
2759 ObjCMethodDecl *getterMethod,
2760 ObjCMethodDecl *setterMethod) {
2761 return getSema().BuildObjCSubscriptExpression(RB, Base, Key,
2762 getterMethod, setterMethod);
2765 /// \brief Build a new Objective-C dictionary literal.
2767 /// By default, performs semantic analysis to build the new expression.
2768 /// Subclasses may override this routine to provide different behavior.
2769 ExprResult RebuildObjCDictionaryLiteral(SourceRange Range,
2770 MutableArrayRef<ObjCDictionaryElement> Elements) {
2771 return getSema().BuildObjCDictionaryLiteral(Range, Elements);
2774 /// \brief Build a new Objective-C \@encode expression.
2776 /// By default, performs semantic analysis to build the new expression.
2777 /// Subclasses may override this routine to provide different behavior.
2778 ExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc,
2779 TypeSourceInfo *EncodeTypeInfo,
2780 SourceLocation RParenLoc) {
2781 return SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo, RParenLoc);
2784 /// \brief Build a new Objective-C class message.
2785 ExprResult RebuildObjCMessageExpr(TypeSourceInfo *ReceiverTypeInfo,
2787 ArrayRef<SourceLocation> SelectorLocs,
2788 ObjCMethodDecl *Method,
2789 SourceLocation LBracLoc,
2791 SourceLocation RBracLoc) {
2792 return SemaRef.BuildClassMessage(ReceiverTypeInfo,
2793 ReceiverTypeInfo->getType(),
2794 /*SuperLoc=*/SourceLocation(),
2795 Sel, Method, LBracLoc, SelectorLocs,
2799 /// \brief Build a new Objective-C instance message.
2800 ExprResult RebuildObjCMessageExpr(Expr *Receiver,
2802 ArrayRef<SourceLocation> SelectorLocs,
2803 ObjCMethodDecl *Method,
2804 SourceLocation LBracLoc,
2806 SourceLocation RBracLoc) {
2807 return SemaRef.BuildInstanceMessage(Receiver,
2808 Receiver->getType(),
2809 /*SuperLoc=*/SourceLocation(),
2810 Sel, Method, LBracLoc, SelectorLocs,
2814 /// \brief Build a new Objective-C instance/class message to 'super'.
2815 ExprResult RebuildObjCMessageExpr(SourceLocation SuperLoc,
2817 ArrayRef<SourceLocation> SelectorLocs,
2819 ObjCMethodDecl *Method,
2820 SourceLocation LBracLoc,
2822 SourceLocation RBracLoc) {
2823 return Method->isInstanceMethod() ? SemaRef.BuildInstanceMessage(nullptr,
2826 Sel, Method, LBracLoc, SelectorLocs,
2828 : SemaRef.BuildClassMessage(nullptr,
2831 Sel, Method, LBracLoc, SelectorLocs,
2837 /// \brief Build a new Objective-C ivar reference expression.
2839 /// By default, performs semantic analysis to build the new expression.
2840 /// Subclasses may override this routine to provide different behavior.
2841 ExprResult RebuildObjCIvarRefExpr(Expr *BaseArg, ObjCIvarDecl *Ivar,
2842 SourceLocation IvarLoc,
2843 bool IsArrow, bool IsFreeIvar) {
2844 // FIXME: We lose track of the IsFreeIvar bit.
2846 DeclarationNameInfo NameInfo(Ivar->getDeclName(), IvarLoc);
2847 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
2848 /*FIXME:*/IvarLoc, IsArrow,
2849 SS, SourceLocation(),
2850 /*FirstQualifierInScope=*/nullptr,
2852 /*TemplateArgs=*/nullptr,
2856 /// \brief Build a new Objective-C property reference expression.
2858 /// By default, performs semantic analysis to build the new expression.
2859 /// Subclasses may override this routine to provide different behavior.
2860 ExprResult RebuildObjCPropertyRefExpr(Expr *BaseArg,
2861 ObjCPropertyDecl *Property,
2862 SourceLocation PropertyLoc) {
2864 DeclarationNameInfo NameInfo(Property->getDeclName(), PropertyLoc);
2865 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
2866 /*FIXME:*/PropertyLoc,
2868 SS, SourceLocation(),
2869 /*FirstQualifierInScope=*/nullptr,
2871 /*TemplateArgs=*/nullptr,
2875 /// \brief Build a new Objective-C property reference expression.
2877 /// By default, performs semantic analysis to build the new expression.
2878 /// Subclasses may override this routine to provide different behavior.
2879 ExprResult RebuildObjCPropertyRefExpr(Expr *Base, QualType T,
2880 ObjCMethodDecl *Getter,
2881 ObjCMethodDecl *Setter,
2882 SourceLocation PropertyLoc) {
2883 // Since these expressions can only be value-dependent, we do not
2884 // need to perform semantic analysis again.
2886 new (getSema().Context) ObjCPropertyRefExpr(Getter, Setter, T,
2887 VK_LValue, OK_ObjCProperty,
2888 PropertyLoc, Base));
2891 /// \brief Build a new Objective-C "isa" expression.
2893 /// By default, performs semantic analysis to build the new expression.
2894 /// Subclasses may override this routine to provide different behavior.
2895 ExprResult RebuildObjCIsaExpr(Expr *BaseArg, SourceLocation IsaLoc,
2896 SourceLocation OpLoc, bool IsArrow) {
2898 DeclarationNameInfo NameInfo(&getSema().Context.Idents.get("isa"), IsaLoc);
2899 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
2901 SS, SourceLocation(),
2902 /*FirstQualifierInScope=*/nullptr,
2904 /*TemplateArgs=*/nullptr,
2908 /// \brief Build a new shuffle vector expression.
2910 /// By default, performs semantic analysis to build the new expression.
2911 /// Subclasses may override this routine to provide different behavior.
2912 ExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc,
2913 MultiExprArg SubExprs,
2914 SourceLocation RParenLoc) {
2915 // Find the declaration for __builtin_shufflevector
2916 const IdentifierInfo &Name
2917 = SemaRef.Context.Idents.get("__builtin_shufflevector");
2918 TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl();
2919 DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name));
2920 assert(!Lookup.empty() && "No __builtin_shufflevector?");
2922 // Build a reference to the __builtin_shufflevector builtin
2923 FunctionDecl *Builtin = cast<FunctionDecl>(Lookup.front());
2924 Expr *Callee = new (SemaRef.Context) DeclRefExpr(Builtin, false,
2925 SemaRef.Context.BuiltinFnTy,
2926 VK_RValue, BuiltinLoc);
2927 QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType());
2928 Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy,
2929 CK_BuiltinFnToFnPtr).get();
2931 // Build the CallExpr
2932 ExprResult TheCall = new (SemaRef.Context) CallExpr(
2933 SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(),
2934 Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc);
2936 // Type-check the __builtin_shufflevector expression.
2937 return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.get()));
2940 /// \brief Build a new convert vector expression.
2941 ExprResult RebuildConvertVectorExpr(SourceLocation BuiltinLoc,
2942 Expr *SrcExpr, TypeSourceInfo *DstTInfo,
2943 SourceLocation RParenLoc) {
2944 return SemaRef.SemaConvertVectorExpr(SrcExpr, DstTInfo,
2945 BuiltinLoc, RParenLoc);
2948 /// \brief Build a new template argument pack expansion.
2950 /// By default, performs semantic analysis to build a new pack expansion
2951 /// for a template argument. Subclasses may override this routine to provide
2952 /// different behavior.
2953 TemplateArgumentLoc RebuildPackExpansion(TemplateArgumentLoc Pattern,
2954 SourceLocation EllipsisLoc,
2955 Optional<unsigned> NumExpansions) {
2956 switch (Pattern.getArgument().getKind()) {
2957 case TemplateArgument::Expression: {
2959 = getSema().CheckPackExpansion(Pattern.getSourceExpression(),
2960 EllipsisLoc, NumExpansions);
2961 if (Result.isInvalid())
2962 return TemplateArgumentLoc();
2964 return TemplateArgumentLoc(Result.get(), Result.get());
2967 case TemplateArgument::Template:
2968 return TemplateArgumentLoc(TemplateArgument(
2969 Pattern.getArgument().getAsTemplate(),
2971 Pattern.getTemplateQualifierLoc(),
2972 Pattern.getTemplateNameLoc(),
2975 case TemplateArgument::Null:
2976 case TemplateArgument::Integral:
2977 case TemplateArgument::Declaration:
2978 case TemplateArgument::Pack:
2979 case TemplateArgument::TemplateExpansion:
2980 case TemplateArgument::NullPtr:
2981 llvm_unreachable("Pack expansion pattern has no parameter packs");
2983 case TemplateArgument::Type:
2984 if (TypeSourceInfo *Expansion
2985 = getSema().CheckPackExpansion(Pattern.getTypeSourceInfo(),
2988 return TemplateArgumentLoc(TemplateArgument(Expansion->getType()),
2993 return TemplateArgumentLoc();
2996 /// \brief Build a new expression pack expansion.
2998 /// By default, performs semantic analysis to build a new pack expansion
2999 /// for an expression. Subclasses may override this routine to provide
3000 /// different behavior.
3001 ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
3002 Optional<unsigned> NumExpansions) {
3003 return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions);
3006 /// \brief Build a new C++1z fold-expression.
3008 /// By default, performs semantic analysis in order to build a new fold
3010 ExprResult RebuildCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
3011 BinaryOperatorKind Operator,
3012 SourceLocation EllipsisLoc, Expr *RHS,
3013 SourceLocation RParenLoc) {
3014 return getSema().BuildCXXFoldExpr(LParenLoc, LHS, Operator, EllipsisLoc,
3018 /// \brief Build an empty C++1z fold-expression with the given operator.
3020 /// By default, produces the fallback value for the fold-expression, or
3021 /// produce an error if there is no fallback value.
3022 ExprResult RebuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
3023 BinaryOperatorKind Operator) {
3024 return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator);
3027 /// \brief Build a new atomic operation expression.
3029 /// By default, performs semantic analysis to build the new expression.
3030 /// Subclasses may override this routine to provide different behavior.
3031 ExprResult RebuildAtomicExpr(SourceLocation BuiltinLoc,
3032 MultiExprArg SubExprs,
3034 AtomicExpr::AtomicOp Op,
3035 SourceLocation RParenLoc) {
3036 // Just create the expression; there is not any interesting semantic
3037 // analysis here because we can't actually build an AtomicExpr until
3038 // we are sure it is semantically sound.
3039 return new (SemaRef.Context) AtomicExpr(BuiltinLoc, SubExprs, RetTy, Op,
3044 TypeLoc TransformTypeInObjectScope(TypeLoc TL,
3045 QualType ObjectType,
3046 NamedDecl *FirstQualifierInScope,
3049 TypeSourceInfo *TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
3050 QualType ObjectType,
3051 NamedDecl *FirstQualifierInScope,
3054 TypeSourceInfo *TransformTSIInObjectScope(TypeLoc TL, QualType ObjectType,
3055 NamedDecl *FirstQualifierInScope,
3059 template<typename Derived>
3060 StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) {
3064 switch (S->getStmtClass()) {
3065 case Stmt::NoStmtClass: break;
3067 // Transform individual statement nodes
3068 #define STMT(Node, Parent) \
3069 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
3070 #define ABSTRACT_STMT(Node)
3071 #define EXPR(Node, Parent)
3072 #include "clang/AST/StmtNodes.inc"
3074 // Transform expressions by calling TransformExpr.
3075 #define STMT(Node, Parent)
3076 #define ABSTRACT_STMT(Stmt)
3077 #define EXPR(Node, Parent) case Stmt::Node##Class:
3078 #include "clang/AST/StmtNodes.inc"
3080 ExprResult E = getDerived().TransformExpr(cast<Expr>(S));
3084 return getSema().ActOnExprStmt(E);
3091 template<typename Derived>
3092 OMPClause *TreeTransform<Derived>::TransformOMPClause(OMPClause *S) {
3096 switch (S->getClauseKind()) {
3098 // Transform individual clause nodes
3099 #define OPENMP_CLAUSE(Name, Class) \
3100 case OMPC_ ## Name : \
3101 return getDerived().Transform ## Class(cast<Class>(S));
3102 #include "clang/Basic/OpenMPKinds.def"
3109 template<typename Derived>
3110 ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) {
3114 switch (E->getStmtClass()) {
3115 case Stmt::NoStmtClass: break;
3116 #define STMT(Node, Parent) case Stmt::Node##Class: break;
3117 #define ABSTRACT_STMT(Stmt)
3118 #define EXPR(Node, Parent) \
3119 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
3120 #include "clang/AST/StmtNodes.inc"
3126 template<typename Derived>
3127 ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init,
3129 // Initializers are instantiated like expressions, except that various outer
3130 // layers are stripped.
3134 if (ExprWithCleanups *ExprTemp = dyn_cast<ExprWithCleanups>(Init))
3135 Init = ExprTemp->getSubExpr();
3137 if (MaterializeTemporaryExpr *MTE = dyn_cast<MaterializeTemporaryExpr>(Init))
3138 Init = MTE->GetTemporaryExpr();
3140 while (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(Init))
3141 Init = Binder->getSubExpr();
3143 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Init))
3144 Init = ICE->getSubExprAsWritten();
3146 if (CXXStdInitializerListExpr *ILE =
3147 dyn_cast<CXXStdInitializerListExpr>(Init))
3148 return TransformInitializer(ILE->getSubExpr(), NotCopyInit);
3150 // If this is copy-initialization, we only need to reconstruct
3151 // InitListExprs. Other forms of copy-initialization will be a no-op if
3152 // the initializer is already the right type.
3153 CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init);
3154 if (!NotCopyInit && !(Construct && Construct->isListInitialization()))
3155 return getDerived().TransformExpr(Init);
3157 // Revert value-initialization back to empty parens.
3158 if (CXXScalarValueInitExpr *VIE = dyn_cast<CXXScalarValueInitExpr>(Init)) {
3159 SourceRange Parens = VIE->getSourceRange();
3160 return getDerived().RebuildParenListExpr(Parens.getBegin(), None,
3164 // FIXME: We shouldn't build ImplicitValueInitExprs for direct-initialization.
3165 if (isa<ImplicitValueInitExpr>(Init))
3166 return getDerived().RebuildParenListExpr(SourceLocation(), None,
3169 // Revert initialization by constructor back to a parenthesized or braced list
3170 // of expressions. Any other form of initializer can just be reused directly.
3171 if (!Construct || isa<CXXTemporaryObjectExpr>(Construct))
3172 return getDerived().TransformExpr(Init);
3174 // If the initialization implicitly converted an initializer list to a
3175 // std::initializer_list object, unwrap the std::initializer_list too.
3176 if (Construct && Construct->isStdInitListInitialization())
3177 return TransformInitializer(Construct->getArg(0), NotCopyInit);
3179 SmallVector<Expr*, 8> NewArgs;
3180 bool ArgChanged = false;
3181 if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(),
3182 /*IsCall*/true, NewArgs, &ArgChanged))
3185 // If this was list initialization, revert to list form.
3186 if (Construct->isListInitialization())
3187 return getDerived().RebuildInitList(Construct->getLocStart(), NewArgs,
3188 Construct->getLocEnd(),
3189 Construct->getType());
3191 // Build a ParenListExpr to represent anything else.
3192 SourceRange Parens = Construct->getParenOrBraceRange();
3193 if (Parens.isInvalid()) {
3194 // This was a variable declaration's initialization for which no initializer
3196 assert(NewArgs.empty() &&
3197 "no parens or braces but have direct init with arguments?");
3200 return getDerived().RebuildParenListExpr(Parens.getBegin(), NewArgs,
3204 template<typename Derived>
3205 bool TreeTransform<Derived>::TransformExprs(Expr *const *Inputs,
3208 SmallVectorImpl<Expr *> &Outputs,
3210 for (unsigned I = 0; I != NumInputs; ++I) {
3211 // If requested, drop call arguments that need to be dropped.
3212 if (IsCall && getDerived().DropCallArgument(Inputs[I])) {
3219 if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(Inputs[I])) {
3220 Expr *Pattern = Expansion->getPattern();
3222 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
3223 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
3224 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
3226 // Determine whether the set of unexpanded parameter packs can and should
3229 bool RetainExpansion = false;
3230 Optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions();
3231 Optional<unsigned> NumExpansions = OrigNumExpansions;
3232 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
3233 Pattern->getSourceRange(),
3235 Expand, RetainExpansion,
3240 // The transform has determined that we should perform a simple
3241 // transformation on the pack expansion, producing another pack
3243 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
3244 ExprResult OutPattern = getDerived().TransformExpr(Pattern);
3245 if (OutPattern.isInvalid())
3248 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(),
3249 Expansion->getEllipsisLoc(),
3251 if (Out.isInvalid())
3256 Outputs.push_back(Out.get());
3260 // Record right away that the argument was changed. This needs
3261 // to happen even if the array expands to nothing.
3262 if (ArgChanged) *ArgChanged = true;
3264 // The transform has determined that we should perform an elementwise
3265 // expansion of the pattern. Do so.
3266 for (unsigned I = 0; I != *NumExpansions; ++I) {
3267 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
3268 ExprResult Out = getDerived().TransformExpr(Pattern);
3269 if (Out.isInvalid())
3272 // FIXME: Can this happen? We should not try to expand the pack
3274 if (Out.get()->containsUnexpandedParameterPack()) {
3275 Out = getDerived().RebuildPackExpansion(
3276 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
3277 if (Out.isInvalid())
3281 Outputs.push_back(Out.get());
3284 // If we're supposed to retain a pack expansion, do so by temporarily
3285 // forgetting the partially-substituted parameter pack.
3286 if (RetainExpansion) {
3287 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
3289 ExprResult Out = getDerived().TransformExpr(Pattern);
3290 if (Out.isInvalid())
3293 Out = getDerived().RebuildPackExpansion(
3294 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
3295 if (Out.isInvalid())
3298 Outputs.push_back(Out.get());
3305 IsCall ? getDerived().TransformInitializer(Inputs[I], /*DirectInit*/false)
3306 : getDerived().TransformExpr(Inputs[I]);
3307 if (Result.isInvalid())
3310 if (Result.get() != Inputs[I] && ArgChanged)
3313 Outputs.push_back(Result.get());
3319 template<typename Derived>
3320 NestedNameSpecifierLoc
3321 TreeTransform<Derived>::TransformNestedNameSpecifierLoc(
3322 NestedNameSpecifierLoc NNS,
3323 QualType ObjectType,
3324 NamedDecl *FirstQualifierInScope) {
3325 SmallVector<NestedNameSpecifierLoc, 4> Qualifiers;
3326 for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier;
3327 Qualifier = Qualifier.getPrefix())
3328 Qualifiers.push_back(Qualifier);
3331 while (!Qualifiers.empty()) {
3332 NestedNameSpecifierLoc Q = Qualifiers.pop_back_val();
3333 NestedNameSpecifier *QNNS = Q.getNestedNameSpecifier();
3335 switch (QNNS->getKind()) {
3336 case NestedNameSpecifier::Identifier:
3337 if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/nullptr,
3338 *QNNS->getAsIdentifier(),
3339 Q.getLocalBeginLoc(),
3341 ObjectType, false, SS,
3342 FirstQualifierInScope, false))
3343 return NestedNameSpecifierLoc();
3347 case NestedNameSpecifier::Namespace: {
3349 = cast_or_null<NamespaceDecl>(
3350 getDerived().TransformDecl(
3351 Q.getLocalBeginLoc(),
3352 QNNS->getAsNamespace()));
3353 SS.Extend(SemaRef.Context, NS, Q.getLocalBeginLoc(), Q.getLocalEndLoc());
3357 case NestedNameSpecifier::NamespaceAlias: {
3358 NamespaceAliasDecl *Alias
3359 = cast_or_null<NamespaceAliasDecl>(
3360 getDerived().TransformDecl(Q.getLocalBeginLoc(),
3361 QNNS->getAsNamespaceAlias()));
3362 SS.Extend(SemaRef.Context, Alias, Q.getLocalBeginLoc(),
3363 Q.getLocalEndLoc());
3367 case NestedNameSpecifier::Global:
3368 // There is no meaningful transformation that one could perform on the
3370 SS.MakeGlobal(SemaRef.Context, Q.getBeginLoc());
3373 case NestedNameSpecifier::Super: {
3375 cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
3376 SourceLocation(), QNNS->getAsRecordDecl()));
3377 SS.MakeSuper(SemaRef.Context, RD, Q.getBeginLoc(), Q.getEndLoc());
3381 case NestedNameSpecifier::TypeSpecWithTemplate:
3382 case NestedNameSpecifier::TypeSpec: {
3383 TypeLoc TL = TransformTypeInObjectScope(Q.getTypeLoc(), ObjectType,
3384 FirstQualifierInScope, SS);
3387 return NestedNameSpecifierLoc();
3389 if (TL.getType()->isDependentType() || TL.getType()->isRecordType() ||
3390 (SemaRef.getLangOpts().CPlusPlus11 &&
3391 TL.getType()->isEnumeralType())) {
3392 assert(!TL.getType().hasLocalQualifiers() &&
3393 "Can't get cv-qualifiers here");
3394 if (TL.getType()->isEnumeralType())
3395 SemaRef.Diag(TL.getBeginLoc(),
3396 diag::warn_cxx98_compat_enum_nested_name_spec);
3397 SS.Extend(SemaRef.Context, /*FIXME:*/SourceLocation(), TL,
3398 Q.getLocalEndLoc());
3401 // If the nested-name-specifier is an invalid type def, don't emit an
3402 // error because a previous error should have already been emitted.
3403 TypedefTypeLoc TTL = TL.getAs<TypedefTypeLoc>();
3404 if (!TTL || !TTL.getTypedefNameDecl()->isInvalidDecl()) {
3405 SemaRef.Diag(TL.getBeginLoc(), diag::err_nested_name_spec_non_tag)
3406 << TL.getType() << SS.getRange();
3408 return NestedNameSpecifierLoc();
3412 // The qualifier-in-scope and object type only apply to the leftmost entity.
3413 FirstQualifierInScope = nullptr;
3414 ObjectType = QualType();
3417 // Don't rebuild the nested-name-specifier if we don't have to.
3418 if (SS.getScopeRep() == NNS.getNestedNameSpecifier() &&
3419 !getDerived().AlwaysRebuild())
3422 // If we can re-use the source-location data from the original
3423 // nested-name-specifier, do so.
3424 if (SS.location_size() == NNS.getDataLength() &&
3425 memcmp(SS.location_data(), NNS.getOpaqueData(), SS.location_size()) == 0)
3426 return NestedNameSpecifierLoc(SS.getScopeRep(), NNS.getOpaqueData());
3428 // Allocate new nested-name-specifier location information.
3429 return SS.getWithLocInContext(SemaRef.Context);
3432 template<typename Derived>
3434 TreeTransform<Derived>
3435 ::TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo) {
3436 DeclarationName Name = NameInfo.getName();
3438 return DeclarationNameInfo();
3440 switch (Name.getNameKind()) {
3441 case DeclarationName::Identifier:
3442 case DeclarationName::ObjCZeroArgSelector:
3443 case DeclarationName::ObjCOneArgSelector:
3444 case DeclarationName::ObjCMultiArgSelector:
3445 case DeclarationName::CXXOperatorName:
3446 case DeclarationName::CXXLiteralOperatorName:
3447 case DeclarationName::CXXUsingDirective:
3450 case DeclarationName::CXXConstructorName:
3451 case DeclarationName::CXXDestructorName:
3452 case DeclarationName::CXXConversionFunctionName: {
3453 TypeSourceInfo *NewTInfo;
3454 CanQualType NewCanTy;
3455 if (TypeSourceInfo *OldTInfo = NameInfo.getNamedTypeInfo()) {
3456 NewTInfo = getDerived().TransformType(OldTInfo);
3458 return DeclarationNameInfo();
3459 NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->getType());
3463 TemporaryBase Rebase(*this, NameInfo.getLoc(), Name);
3464 QualType NewT = getDerived().TransformType(Name.getCXXNameType());
3466 return DeclarationNameInfo();
3467 NewCanTy = SemaRef.Context.getCanonicalType(NewT);
3470 DeclarationName NewName
3471 = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.getNameKind(),
3473 DeclarationNameInfo NewNameInfo(NameInfo);
3474 NewNameInfo.setName(NewName);
3475 NewNameInfo.setNamedTypeInfo(NewTInfo);
3480 llvm_unreachable("Unknown name kind.");
3483 template<typename Derived>
3485 TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS,
3487 SourceLocation NameLoc,
3488 QualType ObjectType,
3489 NamedDecl *FirstQualifierInScope) {
3490 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) {
3491 TemplateDecl *Template = QTN->getTemplateDecl();
3492 assert(Template && "qualified template name must refer to a template");
3494 TemplateDecl *TransTemplate
3495 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
3498 return TemplateName();
3500 if (!getDerived().AlwaysRebuild() &&
3501 SS.getScopeRep() == QTN->getQualifier() &&
3502 TransTemplate == Template)
3505 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
3509 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) {
3510 if (SS.getScopeRep()) {
3511 // These apply to the scope specifier, not the template.
3512 ObjectType = QualType();
3513 FirstQualifierInScope = nullptr;
3516 if (!getDerived().AlwaysRebuild() &&
3517 SS.getScopeRep() == DTN->getQualifier() &&
3518 ObjectType.isNull())
3521 if (DTN->isIdentifier()) {
3522 return getDerived().RebuildTemplateName(SS,
3523 *DTN->getIdentifier(),
3526 FirstQualifierInScope);
3529 return getDerived().RebuildTemplateName(SS, DTN->getOperator(), NameLoc,
3533 if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
3534 TemplateDecl *TransTemplate
3535 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
3538 return TemplateName();
3540 if (!getDerived().AlwaysRebuild() &&
3541 TransTemplate == Template)
3544 return TemplateName(TransTemplate);
3547 if (SubstTemplateTemplateParmPackStorage *SubstPack
3548 = Name.getAsSubstTemplateTemplateParmPack()) {
3549 TemplateTemplateParmDecl *TransParam
3550 = cast_or_null<TemplateTemplateParmDecl>(
3551 getDerived().TransformDecl(NameLoc, SubstPack->getParameterPack()));
3553 return TemplateName();
3555 if (!getDerived().AlwaysRebuild() &&
3556 TransParam == SubstPack->getParameterPack())
3559 return getDerived().RebuildTemplateName(TransParam,
3560 SubstPack->getArgumentPack());
3563 // These should be getting filtered out before they reach the AST.
3564 llvm_unreachable("overloaded function decl survived to here");
3567 template<typename Derived>
3568 void TreeTransform<Derived>::InventTemplateArgumentLoc(
3569 const TemplateArgument &Arg,
3570 TemplateArgumentLoc &Output) {
3571 SourceLocation Loc = getDerived().getBaseLocation();
3572 switch (Arg.getKind()) {
3573 case TemplateArgument::Null:
3574 llvm_unreachable("null template argument in TreeTransform");
3577 case TemplateArgument::Type:
3578 Output = TemplateArgumentLoc(Arg,
3579 SemaRef.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc));
3583 case TemplateArgument::Template:
3584 case TemplateArgument::TemplateExpansion: {
3585 NestedNameSpecifierLocBuilder Builder;
3586 TemplateName Template = Arg.getAsTemplateOrTemplatePattern();
3587 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
3588 Builder.MakeTrivial(SemaRef.Context, DTN->getQualifier(), Loc);
3589 else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
3590 Builder.MakeTrivial(SemaRef.Context, QTN->getQualifier(), Loc);
3592 if (Arg.getKind() == TemplateArgument::Template)
3593 Output = TemplateArgumentLoc(Arg,
3594 Builder.getWithLocInContext(SemaRef.Context),
3597 Output = TemplateArgumentLoc(Arg,
3598 Builder.getWithLocInContext(SemaRef.Context),
3604 case TemplateArgument::Expression:
3605 Output = TemplateArgumentLoc(Arg, Arg.getAsExpr());
3608 case TemplateArgument::Declaration:
3609 case TemplateArgument::Integral:
3610 case TemplateArgument::Pack:
3611 case TemplateArgument::NullPtr:
3612 Output = TemplateArgumentLoc(Arg, TemplateArgumentLocInfo());
3617 template<typename Derived>
3618 bool TreeTransform<Derived>::TransformTemplateArgument(
3619 const TemplateArgumentLoc &Input,
3620 TemplateArgumentLoc &Output, bool Uneval) {
3621 const TemplateArgument &Arg = Input.getArgument();
3622 switch (Arg.getKind()) {
3623 case TemplateArgument::Null:
3624 case TemplateArgument::Integral:
3625 case TemplateArgument::Pack:
3626 case TemplateArgument::Declaration:
3627 case TemplateArgument::NullPtr:
3628 llvm_unreachable("Unexpected TemplateArgument");
3630 case TemplateArgument::Type: {
3631 TypeSourceInfo *DI = Input.getTypeSourceInfo();
3633 DI = InventTypeSourceInfo(Input.getArgument().getAsType());
3635 DI = getDerived().TransformType(DI);
3636 if (!DI) return true;
3638 Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
3642 case TemplateArgument::Template: {
3643 NestedNameSpecifierLoc QualifierLoc = Input.getTemplateQualifierLoc();
3645 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
3651 SS.Adopt(QualifierLoc);
3652 TemplateName Template
3653 = getDerived().TransformTemplateName(SS, Arg.getAsTemplate(),
3654 Input.getTemplateNameLoc());
3655 if (Template.isNull())
3658 Output = TemplateArgumentLoc(TemplateArgument(Template), QualifierLoc,
3659 Input.getTemplateNameLoc());
3663 case TemplateArgument::TemplateExpansion:
3664 llvm_unreachable("Caller should expand pack expansions");
3666 case TemplateArgument::Expression: {
3667 // Template argument expressions are constant expressions.
3668 EnterExpressionEvaluationContext Unevaluated(
3669 getSema(), Uneval ? Sema::Unevaluated : Sema::ConstantEvaluated);
3671 Expr *InputExpr = Input.getSourceExpression();
3672 if (!InputExpr) InputExpr = Input.getArgument().getAsExpr();
3674 ExprResult E = getDerived().TransformExpr(InputExpr);
3675 E = SemaRef.ActOnConstantExpression(E);
3676 if (E.isInvalid()) return true;
3677 Output = TemplateArgumentLoc(TemplateArgument(E.get()), E.get());
3682 // Work around bogus GCC warning
3686 /// \brief Iterator adaptor that invents template argument location information
3687 /// for each of the template arguments in its underlying iterator.
3688 template<typename Derived, typename InputIterator>
3689 class TemplateArgumentLocInventIterator {
3690 TreeTransform<Derived> &Self;
3694 typedef TemplateArgumentLoc value_type;
3695 typedef TemplateArgumentLoc reference;
3696 typedef typename std::iterator_traits<InputIterator>::difference_type
3698 typedef std::input_iterator_tag iterator_category;
3701 TemplateArgumentLoc Arg;
3704 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }
3706 const TemplateArgumentLoc *operator->() const { return &Arg; }
3709 TemplateArgumentLocInventIterator() { }
3711 explicit TemplateArgumentLocInventIterator(TreeTransform<Derived> &Self,
3713 : Self(Self), Iter(Iter) { }
3715 TemplateArgumentLocInventIterator &operator++() {
3720 TemplateArgumentLocInventIterator operator++(int) {
3721 TemplateArgumentLocInventIterator Old(*this);
3726 reference operator*() const {
3727 TemplateArgumentLoc Result;
3728 Self.InventTemplateArgumentLoc(*Iter, Result);
3732 pointer operator->() const { return pointer(**this); }
3734 friend bool operator==(const TemplateArgumentLocInventIterator &X,
3735 const TemplateArgumentLocInventIterator &Y) {
3736 return X.Iter == Y.Iter;
3739 friend bool operator!=(const TemplateArgumentLocInventIterator &X,
3740 const TemplateArgumentLocInventIterator &Y) {
3741 return X.Iter != Y.Iter;
3745 template<typename Derived>
3746 template<typename InputIterator>
3747 bool TreeTransform<Derived>::TransformTemplateArguments(
3748 InputIterator First, InputIterator Last, TemplateArgumentListInfo &Outputs,
3750 for (; First != Last; ++First) {
3751 TemplateArgumentLoc Out;
3752 TemplateArgumentLoc In = *First;
3754 if (In.getArgument().getKind() == TemplateArgument::Pack) {
3755 // Unpack argument packs, which we translate them into separate
3757 // FIXME: We could do much better if we could guarantee that the
3758 // TemplateArgumentLocInfo for the pack expansion would be usable for
3759 // all of the template arguments in the argument pack.
3760 typedef TemplateArgumentLocInventIterator<Derived,
3761 TemplateArgument::pack_iterator>
3763 if (TransformTemplateArguments(PackLocIterator(*this,
3764 In.getArgument().pack_begin()),
3765 PackLocIterator(*this,
3766 In.getArgument().pack_end()),
3773 if (In.getArgument().isPackExpansion()) {
3774 // We have a pack expansion, for which we will be substituting into
3776 SourceLocation Ellipsis;
3777 Optional<unsigned> OrigNumExpansions;
3778 TemplateArgumentLoc Pattern
3779 = getSema().getTemplateArgumentPackExpansionPattern(
3780 In, Ellipsis, OrigNumExpansions);
3782 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
3783 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
3784 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
3786 // Determine whether the set of unexpanded parameter packs can and should
3789 bool RetainExpansion = false;
3790 Optional<unsigned> NumExpansions = OrigNumExpansions;
3791 if (getDerived().TryExpandParameterPacks(Ellipsis,
3792 Pattern.getSourceRange(),
3800 // The transform has determined that we should perform a simple
3801 // transformation on the pack expansion, producing another pack
3803 TemplateArgumentLoc OutPattern;
3804 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
3805 if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))
3808 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,
3810 if (Out.getArgument().isNull())
3813 Outputs.addArgument(Out);
3817 // The transform has determined that we should perform an elementwise
3818 // expansion of the pattern. Do so.
3819 for (unsigned I = 0; I != *NumExpansions; ++I) {
3820 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
3822 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
3825 if (Out.getArgument().containsUnexpandedParameterPack()) {
3826 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
3828 if (Out.getArgument().isNull())
3832 Outputs.addArgument(Out);
3835 // If we're supposed to retain a pack expansion, do so by temporarily
3836 // forgetting the partially-substituted parameter pack.
3837 if (RetainExpansion) {
3838 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
3840 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
3843 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
3845 if (Out.getArgument().isNull())
3848 Outputs.addArgument(Out);
3855 if (getDerived().TransformTemplateArgument(In, Out, Uneval))
3858 Outputs.addArgument(Out);
3865 //===----------------------------------------------------------------------===//
3866 // Type transformation
3867 //===----------------------------------------------------------------------===//
3869 template<typename Derived>
3870 QualType TreeTransform<Derived>::TransformType(QualType T) {
3871 if (getDerived().AlreadyTransformed(T))
3874 // Temporary workaround. All of these transformations should
3875 // eventually turn into transformations on TypeLocs.
3876 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
3877 getDerived().getBaseLocation());
3879 TypeSourceInfo *NewDI = getDerived().TransformType(DI);
3884 return NewDI->getType();
3887 template<typename Derived>
3888 TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *DI) {
3889 // Refine the base location to the type's location.
3890 TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(),
3891 getDerived().getBaseEntity());
3892 if (getDerived().AlreadyTransformed(DI->getType()))
3897 TypeLoc TL = DI->getTypeLoc();
3898 TLB.reserve(TL.getFullDataSize());
3900 QualType Result = getDerived().TransformType(TLB, TL);
3901 if (Result.isNull())
3904 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
3907 template<typename Derived>
3909 TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) {
3910 switch (T.getTypeLocClass()) {
3911 #define ABSTRACT_TYPELOC(CLASS, PARENT)
3912 #define TYPELOC(CLASS, PARENT) \
3913 case TypeLoc::CLASS: \
3914 return getDerived().Transform##CLASS##Type(TLB, \
3915 T.castAs<CLASS##TypeLoc>());
3916 #include "clang/AST/TypeLocNodes.def"
3919 llvm_unreachable("unhandled type loc!");
3922 /// FIXME: By default, this routine adds type qualifiers only to types
3923 /// that can have qualifiers, and silently suppresses those qualifiers
3924 /// that are not permitted (e.g., qualifiers on reference or function
3925 /// types). This is the right thing for template instantiation, but
3926 /// probably not for other clients.
3927 template<typename Derived>
3929 TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB,
3930 QualifiedTypeLoc T) {
3931 Qualifiers Quals = T.getType().getLocalQualifiers();
3933 QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc());
3934 if (Result.isNull())
3937 // Silently suppress qualifiers if the result type can't be qualified.
3938 // FIXME: this is the right thing for template instantiation, but
3939 // probably not for other clients.
3940 if (Result->isFunctionType() || Result->isReferenceType())
3943 // Suppress Objective-C lifetime qualifiers if they don't make sense for the
3945 if (Quals.hasObjCLifetime()) {
3946 if (!Result->isObjCLifetimeType() && !Result->isDependentType())
3947 Quals.removeObjCLifetime();
3948 else if (Result.getObjCLifetime()) {
3950 // A lifetime qualifier applied to a substituted template parameter
3951 // overrides the lifetime qualifier from the template argument.
3952 const AutoType *AutoTy;
3953 if (const SubstTemplateTypeParmType *SubstTypeParam
3954 = dyn_cast<SubstTemplateTypeParmType>(Result)) {
3955 QualType Replacement = SubstTypeParam->getReplacementType();
3956 Qualifiers Qs = Replacement.getQualifiers();
3957 Qs.removeObjCLifetime();
3959 = SemaRef.Context.getQualifiedType(Replacement.getUnqualifiedType(),
3961 Result = SemaRef.Context.getSubstTemplateTypeParmType(
3962 SubstTypeParam->getReplacedParameter(),
3964 TLB.TypeWasModifiedSafely(Result);
3965 } else if ((AutoTy = dyn_cast<AutoType>(Result)) && AutoTy->isDeduced()) {
3966 // 'auto' types behave the same way as template parameters.
3967 QualType Deduced = AutoTy->getDeducedType();
3968 Qualifiers Qs = Deduced.getQualifiers();
3969 Qs.removeObjCLifetime();
3970 Deduced = SemaRef.Context.getQualifiedType(Deduced.getUnqualifiedType(),
3972 Result = SemaRef.Context.getAutoType(Deduced, AutoTy->getKeyword(),
3973 AutoTy->isDependentType());
3974 TLB.TypeWasModifiedSafely(Result);
3976 // Otherwise, complain about the addition of a qualifier to an
3977 // already-qualified type.
3978 SourceRange R = T.getUnqualifiedLoc().getSourceRange();
3979 SemaRef.Diag(R.getBegin(), diag::err_attr_objc_ownership_redundant)
3982 Quals.removeObjCLifetime();
3986 if (!Quals.empty()) {
3987 Result = SemaRef.BuildQualifiedType(Result, T.getBeginLoc(), Quals);
3988 // BuildQualifiedType might not add qualifiers if they are invalid.
3989 if (Result.hasLocalQualifiers())
3990 TLB.push<QualifiedTypeLoc>(Result);
3991 // No location information to preserve.
3997 template<typename Derived>
3999 TreeTransform<Derived>::TransformTypeInObjectScope(TypeLoc TL,
4000 QualType ObjectType,
4001 NamedDecl *UnqualLookup,
4003 if (getDerived().AlreadyTransformed(TL.getType()))
4006 TypeSourceInfo *TSI =
4007 TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
4009 return TSI->getTypeLoc();
4013 template<typename Derived>
4015 TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
4016 QualType ObjectType,
4017 NamedDecl *UnqualLookup,
4019 if (getDerived().AlreadyTransformed(TSInfo->getType()))
4022 return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType,
4026 template <typename Derived>
4027 TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope(
4028 TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup,
4030 QualType T = TL.getType();
4031 assert(!getDerived().AlreadyTransformed(T));
4036 if (isa<TemplateSpecializationType>(T)) {
4037 TemplateSpecializationTypeLoc SpecTL =
4038 TL.castAs<TemplateSpecializationTypeLoc>();
4040 TemplateName Template
4041 = getDerived().TransformTemplateName(SS,
4042 SpecTL.getTypePtr()->getTemplateName(),
4043 SpecTL.getTemplateNameLoc(),
4044 ObjectType, UnqualLookup);
4045 if (Template.isNull())
4048 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL,
4050 } else if (isa<DependentTemplateSpecializationType>(T)) {
4051 DependentTemplateSpecializationTypeLoc SpecTL =
4052 TL.castAs<DependentTemplateSpecializationTypeLoc>();
4054 TemplateName Template
4055 = getDerived().RebuildTemplateName(SS,
4056 *SpecTL.getTypePtr()->getIdentifier(),
4057 SpecTL.getTemplateNameLoc(),
4058 ObjectType, UnqualLookup);
4059 if (Template.isNull())
4062 Result = getDerived().TransformDependentTemplateSpecializationType(TLB,
4067 // Nothing special needs to be done for these.
4068 Result = getDerived().TransformType(TLB, TL);
4071 if (Result.isNull())
4074 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
4077 template <class TyLoc> static inline
4078 QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) {
4079 TyLoc NewT = TLB.push<TyLoc>(T.getType());
4080 NewT.setNameLoc(T.getNameLoc());
4084 template<typename Derived>
4085 QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
4087 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType());
4088 NewT.setBuiltinLoc(T.getBuiltinLoc());
4089 if (T.needsExtraLocalData())
4090 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs();
4094 template<typename Derived>
4095 QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
4098 return TransformTypeSpecType(TLB, T);
4101 template <typename Derived>
4102 QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB,
4103 AdjustedTypeLoc TL) {
4104 // Adjustments applied during transformation are handled elsewhere.
4105 return getDerived().TransformType(TLB, TL.getOriginalLoc());
4108 template<typename Derived>
4109 QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB,
4110 DecayedTypeLoc TL) {
4111 QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc());
4112 if (OriginalType.isNull())
4115 QualType Result = TL.getType();
4116 if (getDerived().AlwaysRebuild() ||
4117 OriginalType != TL.getOriginalLoc().getType())
4118 Result = SemaRef.Context.getDecayedType(OriginalType);
4119 TLB.push<DecayedTypeLoc>(Result);
4120 // Nothing to set for DecayedTypeLoc.
4124 template<typename Derived>
4125 QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
4126 PointerTypeLoc TL) {
4127 QualType PointeeType
4128 = getDerived().TransformType(TLB, TL.getPointeeLoc());
4129 if (PointeeType.isNull())
4132 QualType Result = TL.getType();
4133 if (PointeeType->getAs<ObjCObjectType>()) {
4134 // A dependent pointer type 'T *' has is being transformed such
4135 // that an Objective-C class type is being replaced for 'T'. The
4136 // resulting pointer type is an ObjCObjectPointerType, not a
4138 Result = SemaRef.Context.getObjCObjectPointerType(PointeeType);
4140 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
4141 NewT.setStarLoc(TL.getStarLoc());
4145 if (getDerived().AlwaysRebuild() ||
4146 PointeeType != TL.getPointeeLoc().getType()) {
4147 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
4148 if (Result.isNull())
4152 // Objective-C ARC can add lifetime qualifiers to the type that we're
4154 TLB.TypeWasModifiedSafely(Result->getPointeeType());
4156 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result);
4157 NewT.setSigilLoc(TL.getSigilLoc());
4161 template<typename Derived>
4163 TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
4164 BlockPointerTypeLoc TL) {
4165 QualType PointeeType
4166 = getDerived().TransformType(TLB, TL.getPointeeLoc());
4167 if (PointeeType.isNull())
4170 QualType Result = TL.getType();
4171 if (getDerived().AlwaysRebuild() ||
4172 PointeeType != TL.getPointeeLoc().getType()) {
4173 Result = getDerived().RebuildBlockPointerType(PointeeType,
4175 if (Result.isNull())
4179 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result);
4180 NewT.setSigilLoc(TL.getSigilLoc());
4184 /// Transforms a reference type. Note that somewhat paradoxically we
4185 /// don't care whether the type itself is an l-value type or an r-value
4186 /// type; we only care if the type was *written* as an l-value type
4187 /// or an r-value type.
4188 template<typename Derived>
4190 TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB,
4191 ReferenceTypeLoc TL) {
4192 const ReferenceType *T = TL.getTypePtr();
4194 // Note that this works with the pointee-as-written.
4195 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
4196 if (PointeeType.isNull())
4199 QualType Result = TL.getType();
4200 if (getDerived().AlwaysRebuild() ||
4201 PointeeType != T->getPointeeTypeAsWritten()) {
4202 Result = getDerived().RebuildReferenceType(PointeeType,
4203 T->isSpelledAsLValue(),
4205 if (Result.isNull())
4209 // Objective-C ARC can add lifetime qualifiers to the type that we're
4211 TLB.TypeWasModifiedSafely(
4212 Result->getAs<ReferenceType>()->getPointeeTypeAsWritten());
4214 // r-value references can be rebuilt as l-value references.
4215 ReferenceTypeLoc NewTL;
4216 if (isa<LValueReferenceType>(Result))
4217 NewTL = TLB.push<LValueReferenceTypeLoc>(Result);
4219 NewTL = TLB.push<RValueReferenceTypeLoc>(Result);
4220 NewTL.setSigilLoc(TL.getSigilLoc());
4225 template<typename Derived>
4227 TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB,
4228 LValueReferenceTypeLoc TL) {
4229 return TransformReferenceType(TLB, TL);
4232 template<typename Derived>
4234 TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
4235 RValueReferenceTypeLoc TL) {
4236 return TransformReferenceType(TLB, TL);
4239 template<typename Derived>
4241 TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
4242 MemberPointerTypeLoc TL) {
4243 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
4244 if (PointeeType.isNull())
4247 TypeSourceInfo* OldClsTInfo = TL.getClassTInfo();
4248 TypeSourceInfo *NewClsTInfo = nullptr;
4250 NewClsTInfo = getDerived().TransformType(OldClsTInfo);
4255 const MemberPointerType *T = TL.getTypePtr();
4256 QualType OldClsType = QualType(T->getClass(), 0);
4257 QualType NewClsType;
4259 NewClsType = NewClsTInfo->getType();
4261 NewClsType = getDerived().TransformType(OldClsType);
4262 if (NewClsType.isNull())
4266 QualType Result = TL.getType();
4267 if (getDerived().AlwaysRebuild() ||
4268 PointeeType != T->getPointeeType() ||
4269 NewClsType != OldClsType) {
4270 Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType,
4272 if (Result.isNull())
4276 // If we had to adjust the pointee type when building a member pointer, make
4277 // sure to push TypeLoc info for it.
4278 const MemberPointerType *MPT = Result->getAs<MemberPointerType>();
4279 if (MPT && PointeeType != MPT->getPointeeType()) {
4280 assert(isa<AdjustedType>(MPT->getPointeeType()));
4281 TLB.push<AdjustedTypeLoc>(MPT->getPointeeType());
4284 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
4285 NewTL.setSigilLoc(TL.getSigilLoc());
4286 NewTL.setClassTInfo(NewClsTInfo);
4291 template<typename Derived>
4293 TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
4294 ConstantArrayTypeLoc TL) {
4295 const ConstantArrayType *T = TL.getTypePtr();
4296 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4297 if (ElementType.isNull())
4300 QualType Result = TL.getType();
4301 if (getDerived().AlwaysRebuild() ||
4302 ElementType != T->getElementType()) {
4303 Result = getDerived().RebuildConstantArrayType(ElementType,
4304 T->getSizeModifier(),
4306 T->getIndexTypeCVRQualifiers(),
4307 TL.getBracketsRange());
4308 if (Result.isNull())
4312 // We might have either a ConstantArrayType or a VariableArrayType now:
4313 // a ConstantArrayType is allowed to have an element type which is a
4314 // VariableArrayType if the type is dependent. Fortunately, all array
4315 // types have the same location layout.
4316 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4317 NewTL.setLBracketLoc(TL.getLBracketLoc());
4318 NewTL.setRBracketLoc(TL.getRBracketLoc());
4320 Expr *Size = TL.getSizeExpr();
4322 EnterExpressionEvaluationContext Unevaluated(SemaRef,
4323 Sema::ConstantEvaluated);
4324 Size = getDerived().TransformExpr(Size).template getAs<Expr>();
4325 Size = SemaRef.ActOnConstantExpression(Size).get();
4327 NewTL.setSizeExpr(Size);
4332 template<typename Derived>
4333 QualType TreeTransform<Derived>::TransformIncompleteArrayType(
4334 TypeLocBuilder &TLB,
4335 IncompleteArrayTypeLoc TL) {
4336 const IncompleteArrayType *T = TL.getTypePtr();
4337 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4338 if (ElementType.isNull())
4341 QualType Result = TL.getType();
4342 if (getDerived().AlwaysRebuild() ||
4343 ElementType != T->getElementType()) {
4344 Result = getDerived().RebuildIncompleteArrayType(ElementType,
4345 T->getSizeModifier(),
4346 T->getIndexTypeCVRQualifiers(),
4347 TL.getBracketsRange());
4348 if (Result.isNull())
4352 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
4353 NewTL.setLBracketLoc(TL.getLBracketLoc());
4354 NewTL.setRBracketLoc(TL.getRBracketLoc());
4355 NewTL.setSizeExpr(nullptr);
4360 template<typename Derived>
4362 TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
4363 VariableArrayTypeLoc TL) {
4364 const VariableArrayType *T = TL.getTypePtr();
4365 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4366 if (ElementType.isNull())
4369 ExprResult SizeResult
4370 = getDerived().TransformExpr(T->getSizeExpr());
4371 if (SizeResult.isInvalid())
4374 Expr *Size = SizeResult.get();
4376 QualType Result = TL.getType();
4377 if (getDerived().AlwaysRebuild() ||
4378 ElementType != T->getElementType() ||
4379 Size != T->getSizeExpr()) {
4380 Result = getDerived().RebuildVariableArrayType(ElementType,
4381 T->getSizeModifier(),
4383 T->getIndexTypeCVRQualifiers(),
4384 TL.getBracketsRange());
4385 if (Result.isNull())
4389 // We might have constant size array now, but fortunately it has the same
4391 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4392 NewTL.setLBracketLoc(TL.getLBracketLoc());
4393 NewTL.setRBracketLoc(TL.getRBracketLoc());
4394 NewTL.setSizeExpr(Size);
4399 template<typename Derived>
4401 TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
4402 DependentSizedArrayTypeLoc TL) {
4403 const DependentSizedArrayType *T = TL.getTypePtr();
4404 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4405 if (ElementType.isNull())
4408 // Array bounds are constant expressions.
4409 EnterExpressionEvaluationContext Unevaluated(SemaRef,
4410 Sema::ConstantEvaluated);
4412 // Prefer the expression from the TypeLoc; the other may have been uniqued.
4413 Expr *origSize = TL.getSizeExpr();
4414 if (!origSize) origSize = T->getSizeExpr();
4416 ExprResult sizeResult
4417 = getDerived().TransformExpr(origSize);
4418 sizeResult = SemaRef.ActOnConstantExpression(sizeResult);
4419 if (sizeResult.isInvalid())
4422 Expr *size = sizeResult.get();
4424 QualType Result = TL.getType();
4425 if (getDerived().AlwaysRebuild() ||
4426 ElementType != T->getElementType() ||
4428 Result = getDerived().RebuildDependentSizedArrayType(ElementType,
4429 T->getSizeModifier(),
4431 T->getIndexTypeCVRQualifiers(),
4432 TL.getBracketsRange());
4433 if (Result.isNull())
4437 // We might have any sort of array type now, but fortunately they
4438 // all have the same location layout.
4439 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4440 NewTL.setLBracketLoc(TL.getLBracketLoc());
4441 NewTL.setRBracketLoc(TL.getRBracketLoc());
4442 NewTL.setSizeExpr(size);
4447 template<typename Derived>
4448 QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
4449 TypeLocBuilder &TLB,
4450 DependentSizedExtVectorTypeLoc TL) {
4451 const DependentSizedExtVectorType *T = TL.getTypePtr();
4453 // FIXME: ext vector locs should be nested
4454 QualType ElementType = getDerived().TransformType(T->getElementType());
4455 if (ElementType.isNull())
4458 // Vector sizes are constant expressions.
4459 EnterExpressionEvaluationContext Unevaluated(SemaRef,
4460 Sema::ConstantEvaluated);
4462 ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
4463 Size = SemaRef.ActOnConstantExpression(Size);
4464 if (Size.isInvalid())
4467 QualType Result = TL.getType();
4468 if (getDerived().AlwaysRebuild() ||
4469 ElementType != T->getElementType() ||
4470 Size.get() != T->getSizeExpr()) {
4471 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
4473 T->getAttributeLoc());
4474 if (Result.isNull())
4478 // Result might be dependent or not.
4479 if (isa<DependentSizedExtVectorType>(Result)) {
4480 DependentSizedExtVectorTypeLoc NewTL
4481 = TLB.push<DependentSizedExtVectorTypeLoc>(Result);
4482 NewTL.setNameLoc(TL.getNameLoc());
4484 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
4485 NewTL.setNameLoc(TL.getNameLoc());
4491 template<typename Derived>
4492 QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
4494 const VectorType *T = TL.getTypePtr();
4495 QualType ElementType = getDerived().TransformType(T->getElementType());
4496 if (ElementType.isNull())
4499 QualType Result = TL.getType();
4500 if (getDerived().AlwaysRebuild() ||
4501 ElementType != T->getElementType()) {
4502 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(),
4503 T->getVectorKind());
4504 if (Result.isNull())
4508 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
4509 NewTL.setNameLoc(TL.getNameLoc());
4514 template<typename Derived>
4515 QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
4516 ExtVectorTypeLoc TL) {
4517 const VectorType *T = TL.getTypePtr();
4518 QualType ElementType = getDerived().TransformType(T->getElementType());
4519 if (ElementType.isNull())
4522 QualType Result = TL.getType();
4523 if (getDerived().AlwaysRebuild() ||
4524 ElementType != T->getElementType()) {
4525 Result = getDerived().RebuildExtVectorType(ElementType,
4526 T->getNumElements(),
4527 /*FIXME*/ SourceLocation());
4528 if (Result.isNull())
4532 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
4533 NewTL.setNameLoc(TL.getNameLoc());
4538 template <typename Derived>
4539 ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam(
4540 ParmVarDecl *OldParm, int indexAdjustment, Optional<unsigned> NumExpansions,
4541 bool ExpectParameterPack) {
4542 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
4543 TypeSourceInfo *NewDI = nullptr;
4545 if (NumExpansions && isa<PackExpansionType>(OldDI->getType())) {
4546 // If we're substituting into a pack expansion type and we know the
4547 // length we want to expand to, just substitute for the pattern.
4548 TypeLoc OldTL = OldDI->getTypeLoc();
4549 PackExpansionTypeLoc OldExpansionTL = OldTL.castAs<PackExpansionTypeLoc>();
4552 TypeLoc NewTL = OldDI->getTypeLoc();
4553 TLB.reserve(NewTL.getFullDataSize());
4555 QualType Result = getDerived().TransformType(TLB,
4556 OldExpansionTL.getPatternLoc());
4557 if (Result.isNull())
4560 Result = RebuildPackExpansionType(Result,
4561 OldExpansionTL.getPatternLoc().getSourceRange(),
4562 OldExpansionTL.getEllipsisLoc(),
4564 if (Result.isNull())
4567 PackExpansionTypeLoc NewExpansionTL
4568 = TLB.push<PackExpansionTypeLoc>(Result);
4569 NewExpansionTL.setEllipsisLoc(OldExpansionTL.getEllipsisLoc());
4570 NewDI = TLB.getTypeSourceInfo(SemaRef.Context, Result);
4572 NewDI = getDerived().TransformType(OldDI);
4576 if (NewDI == OldDI && indexAdjustment == 0)
4579 ParmVarDecl *newParm = ParmVarDecl::Create(SemaRef.Context,
4580 OldParm->getDeclContext(),
4581 OldParm->getInnerLocStart(),
4582 OldParm->getLocation(),
4583 OldParm->getIdentifier(),
4586 OldParm->getStorageClass(),
4587 /* DefArg */ nullptr);
4588 newParm->setScopeInfo(OldParm->getFunctionScopeDepth(),
4589 OldParm->getFunctionScopeIndex() + indexAdjustment);
4593 template<typename Derived>
4594 bool TreeTransform<Derived>::
4595 TransformFunctionTypeParams(SourceLocation Loc,
4596 ParmVarDecl **Params, unsigned NumParams,
4597 const QualType *ParamTypes,
4598 SmallVectorImpl<QualType> &OutParamTypes,
4599 SmallVectorImpl<ParmVarDecl*> *PVars) {
4600 int indexAdjustment = 0;
4602 for (unsigned i = 0; i != NumParams; ++i) {
4603 if (ParmVarDecl *OldParm = Params[i]) {
4604 assert(OldParm->getFunctionScopeIndex() == i);
4606 Optional<unsigned> NumExpansions;
4607 ParmVarDecl *NewParm = nullptr;
4608 if (OldParm->isParameterPack()) {
4609 // We have a function parameter pack that may need to be expanded.
4610 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
4612 // Find the parameter packs that could be expanded.
4613 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc();
4614 PackExpansionTypeLoc ExpansionTL = TL.castAs<PackExpansionTypeLoc>();
4615 TypeLoc Pattern = ExpansionTL.getPatternLoc();
4616 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
4617 assert(Unexpanded.size() > 0 && "Could not find parameter packs!");
4619 // Determine whether we should expand the parameter packs.
4620 bool ShouldExpand = false;
4621 bool RetainExpansion = false;
4622 Optional<unsigned> OrigNumExpansions =
4623 ExpansionTL.getTypePtr()->getNumExpansions();
4624 NumExpansions = OrigNumExpansions;
4625 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
4626 Pattern.getSourceRange(),
4635 // Expand the function parameter pack into multiple, separate
4637 getDerived().ExpandingFunctionParameterPack(OldParm);
4638 for (unsigned I = 0; I != *NumExpansions; ++I) {
4639 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
4640 ParmVarDecl *NewParm
4641 = getDerived().TransformFunctionTypeParam(OldParm,
4644 /*ExpectParameterPack=*/false);
4648 OutParamTypes.push_back(NewParm->getType());
4650 PVars->push_back(NewParm);
4653 // If we're supposed to retain a pack expansion, do so by temporarily
4654 // forgetting the partially-substituted parameter pack.
4655 if (RetainExpansion) {
4656 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4657 ParmVarDecl *NewParm
4658 = getDerived().TransformFunctionTypeParam(OldParm,
4661 /*ExpectParameterPack=*/false);
4665 OutParamTypes.push_back(NewParm->getType());
4667 PVars->push_back(NewParm);
4670 // The next parameter should have the same adjustment as the
4671 // last thing we pushed, but we post-incremented indexAdjustment
4672 // on every push. Also, if we push nothing, the adjustment should
4676 // We're done with the pack expansion.
4680 // We'll substitute the parameter now without expanding the pack
4682 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
4683 NewParm = getDerived().TransformFunctionTypeParam(OldParm,
4686 /*ExpectParameterPack=*/true);
4688 NewParm = getDerived().TransformFunctionTypeParam(
4689 OldParm, indexAdjustment, None, /*ExpectParameterPack=*/ false);
4695 OutParamTypes.push_back(NewParm->getType());
4697 PVars->push_back(NewParm);
4701 // Deal with the possibility that we don't have a parameter
4702 // declaration for this parameter.
4703 QualType OldType = ParamTypes[i];
4704 bool IsPackExpansion = false;
4705 Optional<unsigned> NumExpansions;
4707 if (const PackExpansionType *Expansion
4708 = dyn_cast<PackExpansionType>(OldType)) {
4709 // We have a function parameter pack that may need to be expanded.
4710 QualType Pattern = Expansion->getPattern();
4711 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
4712 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
4714 // Determine whether we should expand the parameter packs.
4715 bool ShouldExpand = false;
4716 bool RetainExpansion = false;
4717 if (getDerived().TryExpandParameterPacks(Loc, SourceRange(),
4726 // Expand the function parameter pack into multiple, separate
4728 for (unsigned I = 0; I != *NumExpansions; ++I) {
4729 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
4730 QualType NewType = getDerived().TransformType(Pattern);
4731 if (NewType.isNull())
4734 OutParamTypes.push_back(NewType);
4736 PVars->push_back(nullptr);
4739 // We're done with the pack expansion.
4743 // If we're supposed to retain a pack expansion, do so by temporarily
4744 // forgetting the partially-substituted parameter pack.
4745 if (RetainExpansion) {
4746 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4747 QualType NewType = getDerived().TransformType(Pattern);
4748 if (NewType.isNull())
4751 OutParamTypes.push_back(NewType);
4753 PVars->push_back(nullptr);
4756 // We'll substitute the parameter now without expanding the pack
4758 OldType = Expansion->getPattern();
4759 IsPackExpansion = true;
4760 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
4761 NewType = getDerived().TransformType(OldType);
4763 NewType = getDerived().TransformType(OldType);
4766 if (NewType.isNull())
4769 if (IsPackExpansion)
4770 NewType = getSema().Context.getPackExpansionType(NewType,
4773 OutParamTypes.push_back(NewType);
4775 PVars->push_back(nullptr);
4780 for (unsigned i = 0, e = PVars->size(); i != e; ++i)
4781 if (ParmVarDecl *parm = (*PVars)[i])
4782 assert(parm->getFunctionScopeIndex() == i);
4789 template<typename Derived>
4791 TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB,
4792 FunctionProtoTypeLoc TL) {
4793 SmallVector<QualType, 4> ExceptionStorage;
4794 TreeTransform *This = this; // Work around gcc.gnu.org/PR56135.
4795 return getDerived().TransformFunctionProtoType(
4796 TLB, TL, nullptr, 0,
4797 [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) {
4798 return This->TransformExceptionSpec(TL.getBeginLoc(), ESI,
4799 ExceptionStorage, Changed);
4803 template<typename Derived> template<typename Fn>
4804 QualType TreeTransform<Derived>::TransformFunctionProtoType(
4805 TypeLocBuilder &TLB, FunctionProtoTypeLoc TL, CXXRecordDecl *ThisContext,
4806 unsigned ThisTypeQuals, Fn TransformExceptionSpec) {
4807 // Transform the parameters and return type.
4809 // We are required to instantiate the params and return type in source order.
4810 // When the function has a trailing return type, we instantiate the
4811 // parameters before the return type, since the return type can then refer
4812 // to the parameters themselves (via decltype, sizeof, etc.).
4814 SmallVector<QualType, 4> ParamTypes;
4815 SmallVector<ParmVarDecl*, 4> ParamDecls;
4816 const FunctionProtoType *T = TL.getTypePtr();
4818 QualType ResultType;
4820 if (T->hasTrailingReturn()) {
4821 if (getDerived().TransformFunctionTypeParams(
4822 TL.getBeginLoc(), TL.getParmArray(), TL.getNumParams(),
4823 TL.getTypePtr()->param_type_begin(), ParamTypes, &ParamDecls))
4827 // C++11 [expr.prim.general]p3:
4828 // If a declaration declares a member function or member function
4829 // template of a class X, the expression this is a prvalue of type
4830 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
4831 // and the end of the function-definition, member-declarator, or
4833 Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, ThisTypeQuals);
4835 ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
4836 if (ResultType.isNull())
4841 ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
4842 if (ResultType.isNull())
4845 if (getDerived().TransformFunctionTypeParams(
4846 TL.getBeginLoc(), TL.getParmArray(), TL.getNumParams(),
4847 TL.getTypePtr()->param_type_begin(), ParamTypes, &ParamDecls))
4851 FunctionProtoType::ExtProtoInfo EPI = T->getExtProtoInfo();
4853 bool EPIChanged = false;
4854 if (TransformExceptionSpec(EPI.ExceptionSpec, EPIChanged))
4857 // FIXME: Need to transform ConsumedParameters for variadic template
4860 QualType Result = TL.getType();
4861 if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType() ||
4862 T->getParamTypes() != llvm::makeArrayRef(ParamTypes) || EPIChanged) {
4863 Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI);
4864 if (Result.isNull())
4868 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result);
4869 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin());
4870 NewTL.setLParenLoc(TL.getLParenLoc());
4871 NewTL.setRParenLoc(TL.getRParenLoc());
4872 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());
4873 for (unsigned i = 0, e = NewTL.getNumParams(); i != e; ++i)
4874 NewTL.setParam(i, ParamDecls[i]);
4879 template<typename Derived>
4880 bool TreeTransform<Derived>::TransformExceptionSpec(
4881 SourceLocation Loc, FunctionProtoType::ExceptionSpecInfo &ESI,
4882 SmallVectorImpl<QualType> &Exceptions, bool &Changed) {
4883 assert(ESI.Type != EST_Uninstantiated && ESI.Type != EST_Unevaluated);
4885 // Instantiate a dynamic noexcept expression, if any.
4886 if (ESI.Type == EST_ComputedNoexcept) {
4887 EnterExpressionEvaluationContext Unevaluated(getSema(),
4888 Sema::ConstantEvaluated);
4889 ExprResult NoexceptExpr = getDerived().TransformExpr(ESI.NoexceptExpr);
4890 if (NoexceptExpr.isInvalid())
4893 NoexceptExpr = getSema().CheckBooleanCondition(
4894 NoexceptExpr.get(), NoexceptExpr.get()->getLocStart());
4895 if (NoexceptExpr.isInvalid())
4898 if (!NoexceptExpr.get()->isValueDependent()) {
4899 NoexceptExpr = getSema().VerifyIntegerConstantExpression(
4900 NoexceptExpr.get(), nullptr,
4901 diag::err_noexcept_needs_constant_expression,
4902 /*AllowFold*/false);
4903 if (NoexceptExpr.isInvalid())
4907 if (ESI.NoexceptExpr != NoexceptExpr.get())
4909 ESI.NoexceptExpr = NoexceptExpr.get();
4912 if (ESI.Type != EST_Dynamic)
4915 // Instantiate a dynamic exception specification's type.
4916 for (QualType T : ESI.Exceptions) {
4917 if (const PackExpansionType *PackExpansion =
4918 T->getAs<PackExpansionType>()) {
4921 // We have a pack expansion. Instantiate it.
4922 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
4923 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
4925 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
4927 // Determine whether the set of unexpanded parameter packs can and
4930 bool Expand = false;
4931 bool RetainExpansion = false;
4932 Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
4933 // FIXME: Track the location of the ellipsis (and track source location
4934 // information for the types in the exception specification in general).
4935 if (getDerived().TryExpandParameterPacks(
4936 Loc, SourceRange(), Unexpanded, Expand,
4937 RetainExpansion, NumExpansions))
4941 // We can't expand this pack expansion into separate arguments yet;
4942 // just substitute into the pattern and create a new pack expansion
4944 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
4945 QualType U = getDerived().TransformType(PackExpansion->getPattern());
4949 U = SemaRef.Context.getPackExpansionType(U, NumExpansions);
4950 Exceptions.push_back(U);
4954 // Substitute into the pack expansion pattern for each slice of the
4956 for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
4957 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);
4959 QualType U = getDerived().TransformType(PackExpansion->getPattern());
4960 if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
4963 Exceptions.push_back(U);
4966 QualType U = getDerived().TransformType(T);
4967 if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
4972 Exceptions.push_back(U);
4976 ESI.Exceptions = Exceptions;
4980 template<typename Derived>
4981 QualType TreeTransform<Derived>::TransformFunctionNoProtoType(
4982 TypeLocBuilder &TLB,
4983 FunctionNoProtoTypeLoc TL) {
4984 const FunctionNoProtoType *T = TL.getTypePtr();
4985 QualType ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
4986 if (ResultType.isNull())
4989 QualType Result = TL.getType();
4990 if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType())
4991 Result = getDerived().RebuildFunctionNoProtoType(ResultType);
4993 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result);
4994 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin());
4995 NewTL.setLParenLoc(TL.getLParenLoc());
4996 NewTL.setRParenLoc(TL.getRParenLoc());
4997 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());
5002 template<typename Derived> QualType
5003 TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB,
5004 UnresolvedUsingTypeLoc TL) {
5005 const UnresolvedUsingType *T = TL.getTypePtr();
5006 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl());
5010 QualType Result = TL.getType();
5011 if (getDerived().AlwaysRebuild() || D != T->getDecl()) {
5012 Result = getDerived().RebuildUnresolvedUsingType(D);
5013 if (Result.isNull())
5017 // We might get an arbitrary type spec type back. We should at
5018 // least always get a type spec type, though.
5019 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result);
5020 NewTL.setNameLoc(TL.getNameLoc());
5025 template<typename Derived>
5026 QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
5027 TypedefTypeLoc TL) {
5028 const TypedefType *T = TL.getTypePtr();
5029 TypedefNameDecl *Typedef
5030 = cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5035 QualType Result = TL.getType();
5036 if (getDerived().AlwaysRebuild() ||
5037 Typedef != T->getDecl()) {
5038 Result = getDerived().RebuildTypedefType(Typedef);
5039 if (Result.isNull())
5043 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result);
5044 NewTL.setNameLoc(TL.getNameLoc());
5049 template<typename Derived>
5050 QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
5051 TypeOfExprTypeLoc TL) {
5052 // typeof expressions are not potentially evaluated contexts
5053 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated,
5054 Sema::ReuseLambdaContextDecl);
5056 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
5060 E = SemaRef.HandleExprEvaluationContextForTypeof(E.get());
5064 QualType Result = TL.getType();
5065 if (getDerived().AlwaysRebuild() ||
5066 E.get() != TL.getUnderlyingExpr()) {
5067 Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc());
5068 if (Result.isNull())
5073 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result);
5074 NewTL.setTypeofLoc(TL.getTypeofLoc());
5075 NewTL.setLParenLoc(TL.getLParenLoc());
5076 NewTL.setRParenLoc(TL.getRParenLoc());
5081 template<typename Derived>
5082 QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
5084 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo();
5085 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);
5089 QualType Result = TL.getType();
5090 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {
5091 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType());
5092 if (Result.isNull())
5096 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result);
5097 NewTL.setTypeofLoc(TL.getTypeofLoc());
5098 NewTL.setLParenLoc(TL.getLParenLoc());
5099 NewTL.setRParenLoc(TL.getRParenLoc());
5100 NewTL.setUnderlyingTInfo(New_Under_TI);
5105 template<typename Derived>
5106 QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
5107 DecltypeTypeLoc TL) {
5108 const DecltypeType *T = TL.getTypePtr();
5110 // decltype expressions are not potentially evaluated contexts
5111 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated,
5112 nullptr, /*IsDecltype=*/ true);
5114 ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
5118 E = getSema().ActOnDecltypeExpression(E.get());
5122 QualType Result = TL.getType();
5123 if (getDerived().AlwaysRebuild() ||
5124 E.get() != T->getUnderlyingExpr()) {
5125 Result = getDerived().RebuildDecltypeType(E.get(), TL.getNameLoc());
5126 if (Result.isNull())
5131 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
5132 NewTL.setNameLoc(TL.getNameLoc());
5137 template<typename Derived>
5138 QualType TreeTransform<Derived>::TransformUnaryTransformType(
5139 TypeLocBuilder &TLB,
5140 UnaryTransformTypeLoc TL) {
5141 QualType Result = TL.getType();
5142 if (Result->isDependentType()) {
5143 const UnaryTransformType *T = TL.getTypePtr();
5145 getDerived().TransformType(TL.getUnderlyingTInfo())->getType();
5146 Result = getDerived().RebuildUnaryTransformType(NewBase,
5149 if (Result.isNull())
5153 UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result);
5154 NewTL.setKWLoc(TL.getKWLoc());
5155 NewTL.setParensRange(TL.getParensRange());
5156 NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo());
5160 template<typename Derived>
5161 QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
5163 const AutoType *T = TL.getTypePtr();
5164 QualType OldDeduced = T->getDeducedType();
5165 QualType NewDeduced;
5166 if (!OldDeduced.isNull()) {
5167 NewDeduced = getDerived().TransformType(OldDeduced);
5168 if (NewDeduced.isNull())
5172 QualType Result = TL.getType();
5173 if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
5174 T->isDependentType()) {
5175 Result = getDerived().RebuildAutoType(NewDeduced, T->getKeyword());
5176 if (Result.isNull())
5180 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
5181 NewTL.setNameLoc(TL.getNameLoc());
5186 template<typename Derived>
5187 QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,
5189 const RecordType *T = TL.getTypePtr();
5191 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5196 QualType Result = TL.getType();
5197 if (getDerived().AlwaysRebuild() ||
5198 Record != T->getDecl()) {
5199 Result = getDerived().RebuildRecordType(Record);
5200 if (Result.isNull())
5204 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
5205 NewTL.setNameLoc(TL.getNameLoc());
5210 template<typename Derived>
5211 QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
5213 const EnumType *T = TL.getTypePtr();
5215 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5220 QualType Result = TL.getType();
5221 if (getDerived().AlwaysRebuild() ||
5222 Enum != T->getDecl()) {
5223 Result = getDerived().RebuildEnumType(Enum);
5224 if (Result.isNull())
5228 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result);
5229 NewTL.setNameLoc(TL.getNameLoc());
5234 template<typename Derived>
5235 QualType TreeTransform<Derived>::TransformInjectedClassNameType(
5236 TypeLocBuilder &TLB,
5237 InjectedClassNameTypeLoc TL) {
5238 Decl *D = getDerived().TransformDecl(TL.getNameLoc(),
5239 TL.getTypePtr()->getDecl());
5240 if (!D) return QualType();
5242 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D));
5243 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc());
5247 template<typename Derived>
5248 QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
5249 TypeLocBuilder &TLB,
5250 TemplateTypeParmTypeLoc TL) {
5251 return TransformTypeSpecType(TLB, TL);
5254 template<typename Derived>
5255 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
5256 TypeLocBuilder &TLB,
5257 SubstTemplateTypeParmTypeLoc TL) {
5258 const SubstTemplateTypeParmType *T = TL.getTypePtr();
5260 // Substitute into the replacement type, which itself might involve something
5261 // that needs to be transformed. This only tends to occur with default
5262 // template arguments of template template parameters.
5263 TemporaryBase Rebase(*this, TL.getNameLoc(), DeclarationName());
5264 QualType Replacement = getDerived().TransformType(T->getReplacementType());
5265 if (Replacement.isNull())
5268 // Always canonicalize the replacement type.
5269 Replacement = SemaRef.Context.getCanonicalType(Replacement);
5271 = SemaRef.Context.getSubstTemplateTypeParmType(T->getReplacedParameter(),
5274 // Propagate type-source information.
5275 SubstTemplateTypeParmTypeLoc NewTL
5276 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
5277 NewTL.setNameLoc(TL.getNameLoc());
5282 template<typename Derived>
5283 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
5284 TypeLocBuilder &TLB,
5285 SubstTemplateTypeParmPackTypeLoc TL) {
5286 return TransformTypeSpecType(TLB, TL);
5289 template<typename Derived>
5290 QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
5291 TypeLocBuilder &TLB,
5292 TemplateSpecializationTypeLoc TL) {
5293 const TemplateSpecializationType *T = TL.getTypePtr();
5295 // The nested-name-specifier never matters in a TemplateSpecializationType,
5296 // because we can't have a dependent nested-name-specifier anyway.
5298 TemplateName Template
5299 = getDerived().TransformTemplateName(SS, T->getTemplateName(),
5300 TL.getTemplateNameLoc());
5301 if (Template.isNull())
5304 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template);
5307 template<typename Derived>
5308 QualType TreeTransform<Derived>::TransformAtomicType(TypeLocBuilder &TLB,
5310 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
5311 if (ValueType.isNull())
5314 QualType Result = TL.getType();
5315 if (getDerived().AlwaysRebuild() ||
5316 ValueType != TL.getValueLoc().getType()) {
5317 Result = getDerived().RebuildAtomicType(ValueType, TL.getKWLoc());
5318 if (Result.isNull())
5322 AtomicTypeLoc NewTL = TLB.push<AtomicTypeLoc>(Result);
5323 NewTL.setKWLoc(TL.getKWLoc());
5324 NewTL.setLParenLoc(TL.getLParenLoc());
5325 NewTL.setRParenLoc(TL.getRParenLoc());
5330 template <typename Derived>
5331 QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB,
5333 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
5334 if (ValueType.isNull())
5337 QualType Result = TL.getType();
5338 if (getDerived().AlwaysRebuild() || ValueType != TL.getValueLoc().getType()) {
5339 Result = getDerived().RebuildPipeType(ValueType, TL.getKWLoc());
5340 if (Result.isNull())
5344 PipeTypeLoc NewTL = TLB.push<PipeTypeLoc>(Result);
5345 NewTL.setKWLoc(TL.getKWLoc());
5350 /// \brief Simple iterator that traverses the template arguments in a
5351 /// container that provides a \c getArgLoc() member function.
5353 /// This iterator is intended to be used with the iterator form of
5354 /// \c TreeTransform<Derived>::TransformTemplateArguments().
5355 template<typename ArgLocContainer>
5356 class TemplateArgumentLocContainerIterator {
5357 ArgLocContainer *Container;
5361 typedef TemplateArgumentLoc value_type;
5362 typedef TemplateArgumentLoc reference;
5363 typedef int difference_type;
5364 typedef std::input_iterator_tag iterator_category;
5367 TemplateArgumentLoc Arg;
5370 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }
5372 const TemplateArgumentLoc *operator->() const {
5378 TemplateArgumentLocContainerIterator() {}
5380 TemplateArgumentLocContainerIterator(ArgLocContainer &Container,
5382 : Container(&Container), Index(Index) { }
5384 TemplateArgumentLocContainerIterator &operator++() {
5389 TemplateArgumentLocContainerIterator operator++(int) {
5390 TemplateArgumentLocContainerIterator Old(*this);
5395 TemplateArgumentLoc operator*() const {
5396 return Container->getArgLoc(Index);
5399 pointer operator->() const {
5400 return pointer(Container->getArgLoc(Index));
5403 friend bool operator==(const TemplateArgumentLocContainerIterator &X,
5404 const TemplateArgumentLocContainerIterator &Y) {
5405 return X.Container == Y.Container && X.Index == Y.Index;
5408 friend bool operator!=(const TemplateArgumentLocContainerIterator &X,
5409 const TemplateArgumentLocContainerIterator &Y) {
5415 template <typename Derived>
5416 QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
5417 TypeLocBuilder &TLB,
5418 TemplateSpecializationTypeLoc TL,
5419 TemplateName Template) {
5420 TemplateArgumentListInfo NewTemplateArgs;
5421 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
5422 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
5423 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>
5425 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5426 ArgIterator(TL, TL.getNumArgs()),
5430 // FIXME: maybe don't rebuild if all the template arguments are the same.
5433 getDerived().RebuildTemplateSpecializationType(Template,
5434 TL.getTemplateNameLoc(),
5437 if (!Result.isNull()) {
5438 // Specializations of template template parameters are represented as
5439 // TemplateSpecializationTypes, and substitution of type alias templates
5440 // within a dependent context can transform them into
5441 // DependentTemplateSpecializationTypes.
5442 if (isa<DependentTemplateSpecializationType>(Result)) {
5443 DependentTemplateSpecializationTypeLoc NewTL
5444 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
5445 NewTL.setElaboratedKeywordLoc(SourceLocation());
5446 NewTL.setQualifierLoc(NestedNameSpecifierLoc());
5447 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5448 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5449 NewTL.setLAngleLoc(TL.getLAngleLoc());
5450 NewTL.setRAngleLoc(TL.getRAngleLoc());
5451 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
5452 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
5456 TemplateSpecializationTypeLoc NewTL
5457 = TLB.push<TemplateSpecializationTypeLoc>(Result);
5458 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5459 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5460 NewTL.setLAngleLoc(TL.getLAngleLoc());
5461 NewTL.setRAngleLoc(TL.getRAngleLoc());
5462 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
5463 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
5469 template <typename Derived>
5470 QualType TreeTransform<Derived>::TransformDependentTemplateSpecializationType(
5471 TypeLocBuilder &TLB,
5472 DependentTemplateSpecializationTypeLoc TL,
5473 TemplateName Template,
5475 TemplateArgumentListInfo NewTemplateArgs;
5476 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
5477 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
5478 typedef TemplateArgumentLocContainerIterator<
5479 DependentTemplateSpecializationTypeLoc> ArgIterator;
5480 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5481 ArgIterator(TL, TL.getNumArgs()),
5485 // FIXME: maybe don't rebuild if all the template arguments are the same.
5487 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
5489 = getSema().Context.getDependentTemplateSpecializationType(
5490 TL.getTypePtr()->getKeyword(),
5491 DTN->getQualifier(),
5492 DTN->getIdentifier(),
5495 DependentTemplateSpecializationTypeLoc NewTL
5496 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
5497 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5498 NewTL.setQualifierLoc(SS.getWithLocInContext(SemaRef.Context));
5499 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5500 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5501 NewTL.setLAngleLoc(TL.getLAngleLoc());
5502 NewTL.setRAngleLoc(TL.getRAngleLoc());
5503 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
5504 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
5509 = getDerived().RebuildTemplateSpecializationType(Template,
5510 TL.getTemplateNameLoc(),
5513 if (!Result.isNull()) {
5514 /// FIXME: Wrap this in an elaborated-type-specifier?
5515 TemplateSpecializationTypeLoc NewTL
5516 = TLB.push<TemplateSpecializationTypeLoc>(Result);
5517 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5518 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5519 NewTL.setLAngleLoc(TL.getLAngleLoc());
5520 NewTL.setRAngleLoc(TL.getRAngleLoc());
5521 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
5522 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
5528 template<typename Derived>
5530 TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB,
5531 ElaboratedTypeLoc TL) {
5532 const ElaboratedType *T = TL.getTypePtr();
5534 NestedNameSpecifierLoc QualifierLoc;
5535 // NOTE: the qualifier in an ElaboratedType is optional.
5536 if (TL.getQualifierLoc()) {
5538 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
5543 QualType NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc());
5544 if (NamedT.isNull())
5547 // C++0x [dcl.type.elab]p2:
5548 // If the identifier resolves to a typedef-name or the simple-template-id
5549 // resolves to an alias template specialization, the
5550 // elaborated-type-specifier is ill-formed.
5551 if (T->getKeyword() != ETK_None && T->getKeyword() != ETK_Typename) {
5552 if (const TemplateSpecializationType *TST =
5553 NamedT->getAs<TemplateSpecializationType>()) {
5554 TemplateName Template = TST->getTemplateName();
5555 if (TypeAliasTemplateDecl *TAT = dyn_cast_or_null<TypeAliasTemplateDecl>(
5556 Template.getAsTemplateDecl())) {
5557 SemaRef.Diag(TL.getNamedTypeLoc().getBeginLoc(),
5558 diag::err_tag_reference_non_tag) << 4;
5559 SemaRef.Diag(TAT->getLocation(), diag::note_declared_at);
5564 QualType Result = TL.getType();
5565 if (getDerived().AlwaysRebuild() ||
5566 QualifierLoc != TL.getQualifierLoc() ||
5567 NamedT != T->getNamedType()) {
5568 Result = getDerived().RebuildElaboratedType(TL.getElaboratedKeywordLoc(),
5570 QualifierLoc, NamedT);
5571 if (Result.isNull())
5575 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
5576 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5577 NewTL.setQualifierLoc(QualifierLoc);
5581 template<typename Derived>
5582 QualType TreeTransform<Derived>::TransformAttributedType(
5583 TypeLocBuilder &TLB,
5584 AttributedTypeLoc TL) {
5585 const AttributedType *oldType = TL.getTypePtr();
5586 QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc());
5587 if (modifiedType.isNull())
5590 QualType result = TL.getType();
5592 // FIXME: dependent operand expressions?
5593 if (getDerived().AlwaysRebuild() ||
5594 modifiedType != oldType->getModifiedType()) {
5595 // TODO: this is really lame; we should really be rebuilding the
5596 // equivalent type from first principles.
5597 QualType equivalentType
5598 = getDerived().TransformType(oldType->getEquivalentType());
5599 if (equivalentType.isNull())
5602 // Check whether we can add nullability; it is only represented as
5603 // type sugar, and therefore cannot be diagnosed in any other way.
5604 if (auto nullability = oldType->getImmediateNullability()) {
5605 if (!modifiedType->canHaveNullability()) {
5606 SemaRef.Diag(TL.getAttrNameLoc(), diag::err_nullability_nonpointer)
5607 << DiagNullabilityKind(*nullability, false) << modifiedType;
5612 result = SemaRef.Context.getAttributedType(oldType->getAttrKind(),
5617 AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result);
5618 newTL.setAttrNameLoc(TL.getAttrNameLoc());
5619 if (TL.hasAttrOperand())
5620 newTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5621 if (TL.hasAttrExprOperand())
5622 newTL.setAttrExprOperand(TL.getAttrExprOperand());
5623 else if (TL.hasAttrEnumOperand())
5624 newTL.setAttrEnumOperandLoc(TL.getAttrEnumOperandLoc());
5629 template<typename Derived>
5631 TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB,
5633 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
5637 QualType Result = TL.getType();
5638 if (getDerived().AlwaysRebuild() ||
5639 Inner != TL.getInnerLoc().getType()) {
5640 Result = getDerived().RebuildParenType(Inner);
5641 if (Result.isNull())
5645 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result);
5646 NewTL.setLParenLoc(TL.getLParenLoc());
5647 NewTL.setRParenLoc(TL.getRParenLoc());
5651 template<typename Derived>
5652 QualType TreeTransform<Derived>::TransformDependentNameType(TypeLocBuilder &TLB,
5653 DependentNameTypeLoc TL) {
5654 const DependentNameType *T = TL.getTypePtr();
5656 NestedNameSpecifierLoc QualifierLoc
5657 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
5662 = getDerived().RebuildDependentNameType(T->getKeyword(),
5663 TL.getElaboratedKeywordLoc(),
5667 if (Result.isNull())
5670 if (const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) {
5671 QualType NamedT = ElabT->getNamedType();
5672 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc());
5674 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
5675 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5676 NewTL.setQualifierLoc(QualifierLoc);
5678 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result);
5679 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5680 NewTL.setQualifierLoc(QualifierLoc);
5681 NewTL.setNameLoc(TL.getNameLoc());
5686 template<typename Derived>
5687 QualType TreeTransform<Derived>::
5688 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
5689 DependentTemplateSpecializationTypeLoc TL) {
5690 NestedNameSpecifierLoc QualifierLoc;
5691 if (TL.getQualifierLoc()) {
5693 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
5699 .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc);
5702 template<typename Derived>
5703 QualType TreeTransform<Derived>::
5704 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
5705 DependentTemplateSpecializationTypeLoc TL,
5706 NestedNameSpecifierLoc QualifierLoc) {
5707 const DependentTemplateSpecializationType *T = TL.getTypePtr();
5709 TemplateArgumentListInfo NewTemplateArgs;
5710 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
5711 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
5713 typedef TemplateArgumentLocContainerIterator<
5714 DependentTemplateSpecializationTypeLoc> ArgIterator;
5715 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5716 ArgIterator(TL, TL.getNumArgs()),
5721 = getDerived().RebuildDependentTemplateSpecializationType(T->getKeyword(),
5724 TL.getTemplateNameLoc(),
5726 if (Result.isNull())
5729 if (const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) {
5730 QualType NamedT = ElabT->getNamedType();
5732 // Copy information relevant to the template specialization.
5733 TemplateSpecializationTypeLoc NamedTL
5734 = TLB.push<TemplateSpecializationTypeLoc>(NamedT);
5735 NamedTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5736 NamedTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5737 NamedTL.setLAngleLoc(TL.getLAngleLoc());
5738 NamedTL.setRAngleLoc(TL.getRAngleLoc());
5739 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
5740 NamedTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
5742 // Copy information relevant to the elaborated type.
5743 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
5744 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5745 NewTL.setQualifierLoc(QualifierLoc);
5746 } else if (isa<DependentTemplateSpecializationType>(Result)) {
5747 DependentTemplateSpecializationTypeLoc SpecTL
5748 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
5749 SpecTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5750 SpecTL.setQualifierLoc(QualifierLoc);
5751 SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5752 SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5753 SpecTL.setLAngleLoc(TL.getLAngleLoc());
5754 SpecTL.setRAngleLoc(TL.getRAngleLoc());
5755 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
5756 SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
5758 TemplateSpecializationTypeLoc SpecTL
5759 = TLB.push<TemplateSpecializationTypeLoc>(Result);
5760 SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5761 SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5762 SpecTL.setLAngleLoc(TL.getLAngleLoc());
5763 SpecTL.setRAngleLoc(TL.getRAngleLoc());
5764 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
5765 SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
5770 template<typename Derived>
5771 QualType TreeTransform<Derived>::TransformPackExpansionType(TypeLocBuilder &TLB,
5772 PackExpansionTypeLoc TL) {
5774 = getDerived().TransformType(TLB, TL.getPatternLoc());
5775 if (Pattern.isNull())
5778 QualType Result = TL.getType();
5779 if (getDerived().AlwaysRebuild() ||
5780 Pattern != TL.getPatternLoc().getType()) {
5781 Result = getDerived().RebuildPackExpansionType(Pattern,
5782 TL.getPatternLoc().getSourceRange(),
5783 TL.getEllipsisLoc(),
5784 TL.getTypePtr()->getNumExpansions());
5785 if (Result.isNull())
5789 PackExpansionTypeLoc NewT = TLB.push<PackExpansionTypeLoc>(Result);
5790 NewT.setEllipsisLoc(TL.getEllipsisLoc());
5794 template<typename Derived>
5796 TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
5797 ObjCInterfaceTypeLoc TL) {
5798 // ObjCInterfaceType is never dependent.
5799 TLB.pushFullCopy(TL);
5800 return TL.getType();
5803 template<typename Derived>
5805 TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
5806 ObjCObjectTypeLoc TL) {
5807 // Transform base type.
5808 QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc());
5809 if (BaseType.isNull())
5812 bool AnyChanged = BaseType != TL.getBaseLoc().getType();
5814 // Transform type arguments.
5815 SmallVector<TypeSourceInfo *, 4> NewTypeArgInfos;
5816 for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) {
5817 TypeSourceInfo *TypeArgInfo = TL.getTypeArgTInfo(i);
5818 TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc();
5819 QualType TypeArg = TypeArgInfo->getType();
5820 if (auto PackExpansionLoc = TypeArgLoc.getAs<PackExpansionTypeLoc>()) {
5823 // We have a pack expansion. Instantiate it.
5824 const auto *PackExpansion = PackExpansionLoc.getType()
5825 ->castAs<PackExpansionType>();
5826 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
5827 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
5829 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
5831 // Determine whether the set of unexpanded parameter packs can
5832 // and should be expanded.
5833 TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc();
5834 bool Expand = false;
5835 bool RetainExpansion = false;
5836 Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
5837 if (getDerived().TryExpandParameterPacks(
5838 PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(),
5839 Unexpanded, Expand, RetainExpansion, NumExpansions))
5843 // We can't expand this pack expansion into separate arguments yet;
5844 // just substitute into the pattern and create a new pack expansion
5846 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
5848 TypeLocBuilder TypeArgBuilder;
5849 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
5850 QualType NewPatternType = getDerived().TransformType(TypeArgBuilder,
5852 if (NewPatternType.isNull())
5855 QualType NewExpansionType = SemaRef.Context.getPackExpansionType(
5856 NewPatternType, NumExpansions);
5857 auto NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(NewExpansionType);
5858 NewExpansionLoc.setEllipsisLoc(PackExpansionLoc.getEllipsisLoc());
5859 NewTypeArgInfos.push_back(
5860 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewExpansionType));
5864 // Substitute into the pack expansion pattern for each slice of the
5866 for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
5867 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);
5869 TypeLocBuilder TypeArgBuilder;
5870 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
5872 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder,
5874 if (NewTypeArg.isNull())
5877 NewTypeArgInfos.push_back(
5878 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
5884 TypeLocBuilder TypeArgBuilder;
5885 TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize());
5886 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder, TypeArgLoc);
5887 if (NewTypeArg.isNull())
5890 // If nothing changed, just keep the old TypeSourceInfo.
5891 if (NewTypeArg == TypeArg) {
5892 NewTypeArgInfos.push_back(TypeArgInfo);
5896 NewTypeArgInfos.push_back(
5897 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
5901 QualType Result = TL.getType();
5902 if (getDerived().AlwaysRebuild() || AnyChanged) {
5903 // Rebuild the type.
5904 Result = getDerived().RebuildObjCObjectType(
5907 TL.getTypeArgsLAngleLoc(),
5909 TL.getTypeArgsRAngleLoc(),
5910 TL.getProtocolLAngleLoc(),
5911 llvm::makeArrayRef(TL.getTypePtr()->qual_begin(),
5912 TL.getNumProtocols()),
5913 TL.getProtocolLocs(),
5914 TL.getProtocolRAngleLoc());
5916 if (Result.isNull())
5920 ObjCObjectTypeLoc NewT = TLB.push<ObjCObjectTypeLoc>(Result);
5921 assert(TL.hasBaseTypeAsWritten() && "Can't be dependent");
5922 NewT.setHasBaseTypeAsWritten(true);
5923 NewT.setTypeArgsLAngleLoc(TL.getTypeArgsLAngleLoc());
5924 for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)
5925 NewT.setTypeArgTInfo(i, NewTypeArgInfos[i]);
5926 NewT.setTypeArgsRAngleLoc(TL.getTypeArgsRAngleLoc());
5927 NewT.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
5928 for (unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
5929 NewT.setProtocolLoc(i, TL.getProtocolLoc(i));
5930 NewT.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
5934 template<typename Derived>
5936 TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
5937 ObjCObjectPointerTypeLoc TL) {
5938 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
5939 if (PointeeType.isNull())
5942 QualType Result = TL.getType();
5943 if (getDerived().AlwaysRebuild() ||
5944 PointeeType != TL.getPointeeLoc().getType()) {
5945 Result = getDerived().RebuildObjCObjectPointerType(PointeeType,
5947 if (Result.isNull())
5951 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
5952 NewT.setStarLoc(TL.getStarLoc());
5956 //===----------------------------------------------------------------------===//
5957 // Statement transformation
5958 //===----------------------------------------------------------------------===//
5959 template<typename Derived>
5961 TreeTransform<Derived>::TransformNullStmt(NullStmt *S) {
5965 template<typename Derived>
5967 TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) {
5968 return getDerived().TransformCompoundStmt(S, false);
5971 template<typename Derived>
5973 TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S,
5975 Sema::CompoundScopeRAII CompoundScope(getSema());
5977 bool SubStmtInvalid = false;
5978 bool SubStmtChanged = false;
5979 SmallVector<Stmt*, 8> Statements;
5980 for (auto *B : S->body()) {
5981 StmtResult Result = getDerived().TransformStmt(B);
5982 if (Result.isInvalid()) {
5983 // Immediately fail if this was a DeclStmt, since it's very
5984 // likely that this will cause problems for future statements.
5985 if (isa<DeclStmt>(B))
5988 // Otherwise, just keep processing substatements and fail later.
5989 SubStmtInvalid = true;
5993 SubStmtChanged = SubStmtChanged || Result.get() != B;
5994 Statements.push_back(Result.getAs<Stmt>());
6000 if (!getDerived().AlwaysRebuild() &&
6004 return getDerived().RebuildCompoundStmt(S->getLBracLoc(),
6010 template<typename Derived>
6012 TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
6013 ExprResult LHS, RHS;
6015 EnterExpressionEvaluationContext Unevaluated(SemaRef,
6016 Sema::ConstantEvaluated);
6018 // Transform the left-hand case value.
6019 LHS = getDerived().TransformExpr(S->getLHS());
6020 LHS = SemaRef.ActOnConstantExpression(LHS);
6021 if (LHS.isInvalid())
6024 // Transform the right-hand case value (for the GNU case-range extension).
6025 RHS = getDerived().TransformExpr(S->getRHS());
6026 RHS = SemaRef.ActOnConstantExpression(RHS);
6027 if (RHS.isInvalid())
6031 // Build the case statement.
6032 // Case statements are always rebuilt so that they will attached to their
6033 // transformed switch statement.
6034 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
6036 S->getEllipsisLoc(),
6039 if (Case.isInvalid())
6042 // Transform the statement following the case
6043 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6044 if (SubStmt.isInvalid())
6047 // Attach the body to the case statement
6048 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get());
6051 template<typename Derived>
6053 TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
6054 // Transform the statement following the default case
6055 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6056 if (SubStmt.isInvalid())
6059 // Default statements are always rebuilt
6060 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
6064 template<typename Derived>
6066 TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) {
6067 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6068 if (SubStmt.isInvalid())
6071 Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(),
6077 // FIXME: Pass the real colon location in.
6078 return getDerived().RebuildLabelStmt(S->getIdentLoc(),
6079 cast<LabelDecl>(LD), SourceLocation(),
6083 template <typename Derived>
6084 const Attr *TreeTransform<Derived>::TransformAttr(const Attr *R) {
6088 switch (R->getKind()) {
6089 // Transform attributes with a pragma spelling by calling TransformXXXAttr.
6091 #define PRAGMA_SPELLING_ATTR(X) \
6093 return getDerived().Transform##X##Attr(cast<X##Attr>(R));
6094 #include "clang/Basic/AttrList.inc"
6100 template <typename Derived>
6101 StmtResult TreeTransform<Derived>::TransformAttributedStmt(AttributedStmt *S) {
6102 bool AttrsChanged = false;
6103 SmallVector<const Attr *, 1> Attrs;
6105 // Visit attributes and keep track if any are transformed.
6106 for (const auto *I : S->getAttrs()) {
6107 const Attr *R = getDerived().TransformAttr(I);
6108 AttrsChanged |= (I != R);
6112 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6113 if (SubStmt.isInvalid())
6116 if (SubStmt.get() == S->getSubStmt() && !AttrsChanged)
6119 return getDerived().RebuildAttributedStmt(S->getAttrLoc(), Attrs,
6123 template<typename Derived>
6125 TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
6126 // Transform the condition
6128 VarDecl *ConditionVar = nullptr;
6129 if (S->getConditionVariable()) {
6131 = cast_or_null<VarDecl>(
6132 getDerived().TransformDefinition(
6133 S->getConditionVariable()->getLocation(),
6134 S->getConditionVariable()));
6138 Cond = getDerived().TransformExpr(S->getCond());
6140 if (Cond.isInvalid())
6143 // Convert the condition to a boolean value.
6145 ExprResult CondE = getSema().ActOnBooleanCondition(nullptr, S->getIfLoc(),
6147 if (CondE.isInvalid())
6154 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.get(), S->getIfLoc()));
6155 if (!S->getConditionVariable() && S->getCond() && !FullCond.get())
6158 // Transform the "then" branch.
6159 StmtResult Then = getDerived().TransformStmt(S->getThen());
6160 if (Then.isInvalid())
6163 // Transform the "else" branch.
6164 StmtResult Else = getDerived().TransformStmt(S->getElse());
6165 if (Else.isInvalid())
6168 if (!getDerived().AlwaysRebuild() &&
6169 FullCond.get() == S->getCond() &&
6170 ConditionVar == S->getConditionVariable() &&
6171 Then.get() == S->getThen() &&
6172 Else.get() == S->getElse())
6175 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar,
6177 S->getElseLoc(), Else.get());
6180 template<typename Derived>
6182 TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
6183 // Transform the condition.
6185 VarDecl *ConditionVar = nullptr;
6186 if (S->getConditionVariable()) {
6188 = cast_or_null<VarDecl>(
6189 getDerived().TransformDefinition(
6190 S->getConditionVariable()->getLocation(),
6191 S->getConditionVariable()));
6195 Cond = getDerived().TransformExpr(S->getCond());
6197 if (Cond.isInvalid())
6201 // Rebuild the switch statement.
6203 = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), Cond.get(),
6205 if (Switch.isInvalid())
6208 // Transform the body of the switch statement.
6209 StmtResult Body = getDerived().TransformStmt(S->getBody());
6210 if (Body.isInvalid())
6213 // Complete the switch statement.
6214 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(),
6218 template<typename Derived>
6220 TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
6221 // Transform the condition
6223 VarDecl *ConditionVar = nullptr;
6224 if (S->getConditionVariable()) {
6226 = cast_or_null<VarDecl>(
6227 getDerived().TransformDefinition(
6228 S->getConditionVariable()->getLocation(),
6229 S->getConditionVariable()));
6233 Cond = getDerived().TransformExpr(S->getCond());
6235 if (Cond.isInvalid())
6239 // Convert the condition to a boolean value.
6240 ExprResult CondE = getSema().ActOnBooleanCondition(nullptr,
6243 if (CondE.isInvalid())
6249 Sema::FullExprArg FullCond(
6250 getSema().MakeFullExpr(Cond.get(), S->getWhileLoc()));
6251 if (!S->getConditionVariable() && S->getCond() && !FullCond.get())
6254 // Transform the body
6255 StmtResult Body = getDerived().TransformStmt(S->getBody());
6256 if (Body.isInvalid())
6259 if (!getDerived().AlwaysRebuild() &&
6260 FullCond.get() == S->getCond() &&
6261 ConditionVar == S->getConditionVariable() &&
6262 Body.get() == S->getBody())
6265 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond,
6266 ConditionVar, Body.get());
6269 template<typename Derived>
6271 TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
6272 // Transform the body
6273 StmtResult Body = getDerived().TransformStmt(S->getBody());
6274 if (Body.isInvalid())
6277 // Transform the condition
6278 ExprResult Cond = getDerived().TransformExpr(S->getCond());
6279 if (Cond.isInvalid())
6282 if (!getDerived().AlwaysRebuild() &&
6283 Cond.get() == S->getCond() &&
6284 Body.get() == S->getBody())
6287 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(),
6288 /*FIXME:*/S->getWhileLoc(), Cond.get(),
6292 template<typename Derived>
6294 TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
6295 // Transform the initialization statement
6296 StmtResult Init = getDerived().TransformStmt(S->getInit());
6297 if (Init.isInvalid())
6300 // In OpenMP loop region loop control variable must be captured and be
6301 // private. Perform analysis of first part (if any).
6302 if (getSema().getLangOpts().OpenMP && Init.isUsable())
6303 getSema().ActOnOpenMPLoopInitialization(S->getForLoc(), Init.get());
6305 // Transform the condition
6307 VarDecl *ConditionVar = nullptr;
6308 if (S->getConditionVariable()) {
6310 = cast_or_null<VarDecl>(
6311 getDerived().TransformDefinition(
6312 S->getConditionVariable()->getLocation(),
6313 S->getConditionVariable()));
6317 Cond = getDerived().TransformExpr(S->getCond());
6319 if (Cond.isInvalid())
6323 // Convert the condition to a boolean value.
6324 ExprResult CondE = getSema().ActOnBooleanCondition(nullptr,
6327 if (CondE.isInvalid())
6334 Sema::FullExprArg FullCond(
6335 getSema().MakeFullExpr(Cond.get(), S->getForLoc()));
6336 if (!S->getConditionVariable() && S->getCond() && !FullCond.get())
6339 // Transform the increment
6340 ExprResult Inc = getDerived().TransformExpr(S->getInc());
6341 if (Inc.isInvalid())
6344 Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(Inc.get()));
6345 if (S->getInc() && !FullInc.get())
6348 // Transform the body
6349 StmtResult Body = getDerived().TransformStmt(S->getBody());
6350 if (Body.isInvalid())
6353 if (!getDerived().AlwaysRebuild() &&
6354 Init.get() == S->getInit() &&
6355 FullCond.get() == S->getCond() &&
6356 Inc.get() == S->getInc() &&
6357 Body.get() == S->getBody())
6360 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
6361 Init.get(), FullCond, ConditionVar,
6362 FullInc, S->getRParenLoc(), Body.get());
6365 template<typename Derived>
6367 TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
6368 Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(),
6373 // Goto statements must always be rebuilt, to resolve the label.
6374 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
6375 cast<LabelDecl>(LD));
6378 template<typename Derived>
6380 TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
6381 ExprResult Target = getDerived().TransformExpr(S->getTarget());
6382 if (Target.isInvalid())
6384 Target = SemaRef.MaybeCreateExprWithCleanups(Target.get());
6386 if (!getDerived().AlwaysRebuild() &&
6387 Target.get() == S->getTarget())
6390 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
6394 template<typename Derived>
6396 TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
6400 template<typename Derived>
6402 TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
6406 template<typename Derived>
6408 TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
6409 ExprResult Result = getDerived().TransformInitializer(S->getRetValue(),
6410 /*NotCopyInit*/false);
6411 if (Result.isInvalid())
6414 // FIXME: We always rebuild the return statement because there is no way
6415 // to tell whether the return type of the function has changed.
6416 return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get());
6419 template<typename Derived>
6421 TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
6422 bool DeclChanged = false;
6423 SmallVector<Decl *, 4> Decls;
6424 for (auto *D : S->decls()) {
6425 Decl *Transformed = getDerived().TransformDefinition(D->getLocation(), D);
6429 if (Transformed != D)
6432 Decls.push_back(Transformed);
6435 if (!getDerived().AlwaysRebuild() && !DeclChanged)
6438 return getDerived().RebuildDeclStmt(Decls, S->getStartLoc(), S->getEndLoc());
6441 template<typename Derived>
6443 TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) {
6445 SmallVector<Expr*, 8> Constraints;
6446 SmallVector<Expr*, 8> Exprs;
6447 SmallVector<IdentifierInfo *, 4> Names;
6449 ExprResult AsmString;
6450 SmallVector<Expr*, 8> Clobbers;
6452 bool ExprsChanged = false;
6454 // Go through the outputs.
6455 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) {
6456 Names.push_back(S->getOutputIdentifier(I));
6458 // No need to transform the constraint literal.
6459 Constraints.push_back(S->getOutputConstraintLiteral(I));
6461 // Transform the output expr.
6462 Expr *OutputExpr = S->getOutputExpr(I);
6463 ExprResult Result = getDerived().TransformExpr(OutputExpr);
6464 if (Result.isInvalid())
6467 ExprsChanged |= Result.get() != OutputExpr;
6469 Exprs.push_back(Result.get());
6472 // Go through the inputs.
6473 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) {
6474 Names.push_back(S->getInputIdentifier(I));
6476 // No need to transform the constraint literal.
6477 Constraints.push_back(S->getInputConstraintLiteral(I));
6479 // Transform the input expr.
6480 Expr *InputExpr = S->getInputExpr(I);
6481 ExprResult Result = getDerived().TransformExpr(InputExpr);
6482 if (Result.isInvalid())
6485 ExprsChanged |= Result.get() != InputExpr;
6487 Exprs.push_back(Result.get());
6490 if (!getDerived().AlwaysRebuild() && !ExprsChanged)
6493 // Go through the clobbers.
6494 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I)
6495 Clobbers.push_back(S->getClobberStringLiteral(I));
6497 // No need to transform the asm string literal.
6498 AsmString = S->getAsmString();
6499 return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(),
6500 S->isVolatile(), S->getNumOutputs(),
6501 S->getNumInputs(), Names.data(),
6502 Constraints, Exprs, AsmString.get(),
6503 Clobbers, S->getRParenLoc());
6506 template<typename Derived>
6508 TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
6509 ArrayRef<Token> AsmToks =
6510 llvm::makeArrayRef(S->getAsmToks(), S->getNumAsmToks());
6512 bool HadError = false, HadChange = false;
6514 ArrayRef<Expr*> SrcExprs = S->getAllExprs();
6515 SmallVector<Expr*, 8> TransformedExprs;
6516 TransformedExprs.reserve(SrcExprs.size());
6517 for (unsigned i = 0, e = SrcExprs.size(); i != e; ++i) {
6518 ExprResult Result = getDerived().TransformExpr(SrcExprs[i]);
6519 if (!Result.isUsable()) {
6522 HadChange |= (Result.get() != SrcExprs[i]);
6523 TransformedExprs.push_back(Result.get());
6527 if (HadError) return StmtError();
6528 if (!HadChange && !getDerived().AlwaysRebuild())
6531 return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(),
6532 AsmToks, S->getAsmString(),
6533 S->getNumOutputs(), S->getNumInputs(),
6534 S->getAllConstraints(), S->getClobbers(),
6535 TransformedExprs, S->getEndLoc());
6538 // C++ Coroutines TS
6540 template<typename Derived>
6542 TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) {
6543 // The coroutine body should be re-formed by the caller if necessary.
6544 return getDerived().TransformStmt(S->getBody());
6547 template<typename Derived>
6549 TreeTransform<Derived>::TransformCoreturnStmt(CoreturnStmt *S) {
6550 ExprResult Result = getDerived().TransformInitializer(S->getOperand(),
6551 /*NotCopyInit*/false);
6552 if (Result.isInvalid())
6555 // Always rebuild; we don't know if this needs to be injected into a new
6556 // context or if the promise type has changed.
6557 return getDerived().RebuildCoreturnStmt(S->getKeywordLoc(), Result.get());
6560 template<typename Derived>
6562 TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *E) {
6563 ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
6564 /*NotCopyInit*/false);
6565 if (Result.isInvalid())
6568 // Always rebuild; we don't know if this needs to be injected into a new
6569 // context or if the promise type has changed.
6570 return getDerived().RebuildCoawaitExpr(E->getKeywordLoc(), Result.get());
6573 template<typename Derived>
6575 TreeTransform<Derived>::TransformCoyieldExpr(CoyieldExpr *E) {
6576 ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
6577 /*NotCopyInit*/false);
6578 if (Result.isInvalid())
6581 // Always rebuild; we don't know if this needs to be injected into a new
6582 // context or if the promise type has changed.
6583 return getDerived().RebuildCoyieldExpr(E->getKeywordLoc(), Result.get());
6586 // Objective-C Statements.
6588 template<typename Derived>
6590 TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
6591 // Transform the body of the @try.
6592 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
6593 if (TryBody.isInvalid())
6596 // Transform the @catch statements (if present).
6597 bool AnyCatchChanged = false;
6598 SmallVector<Stmt*, 8> CatchStmts;
6599 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
6600 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I));
6601 if (Catch.isInvalid())
6603 if (Catch.get() != S->getCatchStmt(I))
6604 AnyCatchChanged = true;
6605 CatchStmts.push_back(Catch.get());
6608 // Transform the @finally statement (if present).
6610 if (S->getFinallyStmt()) {
6611 Finally = getDerived().TransformStmt(S->getFinallyStmt());
6612 if (Finally.isInvalid())
6616 // If nothing changed, just retain this statement.
6617 if (!getDerived().AlwaysRebuild() &&
6618 TryBody.get() == S->getTryBody() &&
6620 Finally.get() == S->getFinallyStmt())
6623 // Build a new statement.
6624 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(),
6625 CatchStmts, Finally.get());
6628 template<typename Derived>
6630 TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
6631 // Transform the @catch parameter, if there is one.
6632 VarDecl *Var = nullptr;
6633 if (VarDecl *FromVar = S->getCatchParamDecl()) {
6634 TypeSourceInfo *TSInfo = nullptr;
6635 if (FromVar->getTypeSourceInfo()) {
6636 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
6643 T = TSInfo->getType();
6645 T = getDerived().TransformType(FromVar->getType());
6650 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T);
6655 StmtResult Body = getDerived().TransformStmt(S->getCatchBody());
6656 if (Body.isInvalid())
6659 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
6664 template<typename Derived>
6666 TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
6667 // Transform the body.
6668 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
6669 if (Body.isInvalid())
6672 // If nothing changed, just retain this statement.
6673 if (!getDerived().AlwaysRebuild() &&
6674 Body.get() == S->getFinallyBody())
6677 // Build a new statement.
6678 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
6682 template<typename Derived>
6684 TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
6686 if (S->getThrowExpr()) {
6687 Operand = getDerived().TransformExpr(S->getThrowExpr());
6688 if (Operand.isInvalid())
6692 if (!getDerived().AlwaysRebuild() &&
6693 Operand.get() == S->getThrowExpr())
6696 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get());
6699 template<typename Derived>
6701 TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
6702 ObjCAtSynchronizedStmt *S) {
6703 // Transform the object we are locking.
6704 ExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
6705 if (Object.isInvalid())
6708 getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(),
6710 if (Object.isInvalid())
6713 // Transform the body.
6714 StmtResult Body = getDerived().TransformStmt(S->getSynchBody());
6715 if (Body.isInvalid())
6718 // If nothing change, just retain the current statement.
6719 if (!getDerived().AlwaysRebuild() &&
6720 Object.get() == S->getSynchExpr() &&
6721 Body.get() == S->getSynchBody())
6724 // Build a new statement.
6725 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
6726 Object.get(), Body.get());
6729 template<typename Derived>
6731 TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt(
6732 ObjCAutoreleasePoolStmt *S) {
6733 // Transform the body.
6734 StmtResult Body = getDerived().TransformStmt(S->getSubStmt());
6735 if (Body.isInvalid())
6738 // If nothing changed, just retain this statement.
6739 if (!getDerived().AlwaysRebuild() &&
6740 Body.get() == S->getSubStmt())
6743 // Build a new statement.
6744 return getDerived().RebuildObjCAutoreleasePoolStmt(
6745 S->getAtLoc(), Body.get());
6748 template<typename Derived>
6750 TreeTransform<Derived>::TransformObjCForCollectionStmt(
6751 ObjCForCollectionStmt *S) {
6752 // Transform the element statement.
6753 StmtResult Element = getDerived().TransformStmt(S->getElement());
6754 if (Element.isInvalid())
6757 // Transform the collection expression.
6758 ExprResult Collection = getDerived().TransformExpr(S->getCollection());
6759 if (Collection.isInvalid())
6762 // Transform the body.
6763 StmtResult Body = getDerived().TransformStmt(S->getBody());
6764 if (Body.isInvalid())
6767 // If nothing changed, just retain this statement.
6768 if (!getDerived().AlwaysRebuild() &&
6769 Element.get() == S->getElement() &&
6770 Collection.get() == S->getCollection() &&
6771 Body.get() == S->getBody())
6774 // Build a new statement.
6775 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
6782 template <typename Derived>
6783 StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
6784 // Transform the exception declaration, if any.
6785 VarDecl *Var = nullptr;
6786 if (VarDecl *ExceptionDecl = S->getExceptionDecl()) {
6788 getDerived().TransformType(ExceptionDecl->getTypeSourceInfo());
6792 Var = getDerived().RebuildExceptionDecl(
6793 ExceptionDecl, T, ExceptionDecl->getInnerLocStart(),
6794 ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier());
6795 if (!Var || Var->isInvalidDecl())
6799 // Transform the actual exception handler.
6800 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
6801 if (Handler.isInvalid())
6804 if (!getDerived().AlwaysRebuild() && !Var &&
6805 Handler.get() == S->getHandlerBlock())
6808 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get());
6811 template <typename Derived>
6812 StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
6813 // Transform the try block itself.
6814 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
6815 if (TryBlock.isInvalid())
6818 // Transform the handlers.
6819 bool HandlerChanged = false;
6820 SmallVector<Stmt *, 8> Handlers;
6821 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) {
6822 StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(I));
6823 if (Handler.isInvalid())
6826 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I);
6827 Handlers.push_back(Handler.getAs<Stmt>());
6830 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
6834 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(),
6838 template<typename Derived>
6840 TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) {
6841 StmtResult Range = getDerived().TransformStmt(S->getRangeStmt());
6842 if (Range.isInvalid())
6845 StmtResult BeginEnd = getDerived().TransformStmt(S->getBeginEndStmt());
6846 if (BeginEnd.isInvalid())
6849 ExprResult Cond = getDerived().TransformExpr(S->getCond());
6850 if (Cond.isInvalid())
6853 Cond = SemaRef.CheckBooleanCondition(Cond.get(), S->getColonLoc());
6854 if (Cond.isInvalid())
6857 Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.get());
6859 ExprResult Inc = getDerived().TransformExpr(S->getInc());
6860 if (Inc.isInvalid())
6863 Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.get());
6865 StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt());
6866 if (LoopVar.isInvalid())
6869 StmtResult NewStmt = S;
6870 if (getDerived().AlwaysRebuild() ||
6871 Range.get() != S->getRangeStmt() ||
6872 BeginEnd.get() != S->getBeginEndStmt() ||
6873 Cond.get() != S->getCond() ||
6874 Inc.get() != S->getInc() ||
6875 LoopVar.get() != S->getLoopVarStmt()) {
6876 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
6878 S->getColonLoc(), Range.get(),
6879 BeginEnd.get(), Cond.get(),
6880 Inc.get(), LoopVar.get(),
6882 if (NewStmt.isInvalid())
6886 StmtResult Body = getDerived().TransformStmt(S->getBody());
6887 if (Body.isInvalid())
6890 // Body has changed but we didn't rebuild the for-range statement. Rebuild
6891 // it now so we have a new statement to attach the body to.
6892 if (Body.get() != S->getBody() && NewStmt.get() == S) {
6893 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
6895 S->getColonLoc(), Range.get(),
6896 BeginEnd.get(), Cond.get(),
6897 Inc.get(), LoopVar.get(),
6899 if (NewStmt.isInvalid())
6903 if (NewStmt.get() == S)
6906 return FinishCXXForRangeStmt(NewStmt.get(), Body.get());
6909 template<typename Derived>
6911 TreeTransform<Derived>::TransformMSDependentExistsStmt(
6912 MSDependentExistsStmt *S) {
6913 // Transform the nested-name-specifier, if any.
6914 NestedNameSpecifierLoc QualifierLoc;
6915 if (S->getQualifierLoc()) {
6917 = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc());
6922 // Transform the declaration name.
6923 DeclarationNameInfo NameInfo = S->getNameInfo();
6924 if (NameInfo.getName()) {
6925 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
6926 if (!NameInfo.getName())
6930 // Check whether anything changed.
6931 if (!getDerived().AlwaysRebuild() &&
6932 QualifierLoc == S->getQualifierLoc() &&
6933 NameInfo.getName() == S->getNameInfo().getName())
6936 // Determine whether this name exists, if we can.
6938 SS.Adopt(QualifierLoc);
6939 bool Dependent = false;
6940 switch (getSema().CheckMicrosoftIfExistsSymbol(/*S=*/nullptr, SS, NameInfo)) {
6941 case Sema::IER_Exists:
6942 if (S->isIfExists())
6945 return new (getSema().Context) NullStmt(S->getKeywordLoc());
6947 case Sema::IER_DoesNotExist:
6948 if (S->isIfNotExists())
6951 return new (getSema().Context) NullStmt(S->getKeywordLoc());
6953 case Sema::IER_Dependent:
6957 case Sema::IER_Error:
6961 // We need to continue with the instantiation, so do so now.
6962 StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt());
6963 if (SubStmt.isInvalid())
6966 // If we have resolved the name, just transform to the substatement.
6970 // The name is still dependent, so build a dependent expression again.
6971 return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(),
6978 template<typename Derived>
6980 TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *E) {
6981 NestedNameSpecifierLoc QualifierLoc;
6982 if (E->getQualifierLoc()) {
6984 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
6989 MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>(
6990 getDerived().TransformDecl(E->getMemberLoc(), E->getPropertyDecl()));
6994 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
6995 if (Base.isInvalid())
6998 return new (SemaRef.getASTContext())
6999 MSPropertyRefExpr(Base.get(), PD, E->isArrow(),
7000 SemaRef.getASTContext().PseudoObjectTy, VK_LValue,
7001 QualifierLoc, E->getMemberLoc());
7004 template <typename Derived>
7005 ExprResult TreeTransform<Derived>::TransformMSPropertySubscriptExpr(
7006 MSPropertySubscriptExpr *E) {
7007 auto BaseRes = getDerived().TransformExpr(E->getBase());
7008 if (BaseRes.isInvalid())
7010 auto IdxRes = getDerived().TransformExpr(E->getIdx());
7011 if (IdxRes.isInvalid())
7014 if (!getDerived().AlwaysRebuild() &&
7015 BaseRes.get() == E->getBase() &&
7016 IdxRes.get() == E->getIdx())
7019 return getDerived().RebuildArraySubscriptExpr(
7020 BaseRes.get(), SourceLocation(), IdxRes.get(), E->getRBracketLoc());
7023 template <typename Derived>
7024 StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) {
7025 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
7026 if (TryBlock.isInvalid())
7029 StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler());
7030 if (Handler.isInvalid())
7033 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
7034 Handler.get() == S->getHandler())
7037 return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(),
7038 TryBlock.get(), Handler.get());
7041 template <typename Derived>
7042 StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) {
7043 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
7044 if (Block.isInvalid())
7047 return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.get());
7050 template <typename Derived>
7051 StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) {
7052 ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr());
7053 if (FilterExpr.isInvalid())
7056 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
7057 if (Block.isInvalid())
7060 return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(),
7064 template <typename Derived>
7065 StmtResult TreeTransform<Derived>::TransformSEHHandler(Stmt *Handler) {
7066 if (isa<SEHFinallyStmt>(Handler))
7067 return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler));
7069 return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler));
7072 template<typename Derived>
7074 TreeTransform<Derived>::TransformSEHLeaveStmt(SEHLeaveStmt *S) {
7078 //===----------------------------------------------------------------------===//
7079 // OpenMP directive transformation
7080 //===----------------------------------------------------------------------===//
7081 template <typename Derived>
7082 StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective(
7083 OMPExecutableDirective *D) {
7085 // Transform the clauses
7086 llvm::SmallVector<OMPClause *, 16> TClauses;
7087 ArrayRef<OMPClause *> Clauses = D->clauses();
7088 TClauses.reserve(Clauses.size());
7089 for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
7092 getDerived().getSema().StartOpenMPClause((*I)->getClauseKind());
7093 OMPClause *Clause = getDerived().TransformOMPClause(*I);
7094 getDerived().getSema().EndOpenMPClause();
7096 TClauses.push_back(Clause);
7098 TClauses.push_back(nullptr);
7101 StmtResult AssociatedStmt;
7102 if (D->hasAssociatedStmt() && D->getAssociatedStmt()) {
7103 getDerived().getSema().ActOnOpenMPRegionStart(D->getDirectiveKind(),
7104 /*CurScope=*/nullptr);
7107 Sema::CompoundScopeRAII CompoundScope(getSema());
7108 Body = getDerived().TransformStmt(
7109 cast<CapturedStmt>(D->getAssociatedStmt())->getCapturedStmt());
7112 getDerived().getSema().ActOnOpenMPRegionEnd(Body, TClauses);
7113 if (AssociatedStmt.isInvalid()) {
7117 if (TClauses.size() != Clauses.size()) {
7121 // Transform directive name for 'omp critical' directive.
7122 DeclarationNameInfo DirName;
7123 if (D->getDirectiveKind() == OMPD_critical) {
7124 DirName = cast<OMPCriticalDirective>(D)->getDirectiveName();
7125 DirName = getDerived().TransformDeclarationNameInfo(DirName);
7127 OpenMPDirectiveKind CancelRegion = OMPD_unknown;
7128 if (D->getDirectiveKind() == OMPD_cancellation_point) {
7129 CancelRegion = cast<OMPCancellationPointDirective>(D)->getCancelRegion();
7130 } else if (D->getDirectiveKind() == OMPD_cancel) {
7131 CancelRegion = cast<OMPCancelDirective>(D)->getCancelRegion();
7134 return getDerived().RebuildOMPExecutableDirective(
7135 D->getDirectiveKind(), DirName, CancelRegion, TClauses,
7136 AssociatedStmt.get(), D->getLocStart(), D->getLocEnd());
7139 template <typename Derived>
7141 TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) {
7142 DeclarationNameInfo DirName;
7143 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel, DirName, nullptr,
7145 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7146 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7150 template <typename Derived>
7152 TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *D) {
7153 DeclarationNameInfo DirName;
7154 getDerived().getSema().StartOpenMPDSABlock(OMPD_simd, DirName, nullptr,
7156 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7157 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7161 template <typename Derived>
7163 TreeTransform<Derived>::TransformOMPForDirective(OMPForDirective *D) {
7164 DeclarationNameInfo DirName;
7165 getDerived().getSema().StartOpenMPDSABlock(OMPD_for, DirName, nullptr,
7167 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7168 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7172 template <typename Derived>
7174 TreeTransform<Derived>::TransformOMPForSimdDirective(OMPForSimdDirective *D) {
7175 DeclarationNameInfo DirName;
7176 getDerived().getSema().StartOpenMPDSABlock(OMPD_for_simd, DirName, nullptr,
7178 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7179 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7183 template <typename Derived>
7185 TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *D) {
7186 DeclarationNameInfo DirName;
7187 getDerived().getSema().StartOpenMPDSABlock(OMPD_sections, DirName, nullptr,
7189 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7190 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7194 template <typename Derived>
7196 TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *D) {
7197 DeclarationNameInfo DirName;
7198 getDerived().getSema().StartOpenMPDSABlock(OMPD_section, DirName, nullptr,
7200 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7201 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7205 template <typename Derived>
7207 TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *D) {
7208 DeclarationNameInfo DirName;
7209 getDerived().getSema().StartOpenMPDSABlock(OMPD_single, DirName, nullptr,
7211 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7212 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7216 template <typename Derived>
7218 TreeTransform<Derived>::TransformOMPMasterDirective(OMPMasterDirective *D) {
7219 DeclarationNameInfo DirName;
7220 getDerived().getSema().StartOpenMPDSABlock(OMPD_master, DirName, nullptr,
7222 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7223 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7227 template <typename Derived>
7229 TreeTransform<Derived>::TransformOMPCriticalDirective(OMPCriticalDirective *D) {
7230 getDerived().getSema().StartOpenMPDSABlock(
7231 OMPD_critical, D->getDirectiveName(), nullptr, D->getLocStart());
7232 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7233 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7237 template <typename Derived>
7238 StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective(
7239 OMPParallelForDirective *D) {
7240 DeclarationNameInfo DirName;
7241 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for, DirName,
7242 nullptr, D->getLocStart());
7243 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7244 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7248 template <typename Derived>
7249 StmtResult TreeTransform<Derived>::TransformOMPParallelForSimdDirective(
7250 OMPParallelForSimdDirective *D) {
7251 DeclarationNameInfo DirName;
7252 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for_simd, DirName,
7253 nullptr, D->getLocStart());
7254 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7255 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7259 template <typename Derived>
7260 StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective(
7261 OMPParallelSectionsDirective *D) {
7262 DeclarationNameInfo DirName;
7263 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_sections, DirName,
7264 nullptr, D->getLocStart());
7265 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7266 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7270 template <typename Derived>
7272 TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *D) {
7273 DeclarationNameInfo DirName;
7274 getDerived().getSema().StartOpenMPDSABlock(OMPD_task, DirName, nullptr,
7276 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7277 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7281 template <typename Derived>
7282 StmtResult TreeTransform<Derived>::TransformOMPTaskyieldDirective(
7283 OMPTaskyieldDirective *D) {
7284 DeclarationNameInfo DirName;
7285 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskyield, DirName, nullptr,
7287 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7288 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7292 template <typename Derived>
7294 TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *D) {
7295 DeclarationNameInfo DirName;
7296 getDerived().getSema().StartOpenMPDSABlock(OMPD_barrier, DirName, nullptr,
7298 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7299 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7303 template <typename Derived>
7305 TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
7306 DeclarationNameInfo DirName;
7307 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskwait, DirName, nullptr,
7309 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7310 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7314 template <typename Derived>
7315 StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective(
7316 OMPTaskgroupDirective *D) {
7317 DeclarationNameInfo DirName;
7318 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskgroup, DirName, nullptr,
7320 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7321 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7325 template <typename Derived>
7327 TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *D) {
7328 DeclarationNameInfo DirName;
7329 getDerived().getSema().StartOpenMPDSABlock(OMPD_flush, DirName, nullptr,
7331 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7332 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7336 template <typename Derived>
7338 TreeTransform<Derived>::TransformOMPOrderedDirective(OMPOrderedDirective *D) {
7339 DeclarationNameInfo DirName;
7340 getDerived().getSema().StartOpenMPDSABlock(OMPD_ordered, DirName, nullptr,
7342 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7343 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7347 template <typename Derived>
7349 TreeTransform<Derived>::TransformOMPAtomicDirective(OMPAtomicDirective *D) {
7350 DeclarationNameInfo DirName;
7351 getDerived().getSema().StartOpenMPDSABlock(OMPD_atomic, DirName, nullptr,
7353 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7354 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7358 template <typename Derived>
7360 TreeTransform<Derived>::TransformOMPTargetDirective(OMPTargetDirective *D) {
7361 DeclarationNameInfo DirName;
7362 getDerived().getSema().StartOpenMPDSABlock(OMPD_target, DirName, nullptr,
7364 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7365 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7369 template <typename Derived>
7370 StmtResult TreeTransform<Derived>::TransformOMPTargetDataDirective(
7371 OMPTargetDataDirective *D) {
7372 DeclarationNameInfo DirName;
7373 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_data, DirName, nullptr,
7375 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7376 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7380 template <typename Derived>
7382 TreeTransform<Derived>::TransformOMPTeamsDirective(OMPTeamsDirective *D) {
7383 DeclarationNameInfo DirName;
7384 getDerived().getSema().StartOpenMPDSABlock(OMPD_teams, DirName, nullptr,
7386 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7387 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7391 template <typename Derived>
7392 StmtResult TreeTransform<Derived>::TransformOMPCancellationPointDirective(
7393 OMPCancellationPointDirective *D) {
7394 DeclarationNameInfo DirName;
7395 getDerived().getSema().StartOpenMPDSABlock(OMPD_cancellation_point, DirName,
7396 nullptr, D->getLocStart());
7397 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7398 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7402 template <typename Derived>
7404 TreeTransform<Derived>::TransformOMPCancelDirective(OMPCancelDirective *D) {
7405 DeclarationNameInfo DirName;
7406 getDerived().getSema().StartOpenMPDSABlock(OMPD_cancel, DirName, nullptr,
7408 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7409 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7413 template <typename Derived>
7415 TreeTransform<Derived>::TransformOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
7416 DeclarationNameInfo DirName;
7417 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop, DirName, nullptr,
7419 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7420 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7424 template <typename Derived>
7425 StmtResult TreeTransform<Derived>::TransformOMPTaskLoopSimdDirective(
7426 OMPTaskLoopSimdDirective *D) {
7427 DeclarationNameInfo DirName;
7428 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop_simd, DirName,
7429 nullptr, D->getLocStart());
7430 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7431 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7435 template <typename Derived>
7436 StmtResult TreeTransform<Derived>::TransformOMPDistributeDirective(
7437 OMPDistributeDirective *D) {
7438 DeclarationNameInfo DirName;
7439 getDerived().getSema().StartOpenMPDSABlock(OMPD_distribute, DirName, nullptr,
7441 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7442 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7446 //===----------------------------------------------------------------------===//
7447 // OpenMP clause transformation
7448 //===----------------------------------------------------------------------===//
7449 template <typename Derived>
7450 OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *C) {
7451 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
7452 if (Cond.isInvalid())
7454 return getDerived().RebuildOMPIfClause(
7455 C->getNameModifier(), Cond.get(), C->getLocStart(), C->getLParenLoc(),
7456 C->getNameModifierLoc(), C->getColonLoc(), C->getLocEnd());
7459 template <typename Derived>
7460 OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *C) {
7461 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
7462 if (Cond.isInvalid())
7464 return getDerived().RebuildOMPFinalClause(Cond.get(), C->getLocStart(),
7465 C->getLParenLoc(), C->getLocEnd());
7468 template <typename Derived>
7470 TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *C) {
7471 ExprResult NumThreads = getDerived().TransformExpr(C->getNumThreads());
7472 if (NumThreads.isInvalid())
7474 return getDerived().RebuildOMPNumThreadsClause(
7475 NumThreads.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7478 template <typename Derived>
7480 TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *C) {
7481 ExprResult E = getDerived().TransformExpr(C->getSafelen());
7484 return getDerived().RebuildOMPSafelenClause(
7485 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7488 template <typename Derived>
7490 TreeTransform<Derived>::TransformOMPSimdlenClause(OMPSimdlenClause *C) {
7491 ExprResult E = getDerived().TransformExpr(C->getSimdlen());
7494 return getDerived().RebuildOMPSimdlenClause(
7495 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7498 template <typename Derived>
7500 TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) {
7501 ExprResult E = getDerived().TransformExpr(C->getNumForLoops());
7504 return getDerived().RebuildOMPCollapseClause(
7505 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7508 template <typename Derived>
7510 TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *C) {
7511 return getDerived().RebuildOMPDefaultClause(
7512 C->getDefaultKind(), C->getDefaultKindKwLoc(), C->getLocStart(),
7513 C->getLParenLoc(), C->getLocEnd());
7516 template <typename Derived>
7518 TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *C) {
7519 return getDerived().RebuildOMPProcBindClause(
7520 C->getProcBindKind(), C->getProcBindKindKwLoc(), C->getLocStart(),
7521 C->getLParenLoc(), C->getLocEnd());
7524 template <typename Derived>
7526 TreeTransform<Derived>::TransformOMPScheduleClause(OMPScheduleClause *C) {
7527 ExprResult E = getDerived().TransformExpr(C->getChunkSize());
7530 return getDerived().RebuildOMPScheduleClause(
7531 C->getFirstScheduleModifier(), C->getSecondScheduleModifier(),
7532 C->getScheduleKind(), E.get(), C->getLocStart(), C->getLParenLoc(),
7533 C->getFirstScheduleModifierLoc(), C->getSecondScheduleModifierLoc(),
7534 C->getScheduleKindLoc(), C->getCommaLoc(), C->getLocEnd());
7537 template <typename Derived>
7539 TreeTransform<Derived>::TransformOMPOrderedClause(OMPOrderedClause *C) {
7541 if (auto *Num = C->getNumForLoops()) {
7542 E = getDerived().TransformExpr(Num);
7546 return getDerived().RebuildOMPOrderedClause(C->getLocStart(), C->getLocEnd(),
7547 C->getLParenLoc(), E.get());
7550 template <typename Derived>
7552 TreeTransform<Derived>::TransformOMPNowaitClause(OMPNowaitClause *C) {
7553 // No need to rebuild this clause, no template-dependent parameters.
7557 template <typename Derived>
7559 TreeTransform<Derived>::TransformOMPUntiedClause(OMPUntiedClause *C) {
7560 // No need to rebuild this clause, no template-dependent parameters.
7564 template <typename Derived>
7566 TreeTransform<Derived>::TransformOMPMergeableClause(OMPMergeableClause *C) {
7567 // No need to rebuild this clause, no template-dependent parameters.
7571 template <typename Derived>
7572 OMPClause *TreeTransform<Derived>::TransformOMPReadClause(OMPReadClause *C) {
7573 // No need to rebuild this clause, no template-dependent parameters.
7577 template <typename Derived>
7578 OMPClause *TreeTransform<Derived>::TransformOMPWriteClause(OMPWriteClause *C) {
7579 // No need to rebuild this clause, no template-dependent parameters.
7583 template <typename Derived>
7585 TreeTransform<Derived>::TransformOMPUpdateClause(OMPUpdateClause *C) {
7586 // No need to rebuild this clause, no template-dependent parameters.
7590 template <typename Derived>
7592 TreeTransform<Derived>::TransformOMPCaptureClause(OMPCaptureClause *C) {
7593 // No need to rebuild this clause, no template-dependent parameters.
7597 template <typename Derived>
7599 TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *C) {
7600 // No need to rebuild this clause, no template-dependent parameters.
7604 template <typename Derived>
7606 TreeTransform<Derived>::TransformOMPThreadsClause(OMPThreadsClause *C) {
7607 // No need to rebuild this clause, no template-dependent parameters.
7611 template <typename Derived>
7612 OMPClause *TreeTransform<Derived>::TransformOMPSIMDClause(OMPSIMDClause *C) {
7613 // No need to rebuild this clause, no template-dependent parameters.
7617 template <typename Derived>
7619 TreeTransform<Derived>::TransformOMPNogroupClause(OMPNogroupClause *C) {
7620 // No need to rebuild this clause, no template-dependent parameters.
7624 template <typename Derived>
7626 TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) {
7627 llvm::SmallVector<Expr *, 16> Vars;
7628 Vars.reserve(C->varlist_size());
7629 for (auto *VE : C->varlists()) {
7630 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7631 if (EVar.isInvalid())
7633 Vars.push_back(EVar.get());
7635 return getDerived().RebuildOMPPrivateClause(
7636 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7639 template <typename Derived>
7640 OMPClause *TreeTransform<Derived>::TransformOMPFirstprivateClause(
7641 OMPFirstprivateClause *C) {
7642 llvm::SmallVector<Expr *, 16> Vars;
7643 Vars.reserve(C->varlist_size());
7644 for (auto *VE : C->varlists()) {
7645 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7646 if (EVar.isInvalid())
7648 Vars.push_back(EVar.get());
7650 return getDerived().RebuildOMPFirstprivateClause(
7651 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7654 template <typename Derived>
7656 TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *C) {
7657 llvm::SmallVector<Expr *, 16> Vars;
7658 Vars.reserve(C->varlist_size());
7659 for (auto *VE : C->varlists()) {
7660 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7661 if (EVar.isInvalid())
7663 Vars.push_back(EVar.get());
7665 return getDerived().RebuildOMPLastprivateClause(
7666 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7669 template <typename Derived>
7671 TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *C) {
7672 llvm::SmallVector<Expr *, 16> Vars;
7673 Vars.reserve(C->varlist_size());
7674 for (auto *VE : C->varlists()) {
7675 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7676 if (EVar.isInvalid())
7678 Vars.push_back(EVar.get());
7680 return getDerived().RebuildOMPSharedClause(Vars, C->getLocStart(),
7681 C->getLParenLoc(), C->getLocEnd());
7684 template <typename Derived>
7686 TreeTransform<Derived>::TransformOMPReductionClause(OMPReductionClause *C) {
7687 llvm::SmallVector<Expr *, 16> Vars;
7688 Vars.reserve(C->varlist_size());
7689 for (auto *VE : C->varlists()) {
7690 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7691 if (EVar.isInvalid())
7693 Vars.push_back(EVar.get());
7695 CXXScopeSpec ReductionIdScopeSpec;
7696 ReductionIdScopeSpec.Adopt(C->getQualifierLoc());
7698 DeclarationNameInfo NameInfo = C->getNameInfo();
7699 if (NameInfo.getName()) {
7700 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
7701 if (!NameInfo.getName())
7704 return getDerived().RebuildOMPReductionClause(
7705 Vars, C->getLocStart(), C->getLParenLoc(), C->getColonLoc(),
7706 C->getLocEnd(), ReductionIdScopeSpec, NameInfo);
7709 template <typename Derived>
7711 TreeTransform<Derived>::TransformOMPLinearClause(OMPLinearClause *C) {
7712 llvm::SmallVector<Expr *, 16> Vars;
7713 Vars.reserve(C->varlist_size());
7714 for (auto *VE : C->varlists()) {
7715 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7716 if (EVar.isInvalid())
7718 Vars.push_back(EVar.get());
7720 ExprResult Step = getDerived().TransformExpr(C->getStep());
7721 if (Step.isInvalid())
7723 return getDerived().RebuildOMPLinearClause(
7724 Vars, Step.get(), C->getLocStart(), C->getLParenLoc(), C->getModifier(),
7725 C->getModifierLoc(), C->getColonLoc(), C->getLocEnd());
7728 template <typename Derived>
7730 TreeTransform<Derived>::TransformOMPAlignedClause(OMPAlignedClause *C) {
7731 llvm::SmallVector<Expr *, 16> Vars;
7732 Vars.reserve(C->varlist_size());
7733 for (auto *VE : C->varlists()) {
7734 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7735 if (EVar.isInvalid())
7737 Vars.push_back(EVar.get());
7739 ExprResult Alignment = getDerived().TransformExpr(C->getAlignment());
7740 if (Alignment.isInvalid())
7742 return getDerived().RebuildOMPAlignedClause(
7743 Vars, Alignment.get(), C->getLocStart(), C->getLParenLoc(),
7744 C->getColonLoc(), C->getLocEnd());
7747 template <typename Derived>
7749 TreeTransform<Derived>::TransformOMPCopyinClause(OMPCopyinClause *C) {
7750 llvm::SmallVector<Expr *, 16> Vars;
7751 Vars.reserve(C->varlist_size());
7752 for (auto *VE : C->varlists()) {
7753 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7754 if (EVar.isInvalid())
7756 Vars.push_back(EVar.get());
7758 return getDerived().RebuildOMPCopyinClause(Vars, C->getLocStart(),
7759 C->getLParenLoc(), C->getLocEnd());
7762 template <typename Derived>
7764 TreeTransform<Derived>::TransformOMPCopyprivateClause(OMPCopyprivateClause *C) {
7765 llvm::SmallVector<Expr *, 16> Vars;
7766 Vars.reserve(C->varlist_size());
7767 for (auto *VE : C->varlists()) {
7768 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7769 if (EVar.isInvalid())
7771 Vars.push_back(EVar.get());
7773 return getDerived().RebuildOMPCopyprivateClause(
7774 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7777 template <typename Derived>
7778 OMPClause *TreeTransform<Derived>::TransformOMPFlushClause(OMPFlushClause *C) {
7779 llvm::SmallVector<Expr *, 16> Vars;
7780 Vars.reserve(C->varlist_size());
7781 for (auto *VE : C->varlists()) {
7782 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7783 if (EVar.isInvalid())
7785 Vars.push_back(EVar.get());
7787 return getDerived().RebuildOMPFlushClause(Vars, C->getLocStart(),
7788 C->getLParenLoc(), C->getLocEnd());
7791 template <typename Derived>
7793 TreeTransform<Derived>::TransformOMPDependClause(OMPDependClause *C) {
7794 llvm::SmallVector<Expr *, 16> Vars;
7795 Vars.reserve(C->varlist_size());
7796 for (auto *VE : C->varlists()) {
7797 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7798 if (EVar.isInvalid())
7800 Vars.push_back(EVar.get());
7802 return getDerived().RebuildOMPDependClause(
7803 C->getDependencyKind(), C->getDependencyLoc(), C->getColonLoc(), Vars,
7804 C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7807 template <typename Derived>
7809 TreeTransform<Derived>::TransformOMPDeviceClause(OMPDeviceClause *C) {
7810 ExprResult E = getDerived().TransformExpr(C->getDevice());
7813 return getDerived().RebuildOMPDeviceClause(
7814 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7817 template <typename Derived>
7818 OMPClause *TreeTransform<Derived>::TransformOMPMapClause(OMPMapClause *C) {
7819 llvm::SmallVector<Expr *, 16> Vars;
7820 Vars.reserve(C->varlist_size());
7821 for (auto *VE : C->varlists()) {
7822 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7823 if (EVar.isInvalid())
7825 Vars.push_back(EVar.get());
7827 return getDerived().RebuildOMPMapClause(
7828 C->getMapTypeModifier(), C->getMapType(), C->getMapLoc(),
7829 C->getColonLoc(), Vars, C->getLocStart(), C->getLParenLoc(),
7833 template <typename Derived>
7835 TreeTransform<Derived>::TransformOMPNumTeamsClause(OMPNumTeamsClause *C) {
7836 ExprResult E = getDerived().TransformExpr(C->getNumTeams());
7839 return getDerived().RebuildOMPNumTeamsClause(
7840 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7843 template <typename Derived>
7845 TreeTransform<Derived>::TransformOMPThreadLimitClause(OMPThreadLimitClause *C) {
7846 ExprResult E = getDerived().TransformExpr(C->getThreadLimit());
7849 return getDerived().RebuildOMPThreadLimitClause(
7850 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7853 template <typename Derived>
7855 TreeTransform<Derived>::TransformOMPPriorityClause(OMPPriorityClause *C) {
7856 ExprResult E = getDerived().TransformExpr(C->getPriority());
7859 return getDerived().RebuildOMPPriorityClause(
7860 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7863 template <typename Derived>
7865 TreeTransform<Derived>::TransformOMPGrainsizeClause(OMPGrainsizeClause *C) {
7866 ExprResult E = getDerived().TransformExpr(C->getGrainsize());
7869 return getDerived().RebuildOMPGrainsizeClause(
7870 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7873 template <typename Derived>
7875 TreeTransform<Derived>::TransformOMPNumTasksClause(OMPNumTasksClause *C) {
7876 ExprResult E = getDerived().TransformExpr(C->getNumTasks());
7879 return getDerived().RebuildOMPNumTasksClause(
7880 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7883 template <typename Derived>
7884 OMPClause *TreeTransform<Derived>::TransformOMPHintClause(OMPHintClause *C) {
7885 ExprResult E = getDerived().TransformExpr(C->getHint());
7888 return getDerived().RebuildOMPHintClause(E.get(), C->getLocStart(),
7889 C->getLParenLoc(), C->getLocEnd());
7892 //===----------------------------------------------------------------------===//
7893 // Expression transformation
7894 //===----------------------------------------------------------------------===//
7895 template<typename Derived>
7897 TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) {
7898 if (!E->isTypeDependent())
7901 return getDerived().RebuildPredefinedExpr(E->getLocation(),
7905 template<typename Derived>
7907 TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) {
7908 NestedNameSpecifierLoc QualifierLoc;
7909 if (E->getQualifierLoc()) {
7911 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
7917 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
7922 DeclarationNameInfo NameInfo = E->getNameInfo();
7923 if (NameInfo.getName()) {
7924 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
7925 if (!NameInfo.getName())
7929 if (!getDerived().AlwaysRebuild() &&
7930 QualifierLoc == E->getQualifierLoc() &&
7931 ND == E->getDecl() &&
7932 NameInfo.getName() == E->getDecl()->getDeclName() &&
7933 !E->hasExplicitTemplateArgs()) {
7935 // Mark it referenced in the new context regardless.
7936 // FIXME: this is a bit instantiation-specific.
7937 SemaRef.MarkDeclRefReferenced(E);
7942 TemplateArgumentListInfo TransArgs, *TemplateArgs = nullptr;
7943 if (E->hasExplicitTemplateArgs()) {
7944 TemplateArgs = &TransArgs;
7945 TransArgs.setLAngleLoc(E->getLAngleLoc());
7946 TransArgs.setRAngleLoc(E->getRAngleLoc());
7947 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
7948 E->getNumTemplateArgs(),
7953 return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo,
7957 template<typename Derived>
7959 TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) {
7963 template<typename Derived>
7965 TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) {
7969 template<typename Derived>
7971 TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) {
7975 template<typename Derived>
7977 TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) {
7981 template<typename Derived>
7983 TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) {
7987 template<typename Derived>
7989 TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) {
7990 if (FunctionDecl *FD = E->getDirectCallee())
7991 SemaRef.MarkFunctionReferenced(E->getLocStart(), FD);
7992 return SemaRef.MaybeBindToTemporary(E);
7995 template<typename Derived>
7997 TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) {
7998 ExprResult ControllingExpr =
7999 getDerived().TransformExpr(E->getControllingExpr());
8000 if (ControllingExpr.isInvalid())
8003 SmallVector<Expr *, 4> AssocExprs;
8004 SmallVector<TypeSourceInfo *, 4> AssocTypes;
8005 for (unsigned i = 0; i != E->getNumAssocs(); ++i) {
8006 TypeSourceInfo *TS = E->getAssocTypeSourceInfo(i);
8008 TypeSourceInfo *AssocType = getDerived().TransformType(TS);
8011 AssocTypes.push_back(AssocType);
8013 AssocTypes.push_back(nullptr);
8016 ExprResult AssocExpr = getDerived().TransformExpr(E->getAssocExpr(i));
8017 if (AssocExpr.isInvalid())
8019 AssocExprs.push_back(AssocExpr.get());
8022 return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(),
8025 ControllingExpr.get(),
8030 template<typename Derived>
8032 TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
8033 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
8034 if (SubExpr.isInvalid())
8037 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
8040 return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(),
8044 /// \brief The operand of a unary address-of operator has special rules: it's
8045 /// allowed to refer to a non-static member of a class even if there's no 'this'
8046 /// object available.
8047 template<typename Derived>
8049 TreeTransform<Derived>::TransformAddressOfOperand(Expr *E) {
8050 if (DependentScopeDeclRefExpr *DRE = dyn_cast<DependentScopeDeclRefExpr>(E))
8051 return getDerived().TransformDependentScopeDeclRefExpr(DRE, true, nullptr);
8053 return getDerived().TransformExpr(E);
8056 template<typename Derived>
8058 TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) {
8060 if (E->getOpcode() == UO_AddrOf)
8061 SubExpr = TransformAddressOfOperand(E->getSubExpr());
8063 SubExpr = TransformExpr(E->getSubExpr());
8064 if (SubExpr.isInvalid())
8067 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
8070 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(),
8075 template<typename Derived>
8077 TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) {
8078 // Transform the type.
8079 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
8083 // Transform all of the components into components similar to what the
8085 // FIXME: It would be slightly more efficient in the non-dependent case to
8086 // just map FieldDecls, rather than requiring the rebuilder to look for
8087 // the fields again. However, __builtin_offsetof is rare enough in
8088 // template code that we don't care.
8089 bool ExprChanged = false;
8090 typedef Sema::OffsetOfComponent Component;
8091 SmallVector<Component, 4> Components;
8092 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
8093 const OffsetOfNode &ON = E->getComponent(I);
8095 Comp.isBrackets = true;
8096 Comp.LocStart = ON.getSourceRange().getBegin();
8097 Comp.LocEnd = ON.getSourceRange().getEnd();
8098 switch (ON.getKind()) {
8099 case OffsetOfNode::Array: {
8100 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex());
8101 ExprResult Index = getDerived().TransformExpr(FromIndex);
8102 if (Index.isInvalid())
8105 ExprChanged = ExprChanged || Index.get() != FromIndex;
8106 Comp.isBrackets = true;
8107 Comp.U.E = Index.get();
8111 case OffsetOfNode::Field:
8112 case OffsetOfNode::Identifier:
8113 Comp.isBrackets = false;
8114 Comp.U.IdentInfo = ON.getFieldName();
8115 if (!Comp.U.IdentInfo)
8120 case OffsetOfNode::Base:
8121 // Will be recomputed during the rebuild.
8125 Components.push_back(Comp);
8128 // If nothing changed, retain the existing expression.
8129 if (!getDerived().AlwaysRebuild() &&
8130 Type == E->getTypeSourceInfo() &&
8134 // Build a new offsetof expression.
8135 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type,
8136 Components, E->getRParenLoc());
8139 template<typename Derived>
8141 TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) {
8142 assert((!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) &&
8143 "opaque value expression requires transformation");
8147 template<typename Derived>
8149 TreeTransform<Derived>::TransformTypoExpr(TypoExpr *E) {
8153 template<typename Derived>
8155 TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) {
8156 // Rebuild the syntactic form. The original syntactic form has
8157 // opaque-value expressions in it, so strip those away and rebuild
8158 // the result. This is a really awful way of doing this, but the
8159 // better solution (rebuilding the semantic expressions and
8160 // rebinding OVEs as necessary) doesn't work; we'd need
8161 // TreeTransform to not strip away implicit conversions.
8162 Expr *newSyntacticForm = SemaRef.recreateSyntacticForm(E);
8163 ExprResult result = getDerived().TransformExpr(newSyntacticForm);
8164 if (result.isInvalid()) return ExprError();
8166 // If that gives us a pseudo-object result back, the pseudo-object
8167 // expression must have been an lvalue-to-rvalue conversion which we
8169 if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject))
8170 result = SemaRef.checkPseudoObjectRValue(result.get());
8175 template<typename Derived>
8177 TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr(
8178 UnaryExprOrTypeTraitExpr *E) {
8179 if (E->isArgumentType()) {
8180 TypeSourceInfo *OldT = E->getArgumentTypeInfo();
8182 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
8186 if (!getDerived().AlwaysRebuild() && OldT == NewT)
8189 return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(),
8191 E->getSourceRange());
8194 // C++0x [expr.sizeof]p1:
8195 // The operand is either an expression, which is an unevaluated operand
8197 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated,
8198 Sema::ReuseLambdaContextDecl);
8200 // Try to recover if we have something like sizeof(T::X) where X is a type.
8201 // Notably, there must be *exactly* one set of parens if X is a type.
8202 TypeSourceInfo *RecoveryTSI = nullptr;
8204 auto *PE = dyn_cast<ParenExpr>(E->getArgumentExpr());
8206 PE ? dyn_cast<DependentScopeDeclRefExpr>(PE->getSubExpr()) : nullptr)
8207 SubExpr = getDerived().TransformParenDependentScopeDeclRefExpr(
8208 PE, DRE, false, &RecoveryTSI);
8210 SubExpr = getDerived().TransformExpr(E->getArgumentExpr());
8213 return getDerived().RebuildUnaryExprOrTypeTrait(
8214 RecoveryTSI, E->getOperatorLoc(), E->getKind(), E->getSourceRange());
8215 } else if (SubExpr.isInvalid())
8218 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
8221 return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(),
8222 E->getOperatorLoc(),
8224 E->getSourceRange());
8227 template<typename Derived>
8229 TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
8230 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
8231 if (LHS.isInvalid())
8234 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
8235 if (RHS.isInvalid())
8239 if (!getDerived().AlwaysRebuild() &&
8240 LHS.get() == E->getLHS() &&
8241 RHS.get() == E->getRHS())
8244 return getDerived().RebuildArraySubscriptExpr(LHS.get(),
8245 /*FIXME:*/E->getLHS()->getLocStart(),
8247 E->getRBracketLoc());
8250 template <typename Derived>
8252 TreeTransform<Derived>::TransformOMPArraySectionExpr(OMPArraySectionExpr *E) {
8253 ExprResult Base = getDerived().TransformExpr(E->getBase());
8254 if (Base.isInvalid())
8257 ExprResult LowerBound;
8258 if (E->getLowerBound()) {
8259 LowerBound = getDerived().TransformExpr(E->getLowerBound());
8260 if (LowerBound.isInvalid())
8265 if (E->getLength()) {
8266 Length = getDerived().TransformExpr(E->getLength());
8267 if (Length.isInvalid())
8271 if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
8272 LowerBound.get() == E->getLowerBound() && Length.get() == E->getLength())
8275 return getDerived().RebuildOMPArraySectionExpr(
8276 Base.get(), E->getBase()->getLocEnd(), LowerBound.get(), E->getColonLoc(),
8277 Length.get(), E->getRBracketLoc());
8280 template<typename Derived>
8282 TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
8283 // Transform the callee.
8284 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
8285 if (Callee.isInvalid())
8288 // Transform arguments.
8289 bool ArgChanged = false;
8290 SmallVector<Expr*, 8> Args;
8291 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
8295 if (!getDerived().AlwaysRebuild() &&
8296 Callee.get() == E->getCallee() &&
8298 return SemaRef.MaybeBindToTemporary(E);
8300 // FIXME: Wrong source location information for the '('.
8301 SourceLocation FakeLParenLoc
8302 = ((Expr *)Callee.get())->getSourceRange().getBegin();
8303 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
8308 template<typename Derived>
8310 TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
8311 ExprResult Base = getDerived().TransformExpr(E->getBase());
8312 if (Base.isInvalid())
8315 NestedNameSpecifierLoc QualifierLoc;
8316 if (E->hasQualifier()) {
8318 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
8323 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
8326 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
8327 E->getMemberDecl()));
8331 NamedDecl *FoundDecl = E->getFoundDecl();
8332 if (FoundDecl == E->getMemberDecl()) {
8335 FoundDecl = cast_or_null<NamedDecl>(
8336 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl));
8341 if (!getDerived().AlwaysRebuild() &&
8342 Base.get() == E->getBase() &&
8343 QualifierLoc == E->getQualifierLoc() &&
8344 Member == E->getMemberDecl() &&
8345 FoundDecl == E->getFoundDecl() &&
8346 !E->hasExplicitTemplateArgs()) {
8348 // Mark it referenced in the new context regardless.
8349 // FIXME: this is a bit instantiation-specific.
8350 SemaRef.MarkMemberReferenced(E);
8355 TemplateArgumentListInfo TransArgs;
8356 if (E->hasExplicitTemplateArgs()) {
8357 TransArgs.setLAngleLoc(E->getLAngleLoc());
8358 TransArgs.setRAngleLoc(E->getRAngleLoc());
8359 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
8360 E->getNumTemplateArgs(),
8365 // FIXME: Bogus source location for the operator
8366 SourceLocation FakeOperatorLoc =
8367 SemaRef.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd());
8369 // FIXME: to do this check properly, we will need to preserve the
8370 // first-qualifier-in-scope here, just in case we had a dependent
8371 // base (and therefore couldn't do the check) and a
8372 // nested-name-qualifier (and therefore could do the lookup).
8373 NamedDecl *FirstQualifierInScope = nullptr;
8375 return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc,
8379 E->getMemberNameInfo(),
8382 (E->hasExplicitTemplateArgs()
8383 ? &TransArgs : nullptr),
8384 FirstQualifierInScope);
8387 template<typename Derived>
8389 TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
8390 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
8391 if (LHS.isInvalid())
8394 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
8395 if (RHS.isInvalid())
8398 if (!getDerived().AlwaysRebuild() &&
8399 LHS.get() == E->getLHS() &&
8400 RHS.get() == E->getRHS())
8403 Sema::FPContractStateRAII FPContractState(getSema());
8404 getSema().FPFeatures.fp_contract = E->isFPContractable();
8406 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
8407 LHS.get(), RHS.get());
8410 template<typename Derived>
8412 TreeTransform<Derived>::TransformCompoundAssignOperator(
8413 CompoundAssignOperator *E) {
8414 return getDerived().TransformBinaryOperator(E);
8417 template<typename Derived>
8418 ExprResult TreeTransform<Derived>::
8419 TransformBinaryConditionalOperator(BinaryConditionalOperator *e) {
8420 // Just rebuild the common and RHS expressions and see whether we
8423 ExprResult commonExpr = getDerived().TransformExpr(e->getCommon());
8424 if (commonExpr.isInvalid())
8427 ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr());
8428 if (rhs.isInvalid())
8431 if (!getDerived().AlwaysRebuild() &&
8432 commonExpr.get() == e->getCommon() &&
8433 rhs.get() == e->getFalseExpr())
8436 return getDerived().RebuildConditionalOperator(commonExpr.get(),
8437 e->getQuestionLoc(),
8443 template<typename Derived>
8445 TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) {
8446 ExprResult Cond = getDerived().TransformExpr(E->getCond());
8447 if (Cond.isInvalid())
8450 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
8451 if (LHS.isInvalid())
8454 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
8455 if (RHS.isInvalid())
8458 if (!getDerived().AlwaysRebuild() &&
8459 Cond.get() == E->getCond() &&
8460 LHS.get() == E->getLHS() &&
8461 RHS.get() == E->getRHS())
8464 return getDerived().RebuildConditionalOperator(Cond.get(),
8465 E->getQuestionLoc(),
8471 template<typename Derived>
8473 TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) {
8474 // Implicit casts are eliminated during transformation, since they
8475 // will be recomputed by semantic analysis after transformation.
8476 return getDerived().TransformExpr(E->getSubExprAsWritten());
8479 template<typename Derived>
8481 TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
8482 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
8487 = getDerived().TransformExpr(E->getSubExprAsWritten());
8488 if (SubExpr.isInvalid())
8491 if (!getDerived().AlwaysRebuild() &&
8492 Type == E->getTypeInfoAsWritten() &&
8493 SubExpr.get() == E->getSubExpr())
8496 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
8502 template<typename Derived>
8504 TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) {
8505 TypeSourceInfo *OldT = E->getTypeSourceInfo();
8506 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
8510 ExprResult Init = getDerived().TransformExpr(E->getInitializer());
8511 if (Init.isInvalid())
8514 if (!getDerived().AlwaysRebuild() &&
8516 Init.get() == E->getInitializer())
8517 return SemaRef.MaybeBindToTemporary(E);
8519 // Note: the expression type doesn't necessarily match the
8520 // type-as-written, but that's okay, because it should always be
8521 // derivable from the initializer.
8523 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT,
8524 /*FIXME:*/E->getInitializer()->getLocEnd(),
8528 template<typename Derived>
8530 TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) {
8531 ExprResult Base = getDerived().TransformExpr(E->getBase());
8532 if (Base.isInvalid())
8535 if (!getDerived().AlwaysRebuild() &&
8536 Base.get() == E->getBase())
8539 // FIXME: Bad source location
8540 SourceLocation FakeOperatorLoc =
8541 SemaRef.getLocForEndOfToken(E->getBase()->getLocEnd());
8542 return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc,
8543 E->getAccessorLoc(),
8547 template<typename Derived>
8549 TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) {
8550 if (InitListExpr *Syntactic = E->getSyntacticForm())
8553 bool InitChanged = false;
8555 SmallVector<Expr*, 4> Inits;
8556 if (getDerived().TransformExprs(E->getInits(), E->getNumInits(), false,
8557 Inits, &InitChanged))
8560 if (!getDerived().AlwaysRebuild() && !InitChanged) {
8561 // FIXME: Attempt to reuse the existing syntactic form of the InitListExpr
8562 // in some cases. We can't reuse it in general, because the syntactic and
8563 // semantic forms are linked, and we can't know that semantic form will
8564 // match even if the syntactic form does.
8567 return getDerived().RebuildInitList(E->getLBraceLoc(), Inits,
8568 E->getRBraceLoc(), E->getType());
8571 template<typename Derived>
8573 TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) {
8576 // transform the initializer value
8577 ExprResult Init = getDerived().TransformExpr(E->getInit());
8578 if (Init.isInvalid())
8581 // transform the designators.
8582 SmallVector<Expr*, 4> ArrayExprs;
8583 bool ExprChanged = false;
8584 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(),
8585 DEnd = E->designators_end();
8587 if (D->isFieldDesignator()) {
8588 Desig.AddDesignator(Designator::getField(D->getFieldName(),
8594 if (D->isArrayDesignator()) {
8595 ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D));
8596 if (Index.isInvalid())
8599 Desig.AddDesignator(Designator::getArray(Index.get(),
8600 D->getLBracketLoc()));
8602 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D);
8603 ArrayExprs.push_back(Index.get());
8607 assert(D->isArrayRangeDesignator() && "New kind of designator?");
8609 = getDerived().TransformExpr(E->getArrayRangeStart(*D));
8610 if (Start.isInvalid())
8613 ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D));
8614 if (End.isInvalid())
8617 Desig.AddDesignator(Designator::getArrayRange(Start.get(),
8619 D->getLBracketLoc(),
8620 D->getEllipsisLoc()));
8622 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) ||
8623 End.get() != E->getArrayRangeEnd(*D);
8625 ArrayExprs.push_back(Start.get());
8626 ArrayExprs.push_back(End.get());
8629 if (!getDerived().AlwaysRebuild() &&
8630 Init.get() == E->getInit() &&
8634 return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs,
8635 E->getEqualOrColonLoc(),
8636 E->usesGNUSyntax(), Init.get());
8639 // Seems that if TransformInitListExpr() only works on the syntactic form of an
8640 // InitListExpr, then a DesignatedInitUpdateExpr is not encountered.
8641 template<typename Derived>
8643 TreeTransform<Derived>::TransformDesignatedInitUpdateExpr(
8644 DesignatedInitUpdateExpr *E) {
8645 llvm_unreachable("Unexpected DesignatedInitUpdateExpr in syntactic form of "
8650 template<typename Derived>
8652 TreeTransform<Derived>::TransformNoInitExpr(
8654 llvm_unreachable("Unexpected NoInitExpr in syntactic form of initializer");
8658 template<typename Derived>
8660 TreeTransform<Derived>::TransformImplicitValueInitExpr(
8661 ImplicitValueInitExpr *E) {
8662 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName());
8664 // FIXME: Will we ever have proper type location here? Will we actually
8665 // need to transform the type?
8666 QualType T = getDerived().TransformType(E->getType());
8670 if (!getDerived().AlwaysRebuild() &&
8674 return getDerived().RebuildImplicitValueInitExpr(T);
8677 template<typename Derived>
8679 TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) {
8680 TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo());
8684 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
8685 if (SubExpr.isInvalid())
8688 if (!getDerived().AlwaysRebuild() &&
8689 TInfo == E->getWrittenTypeInfo() &&
8690 SubExpr.get() == E->getSubExpr())
8693 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(),
8694 TInfo, E->getRParenLoc());
8697 template<typename Derived>
8699 TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) {
8700 bool ArgumentChanged = false;
8701 SmallVector<Expr*, 4> Inits;
8702 if (TransformExprs(E->getExprs(), E->getNumExprs(), true, Inits,
8706 return getDerived().RebuildParenListExpr(E->getLParenLoc(),
8711 /// \brief Transform an address-of-label expression.
8713 /// By default, the transformation of an address-of-label expression always
8714 /// rebuilds the expression, so that the label identifier can be resolved to
8715 /// the corresponding label statement by semantic analysis.
8716 template<typename Derived>
8718 TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) {
8719 Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(),
8724 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
8725 cast<LabelDecl>(LD));
8728 template<typename Derived>
8730 TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) {
8731 SemaRef.ActOnStartStmtExpr();
8733 = getDerived().TransformCompoundStmt(E->getSubStmt(), true);
8734 if (SubStmt.isInvalid()) {
8735 SemaRef.ActOnStmtExprError();
8739 if (!getDerived().AlwaysRebuild() &&
8740 SubStmt.get() == E->getSubStmt()) {
8741 // Calling this an 'error' is unintuitive, but it does the right thing.
8742 SemaRef.ActOnStmtExprError();
8743 return SemaRef.MaybeBindToTemporary(E);
8746 return getDerived().RebuildStmtExpr(E->getLParenLoc(),
8751 template<typename Derived>
8753 TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) {
8754 ExprResult Cond = getDerived().TransformExpr(E->getCond());
8755 if (Cond.isInvalid())
8758 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
8759 if (LHS.isInvalid())
8762 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
8763 if (RHS.isInvalid())
8766 if (!getDerived().AlwaysRebuild() &&
8767 Cond.get() == E->getCond() &&
8768 LHS.get() == E->getLHS() &&
8769 RHS.get() == E->getRHS())
8772 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(),
8773 Cond.get(), LHS.get(), RHS.get(),
8777 template<typename Derived>
8779 TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) {
8783 template<typename Derived>
8785 TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
8786 switch (E->getOperator()) {
8790 case OO_Array_Delete:
8791 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr");
8794 // This is a call to an object's operator().
8795 assert(E->getNumArgs() >= 1 && "Object call is missing arguments");
8797 // Transform the object itself.
8798 ExprResult Object = getDerived().TransformExpr(E->getArg(0));
8799 if (Object.isInvalid())
8802 // FIXME: Poor location information
8803 SourceLocation FakeLParenLoc = SemaRef.getLocForEndOfToken(
8804 static_cast<Expr *>(Object.get())->getLocEnd());
8806 // Transform the call arguments.
8807 SmallVector<Expr*, 8> Args;
8808 if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1, true,
8812 return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc,
8817 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
8819 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
8820 #include "clang/Basic/OperatorKinds.def"
8825 case OO_Conditional:
8826 llvm_unreachable("conditional operator is not actually overloadable");
8829 case NUM_OVERLOADED_OPERATORS:
8830 llvm_unreachable("not an overloaded operator?");
8833 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
8834 if (Callee.isInvalid())
8838 if (E->getOperator() == OO_Amp)
8839 First = getDerived().TransformAddressOfOperand(E->getArg(0));
8841 First = getDerived().TransformExpr(E->getArg(0));
8842 if (First.isInvalid())
8846 if (E->getNumArgs() == 2) {
8847 Second = getDerived().TransformExpr(E->getArg(1));
8848 if (Second.isInvalid())
8852 if (!getDerived().AlwaysRebuild() &&
8853 Callee.get() == E->getCallee() &&
8854 First.get() == E->getArg(0) &&
8855 (E->getNumArgs() != 2 || Second.get() == E->getArg(1)))
8856 return SemaRef.MaybeBindToTemporary(E);
8858 Sema::FPContractStateRAII FPContractState(getSema());
8859 getSema().FPFeatures.fp_contract = E->isFPContractable();
8861 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(),
8862 E->getOperatorLoc(),
8868 template<typename Derived>
8870 TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) {
8871 return getDerived().TransformCallExpr(E);
8874 template<typename Derived>
8876 TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
8877 // Transform the callee.
8878 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
8879 if (Callee.isInvalid())
8882 // Transform exec config.
8883 ExprResult EC = getDerived().TransformCallExpr(E->getConfig());
8887 // Transform arguments.
8888 bool ArgChanged = false;
8889 SmallVector<Expr*, 8> Args;
8890 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
8894 if (!getDerived().AlwaysRebuild() &&
8895 Callee.get() == E->getCallee() &&
8897 return SemaRef.MaybeBindToTemporary(E);
8899 // FIXME: Wrong source location information for the '('.
8900 SourceLocation FakeLParenLoc
8901 = ((Expr *)Callee.get())->getSourceRange().getBegin();
8902 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
8904 E->getRParenLoc(), EC.get());
8907 template<typename Derived>
8909 TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) {
8910 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
8915 = getDerived().TransformExpr(E->getSubExprAsWritten());
8916 if (SubExpr.isInvalid())
8919 if (!getDerived().AlwaysRebuild() &&
8920 Type == E->getTypeInfoAsWritten() &&
8921 SubExpr.get() == E->getSubExpr())
8923 return getDerived().RebuildCXXNamedCastExpr(
8924 E->getOperatorLoc(), E->getStmtClass(), E->getAngleBrackets().getBegin(),
8925 Type, E->getAngleBrackets().getEnd(),
8926 // FIXME. this should be '(' location
8927 E->getAngleBrackets().getEnd(), SubExpr.get(), E->getRParenLoc());
8930 template<typename Derived>
8932 TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) {
8933 return getDerived().TransformCXXNamedCastExpr(E);
8936 template<typename Derived>
8938 TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
8939 return getDerived().TransformCXXNamedCastExpr(E);
8942 template<typename Derived>
8944 TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
8945 CXXReinterpretCastExpr *E) {
8946 return getDerived().TransformCXXNamedCastExpr(E);
8949 template<typename Derived>
8951 TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) {
8952 return getDerived().TransformCXXNamedCastExpr(E);
8955 template<typename Derived>
8957 TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
8958 CXXFunctionalCastExpr *E) {
8959 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
8964 = getDerived().TransformExpr(E->getSubExprAsWritten());
8965 if (SubExpr.isInvalid())
8968 if (!getDerived().AlwaysRebuild() &&
8969 Type == E->getTypeInfoAsWritten() &&
8970 SubExpr.get() == E->getSubExpr())
8973 return getDerived().RebuildCXXFunctionalCastExpr(Type,
8979 template<typename Derived>
8981 TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) {
8982 if (E->isTypeOperand()) {
8983 TypeSourceInfo *TInfo
8984 = getDerived().TransformType(E->getTypeOperandSourceInfo());
8988 if (!getDerived().AlwaysRebuild() &&
8989 TInfo == E->getTypeOperandSourceInfo())
8992 return getDerived().RebuildCXXTypeidExpr(E->getType(),
8998 // We don't know whether the subexpression is potentially evaluated until
8999 // after we perform semantic analysis. We speculatively assume it is
9000 // unevaluated; it will get fixed later if the subexpression is in fact
9001 // potentially evaluated.
9002 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated,
9003 Sema::ReuseLambdaContextDecl);
9005 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
9006 if (SubExpr.isInvalid())
9009 if (!getDerived().AlwaysRebuild() &&
9010 SubExpr.get() == E->getExprOperand())
9013 return getDerived().RebuildCXXTypeidExpr(E->getType(),
9019 template<typename Derived>
9021 TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) {
9022 if (E->isTypeOperand()) {
9023 TypeSourceInfo *TInfo
9024 = getDerived().TransformType(E->getTypeOperandSourceInfo());
9028 if (!getDerived().AlwaysRebuild() &&
9029 TInfo == E->getTypeOperandSourceInfo())
9032 return getDerived().RebuildCXXUuidofExpr(E->getType(),
9038 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
9040 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
9041 if (SubExpr.isInvalid())
9044 if (!getDerived().AlwaysRebuild() &&
9045 SubExpr.get() == E->getExprOperand())
9048 return getDerived().RebuildCXXUuidofExpr(E->getType(),
9054 template<typename Derived>
9056 TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
9060 template<typename Derived>
9062 TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
9063 CXXNullPtrLiteralExpr *E) {
9067 template<typename Derived>
9069 TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) {
9070 QualType T = getSema().getCurrentThisType();
9072 if (!getDerived().AlwaysRebuild() && T == E->getType()) {
9073 // Make sure that we capture 'this'.
9074 getSema().CheckCXXThisCapture(E->getLocStart());
9078 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit());
9081 template<typename Derived>
9083 TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) {
9084 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
9085 if (SubExpr.isInvalid())
9088 if (!getDerived().AlwaysRebuild() &&
9089 SubExpr.get() == E->getSubExpr())
9092 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(),
9093 E->isThrownVariableInScope());
9096 template<typename Derived>
9098 TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
9100 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(),
9105 if (!getDerived().AlwaysRebuild() &&
9106 Param == E->getParam())
9109 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param);
9112 template<typename Derived>
9114 TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
9116 = cast_or_null<FieldDecl>(getDerived().TransformDecl(E->getLocStart(),
9121 if (!getDerived().AlwaysRebuild() && Field == E->getField())
9124 return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field);
9127 template<typename Derived>
9129 TreeTransform<Derived>::TransformCXXScalarValueInitExpr(
9130 CXXScalarValueInitExpr *E) {
9131 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
9135 if (!getDerived().AlwaysRebuild() &&
9136 T == E->getTypeSourceInfo())
9139 return getDerived().RebuildCXXScalarValueInitExpr(T,
9140 /*FIXME:*/T->getTypeLoc().getEndLoc(),
9144 template<typename Derived>
9146 TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) {
9147 // Transform the type that we're allocating
9148 TypeSourceInfo *AllocTypeInfo
9149 = getDerived().TransformType(E->getAllocatedTypeSourceInfo());
9153 // Transform the size of the array we're allocating (if any).
9154 ExprResult ArraySize = getDerived().TransformExpr(E->getArraySize());
9155 if (ArraySize.isInvalid())
9158 // Transform the placement arguments (if any).
9159 bool ArgumentChanged = false;
9160 SmallVector<Expr*, 8> PlacementArgs;
9161 if (getDerived().TransformExprs(E->getPlacementArgs(),
9162 E->getNumPlacementArgs(), true,
9163 PlacementArgs, &ArgumentChanged))
9166 // Transform the initializer (if any).
9167 Expr *OldInit = E->getInitializer();
9170 NewInit = getDerived().TransformInitializer(OldInit, true);
9171 if (NewInit.isInvalid())
9174 // Transform new operator and delete operator.
9175 FunctionDecl *OperatorNew = nullptr;
9176 if (E->getOperatorNew()) {
9177 OperatorNew = cast_or_null<FunctionDecl>(
9178 getDerived().TransformDecl(E->getLocStart(),
9179 E->getOperatorNew()));
9184 FunctionDecl *OperatorDelete = nullptr;
9185 if (E->getOperatorDelete()) {
9186 OperatorDelete = cast_or_null<FunctionDecl>(
9187 getDerived().TransformDecl(E->getLocStart(),
9188 E->getOperatorDelete()));
9189 if (!OperatorDelete)
9193 if (!getDerived().AlwaysRebuild() &&
9194 AllocTypeInfo == E->getAllocatedTypeSourceInfo() &&
9195 ArraySize.get() == E->getArraySize() &&
9196 NewInit.get() == OldInit &&
9197 OperatorNew == E->getOperatorNew() &&
9198 OperatorDelete == E->getOperatorDelete() &&
9200 // Mark any declarations we need as referenced.
9201 // FIXME: instantiation-specific.
9203 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorNew);
9205 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete);
9207 if (E->isArray() && !E->getAllocatedType()->isDependentType()) {
9208 QualType ElementType
9209 = SemaRef.Context.getBaseElementType(E->getAllocatedType());
9210 if (const RecordType *RecordT = ElementType->getAs<RecordType>()) {
9211 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordT->getDecl());
9212 if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(Record)) {
9213 SemaRef.MarkFunctionReferenced(E->getLocStart(), Destructor);
9221 QualType AllocType = AllocTypeInfo->getType();
9222 if (!ArraySize.get()) {
9223 // If no array size was specified, but the new expression was
9224 // instantiated with an array type (e.g., "new T" where T is
9225 // instantiated with "int[4]"), extract the outer bound from the
9226 // array type as our array size. We do this with constant and
9227 // dependently-sized array types.
9228 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType);
9231 } else if (const ConstantArrayType *ConsArrayT
9232 = dyn_cast<ConstantArrayType>(ArrayT)) {
9233 ArraySize = IntegerLiteral::Create(SemaRef.Context, ConsArrayT->getSize(),
9234 SemaRef.Context.getSizeType(),
9235 /*FIXME:*/ E->getLocStart());
9236 AllocType = ConsArrayT->getElementType();
9237 } else if (const DependentSizedArrayType *DepArrayT
9238 = dyn_cast<DependentSizedArrayType>(ArrayT)) {
9239 if (DepArrayT->getSizeExpr()) {
9240 ArraySize = DepArrayT->getSizeExpr();
9241 AllocType = DepArrayT->getElementType();
9246 return getDerived().RebuildCXXNewExpr(E->getLocStart(),
9248 /*FIXME:*/E->getLocStart(),
9250 /*FIXME:*/E->getLocStart(),
9251 E->getTypeIdParens(),
9255 E->getDirectInitRange(),
9259 template<typename Derived>
9261 TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) {
9262 ExprResult Operand = getDerived().TransformExpr(E->getArgument());
9263 if (Operand.isInvalid())
9266 // Transform the delete operator, if known.
9267 FunctionDecl *OperatorDelete = nullptr;
9268 if (E->getOperatorDelete()) {
9269 OperatorDelete = cast_or_null<FunctionDecl>(
9270 getDerived().TransformDecl(E->getLocStart(),
9271 E->getOperatorDelete()));
9272 if (!OperatorDelete)
9276 if (!getDerived().AlwaysRebuild() &&
9277 Operand.get() == E->getArgument() &&
9278 OperatorDelete == E->getOperatorDelete()) {
9279 // Mark any declarations we need as referenced.
9280 // FIXME: instantiation-specific.
9282 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete);
9284 if (!E->getArgument()->isTypeDependent()) {
9285 QualType Destroyed = SemaRef.Context.getBaseElementType(
9286 E->getDestroyedType());
9287 if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
9288 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
9289 SemaRef.MarkFunctionReferenced(E->getLocStart(),
9290 SemaRef.LookupDestructor(Record));
9297 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(),
9298 E->isGlobalDelete(),
9303 template<typename Derived>
9305 TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
9306 CXXPseudoDestructorExpr *E) {
9307 ExprResult Base = getDerived().TransformExpr(E->getBase());
9308 if (Base.isInvalid())
9311 ParsedType ObjectTypePtr;
9312 bool MayBePseudoDestructor = false;
9313 Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(),
9314 E->getOperatorLoc(),
9315 E->isArrow()? tok::arrow : tok::period,
9317 MayBePseudoDestructor);
9318 if (Base.isInvalid())
9321 QualType ObjectType = ObjectTypePtr.get();
9322 NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc();
9325 = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType);
9330 SS.Adopt(QualifierLoc);
9332 PseudoDestructorTypeStorage Destroyed;
9333 if (E->getDestroyedTypeInfo()) {
9334 TypeSourceInfo *DestroyedTypeInfo
9335 = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(),
9336 ObjectType, nullptr, SS);
9337 if (!DestroyedTypeInfo)
9339 Destroyed = DestroyedTypeInfo;
9340 } else if (!ObjectType.isNull() && ObjectType->isDependentType()) {
9341 // We aren't likely to be able to resolve the identifier down to a type
9342 // now anyway, so just retain the identifier.
9343 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(),
9344 E->getDestroyedTypeLoc());
9346 // Look for a destructor known with the given name.
9347 ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(),
9348 *E->getDestroyedTypeIdentifier(),
9349 E->getDestroyedTypeLoc(),
9357 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T),
9358 E->getDestroyedTypeLoc());
9361 TypeSourceInfo *ScopeTypeInfo = nullptr;
9362 if (E->getScopeTypeInfo()) {
9363 CXXScopeSpec EmptySS;
9364 ScopeTypeInfo = getDerived().TransformTypeInObjectScope(
9365 E->getScopeTypeInfo(), ObjectType, nullptr, EmptySS);
9370 return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(),
9371 E->getOperatorLoc(),
9375 E->getColonColonLoc(),
9380 template<typename Derived>
9382 TreeTransform<Derived>::TransformUnresolvedLookupExpr(
9383 UnresolvedLookupExpr *Old) {
9384 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(),
9385 Sema::LookupOrdinaryName);
9387 // Transform all the decls.
9388 for (UnresolvedLookupExpr::decls_iterator I = Old->decls_begin(),
9389 E = Old->decls_end(); I != E; ++I) {
9390 NamedDecl *InstD = static_cast<NamedDecl*>(
9391 getDerived().TransformDecl(Old->getNameLoc(),
9394 // Silently ignore these if a UsingShadowDecl instantiated to nothing.
9395 // This can happen because of dependent hiding.
9396 if (isa<UsingShadowDecl>(*I))
9404 // Expand using declarations.
9405 if (isa<UsingDecl>(InstD)) {
9406 UsingDecl *UD = cast<UsingDecl>(InstD);
9407 for (auto *I : UD->shadows())
9415 // Resolve a kind, but don't do any further analysis. If it's
9416 // ambiguous, the callee needs to deal with it.
9419 // Rebuild the nested-name qualifier, if present.
9421 if (Old->getQualifierLoc()) {
9422 NestedNameSpecifierLoc QualifierLoc
9423 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
9427 SS.Adopt(QualifierLoc);
9430 if (Old->getNamingClass()) {
9431 CXXRecordDecl *NamingClass
9432 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
9434 Old->getNamingClass()));
9440 R.setNamingClass(NamingClass);
9443 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
9445 // If we have neither explicit template arguments, nor the template keyword,
9446 // it's a normal declaration name or member reference.
9447 if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid()) {
9448 NamedDecl *D = R.getAsSingle<NamedDecl>();
9449 // In a C++11 unevaluated context, an UnresolvedLookupExpr might refer to an
9450 // instance member. In other contexts, BuildPossibleImplicitMemberExpr will
9451 // give a good diagnostic.
9452 if (D && D->isCXXInstanceMember()) {
9453 return SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, R,
9454 /*TemplateArgs=*/nullptr,
9458 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL());
9461 // If we have template arguments, rebuild them, then rebuild the
9462 // templateid expression.
9463 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc());
9464 if (Old->hasExplicitTemplateArgs() &&
9465 getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
9466 Old->getNumTemplateArgs(),
9472 return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R,
9473 Old->requiresADL(), &TransArgs);
9476 template<typename Derived>
9478 TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) {
9479 bool ArgChanged = false;
9480 SmallVector<TypeSourceInfo *, 4> Args;
9481 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
9482 TypeSourceInfo *From = E->getArg(I);
9483 TypeLoc FromTL = From->getTypeLoc();
9484 if (!FromTL.getAs<PackExpansionTypeLoc>()) {
9486 TLB.reserve(FromTL.getFullDataSize());
9487 QualType To = getDerived().TransformType(TLB, FromTL);
9491 if (To == From->getType())
9492 Args.push_back(From);
9494 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
9502 // We have a pack expansion. Instantiate it.
9503 PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>();
9504 TypeLoc PatternTL = ExpansionTL.getPatternLoc();
9505 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
9506 SemaRef.collectUnexpandedParameterPacks(PatternTL, Unexpanded);
9508 // Determine whether the set of unexpanded parameter packs can and should
9511 bool RetainExpansion = false;
9512 Optional<unsigned> OrigNumExpansions =
9513 ExpansionTL.getTypePtr()->getNumExpansions();
9514 Optional<unsigned> NumExpansions = OrigNumExpansions;
9515 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
9516 PatternTL.getSourceRange(),
9518 Expand, RetainExpansion,
9523 // The transform has determined that we should perform a simple
9524 // transformation on the pack expansion, producing another pack
9526 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
9529 TLB.reserve(From->getTypeLoc().getFullDataSize());
9531 QualType To = getDerived().TransformType(TLB, PatternTL);
9535 To = getDerived().RebuildPackExpansionType(To,
9536 PatternTL.getSourceRange(),
9537 ExpansionTL.getEllipsisLoc(),
9542 PackExpansionTypeLoc ToExpansionTL
9543 = TLB.push<PackExpansionTypeLoc>(To);
9544 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
9545 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
9549 // Expand the pack expansion by substituting for each argument in the
9551 for (unsigned I = 0; I != *NumExpansions; ++I) {
9552 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
9554 TLB.reserve(PatternTL.getFullDataSize());
9555 QualType To = getDerived().TransformType(TLB, PatternTL);
9559 if (To->containsUnexpandedParameterPack()) {
9560 To = getDerived().RebuildPackExpansionType(To,
9561 PatternTL.getSourceRange(),
9562 ExpansionTL.getEllipsisLoc(),
9567 PackExpansionTypeLoc ToExpansionTL
9568 = TLB.push<PackExpansionTypeLoc>(To);
9569 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
9572 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
9575 if (!RetainExpansion)
9578 // If we're supposed to retain a pack expansion, do so by temporarily
9579 // forgetting the partially-substituted parameter pack.
9580 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
9583 TLB.reserve(From->getTypeLoc().getFullDataSize());
9585 QualType To = getDerived().TransformType(TLB, PatternTL);
9589 To = getDerived().RebuildPackExpansionType(To,
9590 PatternTL.getSourceRange(),
9591 ExpansionTL.getEllipsisLoc(),
9596 PackExpansionTypeLoc ToExpansionTL
9597 = TLB.push<PackExpansionTypeLoc>(To);
9598 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
9599 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
9602 if (!getDerived().AlwaysRebuild() && !ArgChanged)
9605 return getDerived().RebuildTypeTrait(E->getTrait(),
9611 template<typename Derived>
9613 TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
9614 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo());
9618 if (!getDerived().AlwaysRebuild() &&
9619 T == E->getQueriedTypeSourceInfo())
9624 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
9625 SubExpr = getDerived().TransformExpr(E->getDimensionExpression());
9626 if (SubExpr.isInvalid())
9629 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getDimensionExpression())
9633 return getDerived().RebuildArrayTypeTrait(E->getTrait(),
9640 template<typename Derived>
9642 TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) {
9645 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
9646 SubExpr = getDerived().TransformExpr(E->getQueriedExpression());
9647 if (SubExpr.isInvalid())
9650 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression())
9654 return getDerived().RebuildExpressionTrait(
9655 E->getTrait(), E->getLocStart(), SubExpr.get(), E->getLocEnd());
9658 template <typename Derived>
9659 ExprResult TreeTransform<Derived>::TransformParenDependentScopeDeclRefExpr(
9660 ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool AddrTaken,
9661 TypeSourceInfo **RecoveryTSI) {
9662 ExprResult NewDRE = getDerived().TransformDependentScopeDeclRefExpr(
9663 DRE, AddrTaken, RecoveryTSI);
9665 // Propagate both errors and recovered types, which return ExprEmpty.
9666 if (!NewDRE.isUsable())
9669 // We got an expr, wrap it up in parens.
9670 if (!getDerived().AlwaysRebuild() && NewDRE.get() == DRE)
9672 return getDerived().RebuildParenExpr(NewDRE.get(), PE->getLParen(),
9676 template <typename Derived>
9677 ExprResult TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
9678 DependentScopeDeclRefExpr *E) {
9679 return TransformDependentScopeDeclRefExpr(E, /*IsAddressOfOperand=*/false,
9683 template<typename Derived>
9685 TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
9686 DependentScopeDeclRefExpr *E,
9687 bool IsAddressOfOperand,
9688 TypeSourceInfo **RecoveryTSI) {
9689 assert(E->getQualifierLoc());
9690 NestedNameSpecifierLoc QualifierLoc
9691 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
9694 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
9696 // TODO: If this is a conversion-function-id, verify that the
9697 // destination type name (if present) resolves the same way after
9698 // instantiation as it did in the local scope.
9700 DeclarationNameInfo NameInfo
9701 = getDerived().TransformDeclarationNameInfo(E->getNameInfo());
9702 if (!NameInfo.getName())
9705 if (!E->hasExplicitTemplateArgs()) {
9706 if (!getDerived().AlwaysRebuild() &&
9707 QualifierLoc == E->getQualifierLoc() &&
9708 // Note: it is sufficient to compare the Name component of NameInfo:
9709 // if name has not changed, DNLoc has not changed either.
9710 NameInfo.getName() == E->getDeclName())
9713 return getDerived().RebuildDependentScopeDeclRefExpr(
9714 QualifierLoc, TemplateKWLoc, NameInfo, /*TemplateArgs=*/nullptr,
9715 IsAddressOfOperand, RecoveryTSI);
9718 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
9719 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
9720 E->getNumTemplateArgs(),
9724 return getDerived().RebuildDependentScopeDeclRefExpr(
9725 QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand,
9729 template<typename Derived>
9731 TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) {
9732 // CXXConstructExprs other than for list-initialization and
9733 // CXXTemporaryObjectExpr are always implicit, so when we have
9734 // a 1-argument construction we just transform that argument.
9735 if ((E->getNumArgs() == 1 ||
9736 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) &&
9737 (!getDerived().DropCallArgument(E->getArg(0))) &&
9738 !E->isListInitialization())
9739 return getDerived().TransformExpr(E->getArg(0));
9741 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName());
9743 QualType T = getDerived().TransformType(E->getType());
9747 CXXConstructorDecl *Constructor
9748 = cast_or_null<CXXConstructorDecl>(
9749 getDerived().TransformDecl(E->getLocStart(),
9750 E->getConstructor()));
9754 bool ArgumentChanged = false;
9755 SmallVector<Expr*, 8> Args;
9756 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
9760 if (!getDerived().AlwaysRebuild() &&
9761 T == E->getType() &&
9762 Constructor == E->getConstructor() &&
9764 // Mark the constructor as referenced.
9765 // FIXME: Instantiation-specific
9766 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor);
9770 return getDerived().RebuildCXXConstructExpr(T, /*FIXME:*/E->getLocStart(),
9771 Constructor, E->isElidable(),
9773 E->hadMultipleCandidates(),
9774 E->isListInitialization(),
9775 E->isStdInitListInitialization(),
9776 E->requiresZeroInitialization(),
9777 E->getConstructionKind(),
9778 E->getParenOrBraceRange());
9781 /// \brief Transform a C++ temporary-binding expression.
9783 /// Since CXXBindTemporaryExpr nodes are implicitly generated, we just
9784 /// transform the subexpression and return that.
9785 template<typename Derived>
9787 TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
9788 return getDerived().TransformExpr(E->getSubExpr());
9791 /// \brief Transform a C++ expression that contains cleanups that should
9792 /// be run after the expression is evaluated.
9794 /// Since ExprWithCleanups nodes are implicitly generated, we
9795 /// just transform the subexpression and return that.
9796 template<typename Derived>
9798 TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) {
9799 return getDerived().TransformExpr(E->getSubExpr());
9802 template<typename Derived>
9804 TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
9805 CXXTemporaryObjectExpr *E) {
9806 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
9810 CXXConstructorDecl *Constructor
9811 = cast_or_null<CXXConstructorDecl>(
9812 getDerived().TransformDecl(E->getLocStart(),
9813 E->getConstructor()));
9817 bool ArgumentChanged = false;
9818 SmallVector<Expr*, 8> Args;
9819 Args.reserve(E->getNumArgs());
9820 if (TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
9824 if (!getDerived().AlwaysRebuild() &&
9825 T == E->getTypeSourceInfo() &&
9826 Constructor == E->getConstructor() &&
9828 // FIXME: Instantiation-specific
9829 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor);
9830 return SemaRef.MaybeBindToTemporary(E);
9833 // FIXME: Pass in E->isListInitialization().
9834 return getDerived().RebuildCXXTemporaryObjectExpr(T,
9835 /*FIXME:*/T->getTypeLoc().getEndLoc(),
9840 template<typename Derived>
9842 TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
9843 // Transform any init-capture expressions before entering the scope of the
9844 // lambda body, because they are not semantically within that scope.
9845 typedef std::pair<ExprResult, QualType> InitCaptureInfoTy;
9846 SmallVector<InitCaptureInfoTy, 8> InitCaptureExprsAndTypes;
9847 InitCaptureExprsAndTypes.resize(E->explicit_capture_end() -
9848 E->explicit_capture_begin());
9849 for (LambdaExpr::capture_iterator C = E->capture_begin(),
9850 CEnd = E->capture_end();
9852 if (!E->isInitCapture(C))
9854 EnterExpressionEvaluationContext EEEC(getSema(),
9855 Sema::PotentiallyEvaluated);
9856 ExprResult NewExprInitResult = getDerived().TransformInitializer(
9857 C->getCapturedVar()->getInit(),
9858 C->getCapturedVar()->getInitStyle() == VarDecl::CallInit);
9860 if (NewExprInitResult.isInvalid())
9862 Expr *NewExprInit = NewExprInitResult.get();
9864 VarDecl *OldVD = C->getCapturedVar();
9865 QualType NewInitCaptureType =
9866 getSema().buildLambdaInitCaptureInitialization(
9867 C->getLocation(), OldVD->getType()->isReferenceType(),
9868 OldVD->getIdentifier(),
9869 C->getCapturedVar()->getInitStyle() != VarDecl::CInit, NewExprInit);
9870 NewExprInitResult = NewExprInit;
9871 InitCaptureExprsAndTypes[C - E->capture_begin()] =
9872 std::make_pair(NewExprInitResult, NewInitCaptureType);
9875 // Transform the template parameters, and add them to the current
9876 // instantiation scope. The null case is handled correctly.
9877 auto TPL = getDerived().TransformTemplateParameterList(
9878 E->getTemplateParameterList());
9880 // Transform the type of the original lambda's call operator.
9881 // The transformation MUST be done in the CurrentInstantiationScope since
9882 // it introduces a mapping of the original to the newly created
9883 // transformed parameters.
9884 TypeSourceInfo *NewCallOpTSI = nullptr;
9886 TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo();
9887 FunctionProtoTypeLoc OldCallOpFPTL =
9888 OldCallOpTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>();
9890 TypeLocBuilder NewCallOpTLBuilder;
9891 SmallVector<QualType, 4> ExceptionStorage;
9892 TreeTransform *This = this; // Work around gcc.gnu.org/PR56135.
9893 QualType NewCallOpType = TransformFunctionProtoType(
9894 NewCallOpTLBuilder, OldCallOpFPTL, nullptr, 0,
9895 [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) {
9896 return This->TransformExceptionSpec(OldCallOpFPTL.getBeginLoc(), ESI,
9897 ExceptionStorage, Changed);
9899 if (NewCallOpType.isNull())
9901 NewCallOpTSI = NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context,
9905 LambdaScopeInfo *LSI = getSema().PushLambdaScope();
9906 Sema::FunctionScopeRAII FuncScopeCleanup(getSema());
9907 LSI->GLTemplateParameterList = TPL;
9909 // Create the local class that will describe the lambda.
9910 CXXRecordDecl *Class
9911 = getSema().createLambdaClosureType(E->getIntroducerRange(),
9913 /*KnownDependent=*/false,
9914 E->getCaptureDefault());
9915 getDerived().transformedLocalDecl(E->getLambdaClass(), Class);
9917 // Build the call operator.
9918 CXXMethodDecl *NewCallOperator = getSema().startLambdaDefinition(
9919 Class, E->getIntroducerRange(), NewCallOpTSI,
9920 E->getCallOperator()->getLocEnd(),
9921 NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams());
9922 LSI->CallOperator = NewCallOperator;
9924 getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
9925 getDerived().transformedLocalDecl(E->getCallOperator(), NewCallOperator);
9927 // Introduce the context of the call operator.
9928 Sema::ContextRAII SavedContext(getSema(), NewCallOperator,
9929 /*NewThisContext*/false);
9931 // Enter the scope of the lambda.
9932 getSema().buildLambdaScope(LSI, NewCallOperator,
9933 E->getIntroducerRange(),
9934 E->getCaptureDefault(),
9935 E->getCaptureDefaultLoc(),
9936 E->hasExplicitParameters(),
9937 E->hasExplicitResultType(),
9940 bool Invalid = false;
9942 // Transform captures.
9943 bool FinishedExplicitCaptures = false;
9944 for (LambdaExpr::capture_iterator C = E->capture_begin(),
9945 CEnd = E->capture_end();
9947 // When we hit the first implicit capture, tell Sema that we've finished
9948 // the list of explicit captures.
9949 if (!FinishedExplicitCaptures && C->isImplicit()) {
9950 getSema().finishLambdaExplicitCaptures(LSI);
9951 FinishedExplicitCaptures = true;
9954 // Capturing 'this' is trivial.
9955 if (C->capturesThis()) {
9956 getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit());
9959 // Captured expression will be recaptured during captured variables
9961 if (C->capturesVLAType())
9964 // Rebuild init-captures, including the implied field declaration.
9965 if (E->isInitCapture(C)) {
9966 InitCaptureInfoTy InitExprTypePair =
9967 InitCaptureExprsAndTypes[C - E->capture_begin()];
9968 ExprResult Init = InitExprTypePair.first;
9969 QualType InitQualType = InitExprTypePair.second;
9970 if (Init.isInvalid() || InitQualType.isNull()) {
9974 VarDecl *OldVD = C->getCapturedVar();
9975 VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl(
9976 OldVD->getLocation(), InitExprTypePair.second, OldVD->getIdentifier(),
9977 OldVD->getInitStyle(), Init.get());
9981 getDerived().transformedLocalDecl(OldVD, NewVD);
9983 getSema().buildInitCaptureField(LSI, NewVD);
9987 assert(C->capturesVariable() && "unexpected kind of lambda capture");
9989 // Determine the capture kind for Sema.
9990 Sema::TryCaptureKind Kind
9991 = C->isImplicit()? Sema::TryCapture_Implicit
9992 : C->getCaptureKind() == LCK_ByCopy
9993 ? Sema::TryCapture_ExplicitByVal
9994 : Sema::TryCapture_ExplicitByRef;
9995 SourceLocation EllipsisLoc;
9996 if (C->isPackExpansion()) {
9997 UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation());
9998 bool ShouldExpand = false;
9999 bool RetainExpansion = false;
10000 Optional<unsigned> NumExpansions;
10001 if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(),
10004 ShouldExpand, RetainExpansion,
10010 if (ShouldExpand) {
10011 // The transform has determined that we should perform an expansion;
10012 // transform and capture each of the arguments.
10013 // expansion of the pattern. Do so.
10014 VarDecl *Pack = C->getCapturedVar();
10015 for (unsigned I = 0; I != *NumExpansions; ++I) {
10016 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
10017 VarDecl *CapturedVar
10018 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
10020 if (!CapturedVar) {
10025 // Capture the transformed variable.
10026 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind);
10029 // FIXME: Retain a pack expansion if RetainExpansion is true.
10034 EllipsisLoc = C->getEllipsisLoc();
10037 // Transform the captured variable.
10038 VarDecl *CapturedVar
10039 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
10040 C->getCapturedVar()));
10041 if (!CapturedVar || CapturedVar->isInvalidDecl()) {
10046 // Capture the transformed variable.
10047 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind,
10050 if (!FinishedExplicitCaptures)
10051 getSema().finishLambdaExplicitCaptures(LSI);
10053 // Enter a new evaluation context to insulate the lambda from any
10054 // cleanups from the enclosing full-expression.
10055 getSema().PushExpressionEvaluationContext(Sema::PotentiallyEvaluated);
10057 // Instantiate the body of the lambda expression.
10059 Invalid ? StmtError() : getDerived().TransformStmt(E->getBody());
10061 // ActOnLambda* will pop the function scope for us.
10062 FuncScopeCleanup.disable();
10064 if (Body.isInvalid()) {
10065 SavedContext.pop();
10066 getSema().ActOnLambdaError(E->getLocStart(), /*CurScope=*/nullptr,
10067 /*IsInstantiation=*/true);
10068 return ExprError();
10071 // Copy the LSI before ActOnFinishFunctionBody removes it.
10072 // FIXME: This is dumb. Store the lambda information somewhere that outlives
10073 // the call operator.
10074 auto LSICopy = *LSI;
10075 getSema().ActOnFinishFunctionBody(NewCallOperator, Body.get(),
10076 /*IsInstantiation*/ true);
10077 SavedContext.pop();
10079 return getSema().BuildLambdaExpr(E->getLocStart(), Body.get()->getLocEnd(),
10083 template<typename Derived>
10085 TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
10086 CXXUnresolvedConstructExpr *E) {
10087 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
10089 return ExprError();
10091 bool ArgumentChanged = false;
10092 SmallVector<Expr*, 8> Args;
10093 Args.reserve(E->arg_size());
10094 if (getDerived().TransformExprs(E->arg_begin(), E->arg_size(), true, Args,
10096 return ExprError();
10098 if (!getDerived().AlwaysRebuild() &&
10099 T == E->getTypeSourceInfo() &&
10103 // FIXME: we're faking the locations of the commas
10104 return getDerived().RebuildCXXUnresolvedConstructExpr(T,
10107 E->getRParenLoc());
10110 template<typename Derived>
10112 TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
10113 CXXDependentScopeMemberExpr *E) {
10114 // Transform the base of the expression.
10115 ExprResult Base((Expr*) nullptr);
10118 QualType ObjectType;
10119 if (!E->isImplicitAccess()) {
10120 OldBase = E->getBase();
10121 Base = getDerived().TransformExpr(OldBase);
10122 if (Base.isInvalid())
10123 return ExprError();
10125 // Start the member reference and compute the object's type.
10126 ParsedType ObjectTy;
10127 bool MayBePseudoDestructor = false;
10128 Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(),
10129 E->getOperatorLoc(),
10130 E->isArrow()? tok::arrow : tok::period,
10132 MayBePseudoDestructor);
10133 if (Base.isInvalid())
10134 return ExprError();
10136 ObjectType = ObjectTy.get();
10137 BaseType = ((Expr*) Base.get())->getType();
10140 BaseType = getDerived().TransformType(E->getBaseType());
10141 ObjectType = BaseType->getAs<PointerType>()->getPointeeType();
10144 // Transform the first part of the nested-name-specifier that qualifies
10145 // the member name.
10146 NamedDecl *FirstQualifierInScope
10147 = getDerived().TransformFirstQualifierInScope(
10148 E->getFirstQualifierFoundInScope(),
10149 E->getQualifierLoc().getBeginLoc());
10151 NestedNameSpecifierLoc QualifierLoc;
10152 if (E->getQualifier()) {
10154 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(),
10156 FirstQualifierInScope);
10158 return ExprError();
10161 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
10163 // TODO: If this is a conversion-function-id, verify that the
10164 // destination type name (if present) resolves the same way after
10165 // instantiation as it did in the local scope.
10167 DeclarationNameInfo NameInfo
10168 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo());
10169 if (!NameInfo.getName())
10170 return ExprError();
10172 if (!E->hasExplicitTemplateArgs()) {
10173 // This is a reference to a member without an explicitly-specified
10174 // template argument list. Optimize for this common case.
10175 if (!getDerived().AlwaysRebuild() &&
10176 Base.get() == OldBase &&
10177 BaseType == E->getBaseType() &&
10178 QualifierLoc == E->getQualifierLoc() &&
10179 NameInfo.getName() == E->getMember() &&
10180 FirstQualifierInScope == E->getFirstQualifierFoundInScope())
10183 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
10186 E->getOperatorLoc(),
10189 FirstQualifierInScope,
10191 /*TemplateArgs*/nullptr);
10194 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
10195 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
10196 E->getNumTemplateArgs(),
10198 return ExprError();
10200 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
10203 E->getOperatorLoc(),
10206 FirstQualifierInScope,
10211 template<typename Derived>
10213 TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) {
10214 // Transform the base of the expression.
10215 ExprResult Base((Expr*) nullptr);
10217 if (!Old->isImplicitAccess()) {
10218 Base = getDerived().TransformExpr(Old->getBase());
10219 if (Base.isInvalid())
10220 return ExprError();
10221 Base = getSema().PerformMemberExprBaseConversion(Base.get(),
10223 if (Base.isInvalid())
10224 return ExprError();
10225 BaseType = Base.get()->getType();
10227 BaseType = getDerived().TransformType(Old->getBaseType());
10230 NestedNameSpecifierLoc QualifierLoc;
10231 if (Old->getQualifierLoc()) {
10233 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
10235 return ExprError();
10238 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
10240 LookupResult R(SemaRef, Old->getMemberNameInfo(),
10241 Sema::LookupOrdinaryName);
10243 // Transform all the decls.
10244 for (UnresolvedMemberExpr::decls_iterator I = Old->decls_begin(),
10245 E = Old->decls_end(); I != E; ++I) {
10246 NamedDecl *InstD = static_cast<NamedDecl*>(
10247 getDerived().TransformDecl(Old->getMemberLoc(),
10250 // Silently ignore these if a UsingShadowDecl instantiated to nothing.
10251 // This can happen because of dependent hiding.
10252 if (isa<UsingShadowDecl>(*I))
10256 return ExprError();
10260 // Expand using declarations.
10261 if (isa<UsingDecl>(InstD)) {
10262 UsingDecl *UD = cast<UsingDecl>(InstD);
10263 for (auto *I : UD->shadows())
10273 // Determine the naming class.
10274 if (Old->getNamingClass()) {
10275 CXXRecordDecl *NamingClass
10276 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
10277 Old->getMemberLoc(),
10278 Old->getNamingClass()));
10280 return ExprError();
10282 R.setNamingClass(NamingClass);
10285 TemplateArgumentListInfo TransArgs;
10286 if (Old->hasExplicitTemplateArgs()) {
10287 TransArgs.setLAngleLoc(Old->getLAngleLoc());
10288 TransArgs.setRAngleLoc(Old->getRAngleLoc());
10289 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
10290 Old->getNumTemplateArgs(),
10292 return ExprError();
10295 // FIXME: to do this check properly, we will need to preserve the
10296 // first-qualifier-in-scope here, just in case we had a dependent
10297 // base (and therefore couldn't do the check) and a
10298 // nested-name-qualifier (and therefore could do the lookup).
10299 NamedDecl *FirstQualifierInScope = nullptr;
10301 return getDerived().RebuildUnresolvedMemberExpr(Base.get(),
10303 Old->getOperatorLoc(),
10307 FirstQualifierInScope,
10309 (Old->hasExplicitTemplateArgs()
10310 ? &TransArgs : nullptr));
10313 template<typename Derived>
10315 TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) {
10316 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
10317 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand());
10318 if (SubExpr.isInvalid())
10319 return ExprError();
10321 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand())
10324 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get());
10327 template<typename Derived>
10329 TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) {
10330 ExprResult Pattern = getDerived().TransformExpr(E->getPattern());
10331 if (Pattern.isInvalid())
10332 return ExprError();
10334 if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern())
10337 return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(),
10338 E->getNumExpansions());
10341 template<typename Derived>
10343 TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) {
10344 // If E is not value-dependent, then nothing will change when we transform it.
10345 // Note: This is an instantiation-centric view.
10346 if (!E->isValueDependent())
10349 EnterExpressionEvaluationContext Unevaluated(getSema(), Sema::Unevaluated);
10351 ArrayRef<TemplateArgument> PackArgs;
10352 TemplateArgument ArgStorage;
10354 // Find the argument list to transform.
10355 if (E->isPartiallySubstituted()) {
10356 PackArgs = E->getPartialArguments();
10357 } else if (E->isValueDependent()) {
10358 UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc());
10359 bool ShouldExpand = false;
10360 bool RetainExpansion = false;
10361 Optional<unsigned> NumExpansions;
10362 if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(),
10364 ShouldExpand, RetainExpansion,
10366 return ExprError();
10368 // If we need to expand the pack, build a template argument from it and
10370 if (ShouldExpand) {
10371 auto *Pack = E->getPack();
10372 if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Pack)) {
10373 ArgStorage = getSema().Context.getPackExpansionType(
10374 getSema().Context.getTypeDeclType(TTPD), None);
10375 } else if (auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Pack)) {
10376 ArgStorage = TemplateArgument(TemplateName(TTPD), None);
10378 auto *VD = cast<ValueDecl>(Pack);
10379 ExprResult DRE = getSema().BuildDeclRefExpr(VD, VD->getType(),
10380 VK_RValue, E->getPackLoc());
10381 if (DRE.isInvalid())
10382 return ExprError();
10383 ArgStorage = new (getSema().Context) PackExpansionExpr(
10384 getSema().Context.DependentTy, DRE.get(), E->getPackLoc(), None);
10386 PackArgs = ArgStorage;
10390 // If we're not expanding the pack, just transform the decl.
10391 if (!PackArgs.size()) {
10392 auto *Pack = cast_or_null<NamedDecl>(
10393 getDerived().TransformDecl(E->getPackLoc(), E->getPack()));
10395 return ExprError();
10396 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), Pack,
10398 E->getRParenLoc(), None, None);
10401 TemplateArgumentListInfo TransformedPackArgs(E->getPackLoc(),
10404 TemporaryBase Rebase(*this, E->getPackLoc(), getBaseEntity());
10405 typedef TemplateArgumentLocInventIterator<
10406 Derived, const TemplateArgument*> PackLocIterator;
10407 if (TransformTemplateArguments(PackLocIterator(*this, PackArgs.begin()),
10408 PackLocIterator(*this, PackArgs.end()),
10409 TransformedPackArgs, /*Uneval*/true))
10410 return ExprError();
10413 SmallVector<TemplateArgument, 8> Args;
10414 bool PartialSubstitution = false;
10415 for (auto &Loc : TransformedPackArgs.arguments()) {
10416 Args.push_back(Loc.getArgument());
10417 if (Loc.getArgument().isPackExpansion())
10418 PartialSubstitution = true;
10421 if (PartialSubstitution)
10422 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
10424 E->getRParenLoc(), None, Args);
10426 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
10427 E->getPackLoc(), E->getRParenLoc(),
10428 Args.size(), None);
10431 template<typename Derived>
10433 TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr(
10434 SubstNonTypeTemplateParmPackExpr *E) {
10435 // Default behavior is to do nothing with this transformation.
10439 template<typename Derived>
10441 TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr(
10442 SubstNonTypeTemplateParmExpr *E) {
10443 // Default behavior is to do nothing with this transformation.
10447 template<typename Derived>
10449 TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
10450 // Default behavior is to do nothing with this transformation.
10454 template<typename Derived>
10456 TreeTransform<Derived>::TransformMaterializeTemporaryExpr(
10457 MaterializeTemporaryExpr *E) {
10458 return getDerived().TransformExpr(E->GetTemporaryExpr());
10461 template<typename Derived>
10463 TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) {
10464 Expr *Pattern = E->getPattern();
10466 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
10467 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
10468 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
10470 // Determine whether the set of unexpanded parameter packs can and should
10472 bool Expand = true;
10473 bool RetainExpansion = false;
10474 Optional<unsigned> NumExpansions;
10475 if (getDerived().TryExpandParameterPacks(E->getEllipsisLoc(),
10476 Pattern->getSourceRange(),
10478 Expand, RetainExpansion,
10483 // Do not expand any packs here, just transform and rebuild a fold
10485 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
10488 E->getLHS() ? getDerived().TransformExpr(E->getLHS()) : ExprResult();
10489 if (LHS.isInvalid())
10493 E->getRHS() ? getDerived().TransformExpr(E->getRHS()) : ExprResult();
10494 if (RHS.isInvalid())
10497 if (!getDerived().AlwaysRebuild() &&
10498 LHS.get() == E->getLHS() && RHS.get() == E->getRHS())
10501 return getDerived().RebuildCXXFoldExpr(
10502 E->getLocStart(), LHS.get(), E->getOperator(), E->getEllipsisLoc(),
10503 RHS.get(), E->getLocEnd());
10506 // The transform has determined that we should perform an elementwise
10507 // expansion of the pattern. Do so.
10508 ExprResult Result = getDerived().TransformExpr(E->getInit());
10509 if (Result.isInvalid())
10511 bool LeftFold = E->isLeftFold();
10513 // If we're retaining an expansion for a right fold, it is the innermost
10514 // component and takes the init (if any).
10515 if (!LeftFold && RetainExpansion) {
10516 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
10518 ExprResult Out = getDerived().TransformExpr(Pattern);
10519 if (Out.isInvalid())
10522 Result = getDerived().RebuildCXXFoldExpr(
10523 E->getLocStart(), Out.get(), E->getOperator(), E->getEllipsisLoc(),
10524 Result.get(), E->getLocEnd());
10525 if (Result.isInvalid())
10529 for (unsigned I = 0; I != *NumExpansions; ++I) {
10530 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(
10531 getSema(), LeftFold ? I : *NumExpansions - I - 1);
10532 ExprResult Out = getDerived().TransformExpr(Pattern);
10533 if (Out.isInvalid())
10536 if (Out.get()->containsUnexpandedParameterPack()) {
10537 // We still have a pack; retain a pack expansion for this slice.
10538 Result = getDerived().RebuildCXXFoldExpr(
10540 LeftFold ? Result.get() : Out.get(),
10541 E->getOperator(), E->getEllipsisLoc(),
10542 LeftFold ? Out.get() : Result.get(),
10544 } else if (Result.isUsable()) {
10545 // We've got down to a single element; build a binary operator.
10546 Result = getDerived().RebuildBinaryOperator(
10547 E->getEllipsisLoc(), E->getOperator(),
10548 LeftFold ? Result.get() : Out.get(),
10549 LeftFold ? Out.get() : Result.get());
10553 if (Result.isInvalid())
10557 // If we're retaining an expansion for a left fold, it is the outermost
10558 // component and takes the complete expansion so far as its init (if any).
10559 if (LeftFold && RetainExpansion) {
10560 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
10562 ExprResult Out = getDerived().TransformExpr(Pattern);
10563 if (Out.isInvalid())
10566 Result = getDerived().RebuildCXXFoldExpr(
10567 E->getLocStart(), Result.get(),
10568 E->getOperator(), E->getEllipsisLoc(),
10569 Out.get(), E->getLocEnd());
10570 if (Result.isInvalid())
10574 // If we had no init and an empty pack, and we're not retaining an expansion,
10575 // then produce a fallback value or error.
10576 if (Result.isUnset())
10577 return getDerived().RebuildEmptyCXXFoldExpr(E->getEllipsisLoc(),
10583 template<typename Derived>
10585 TreeTransform<Derived>::TransformCXXStdInitializerListExpr(
10586 CXXStdInitializerListExpr *E) {
10587 return getDerived().TransformExpr(E->getSubExpr());
10590 template<typename Derived>
10592 TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) {
10593 return SemaRef.MaybeBindToTemporary(E);
10596 template<typename Derived>
10598 TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
10602 template<typename Derived>
10604 TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) {
10605 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
10606 if (SubExpr.isInvalid())
10607 return ExprError();
10609 if (!getDerived().AlwaysRebuild() &&
10610 SubExpr.get() == E->getSubExpr())
10613 return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get());
10616 template<typename Derived>
10618 TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *E) {
10619 // Transform each of the elements.
10620 SmallVector<Expr *, 8> Elements;
10621 bool ArgChanged = false;
10622 if (getDerived().TransformExprs(E->getElements(), E->getNumElements(),
10623 /*IsCall=*/false, Elements, &ArgChanged))
10624 return ExprError();
10626 if (!getDerived().AlwaysRebuild() && !ArgChanged)
10627 return SemaRef.MaybeBindToTemporary(E);
10629 return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(),
10634 template<typename Derived>
10636 TreeTransform<Derived>::TransformObjCDictionaryLiteral(
10637 ObjCDictionaryLiteral *E) {
10638 // Transform each of the elements.
10639 SmallVector<ObjCDictionaryElement, 8> Elements;
10640 bool ArgChanged = false;
10641 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
10642 ObjCDictionaryElement OrigElement = E->getKeyValueElement(I);
10644 if (OrigElement.isPackExpansion()) {
10645 // This key/value element is a pack expansion.
10646 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
10647 getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded);
10648 getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded);
10649 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
10651 // Determine whether the set of unexpanded parameter packs can
10652 // and should be expanded.
10653 bool Expand = true;
10654 bool RetainExpansion = false;
10655 Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions;
10656 Optional<unsigned> NumExpansions = OrigNumExpansions;
10657 SourceRange PatternRange(OrigElement.Key->getLocStart(),
10658 OrigElement.Value->getLocEnd());
10659 if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc,
10662 Expand, RetainExpansion,
10664 return ExprError();
10667 // The transform has determined that we should perform a simple
10668 // transformation on the pack expansion, producing another pack
10670 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
10671 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
10672 if (Key.isInvalid())
10673 return ExprError();
10675 if (Key.get() != OrigElement.Key)
10678 ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
10679 if (Value.isInvalid())
10680 return ExprError();
10682 if (Value.get() != OrigElement.Value)
10685 ObjCDictionaryElement Expansion = {
10686 Key.get(), Value.get(), OrigElement.EllipsisLoc, NumExpansions
10688 Elements.push_back(Expansion);
10692 // Record right away that the argument was changed. This needs
10693 // to happen even if the array expands to nothing.
10696 // The transform has determined that we should perform an elementwise
10697 // expansion of the pattern. Do so.
10698 for (unsigned I = 0; I != *NumExpansions; ++I) {
10699 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
10700 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
10701 if (Key.isInvalid())
10702 return ExprError();
10704 ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
10705 if (Value.isInvalid())
10706 return ExprError();
10708 ObjCDictionaryElement Element = {
10709 Key.get(), Value.get(), SourceLocation(), NumExpansions
10712 // If any unexpanded parameter packs remain, we still have a
10714 // FIXME: Can this really happen?
10715 if (Key.get()->containsUnexpandedParameterPack() ||
10716 Value.get()->containsUnexpandedParameterPack())
10717 Element.EllipsisLoc = OrigElement.EllipsisLoc;
10719 Elements.push_back(Element);
10722 // FIXME: Retain a pack expansion if RetainExpansion is true.
10724 // We've finished with this pack expansion.
10728 // Transform and check key.
10729 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
10730 if (Key.isInvalid())
10731 return ExprError();
10733 if (Key.get() != OrigElement.Key)
10736 // Transform and check value.
10738 = getDerived().TransformExpr(OrigElement.Value);
10739 if (Value.isInvalid())
10740 return ExprError();
10742 if (Value.get() != OrigElement.Value)
10745 ObjCDictionaryElement Element = {
10746 Key.get(), Value.get(), SourceLocation(), None
10748 Elements.push_back(Element);
10751 if (!getDerived().AlwaysRebuild() && !ArgChanged)
10752 return SemaRef.MaybeBindToTemporary(E);
10754 return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(),
10758 template<typename Derived>
10760 TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) {
10761 TypeSourceInfo *EncodedTypeInfo
10762 = getDerived().TransformType(E->getEncodedTypeSourceInfo());
10763 if (!EncodedTypeInfo)
10764 return ExprError();
10766 if (!getDerived().AlwaysRebuild() &&
10767 EncodedTypeInfo == E->getEncodedTypeSourceInfo())
10770 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(),
10772 E->getRParenLoc());
10775 template<typename Derived>
10776 ExprResult TreeTransform<Derived>::
10777 TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
10778 // This is a kind of implicit conversion, and it needs to get dropped
10779 // and recomputed for the same general reasons that ImplicitCastExprs
10780 // do, as well a more specific one: this expression is only valid when
10781 // it appears *immediately* as an argument expression.
10782 return getDerived().TransformExpr(E->getSubExpr());
10785 template<typename Derived>
10786 ExprResult TreeTransform<Derived>::
10787 TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
10788 TypeSourceInfo *TSInfo
10789 = getDerived().TransformType(E->getTypeInfoAsWritten());
10791 return ExprError();
10793 ExprResult Result = getDerived().TransformExpr(E->getSubExpr());
10794 if (Result.isInvalid())
10795 return ExprError();
10797 if (!getDerived().AlwaysRebuild() &&
10798 TSInfo == E->getTypeInfoAsWritten() &&
10799 Result.get() == E->getSubExpr())
10802 return SemaRef.BuildObjCBridgedCast(E->getLParenLoc(), E->getBridgeKind(),
10803 E->getBridgeKeywordLoc(), TSInfo,
10807 template<typename Derived>
10809 TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) {
10810 // Transform arguments.
10811 bool ArgChanged = false;
10812 SmallVector<Expr*, 8> Args;
10813 Args.reserve(E->getNumArgs());
10814 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args,
10816 return ExprError();
10818 if (E->getReceiverKind() == ObjCMessageExpr::Class) {
10819 // Class message: transform the receiver type.
10820 TypeSourceInfo *ReceiverTypeInfo
10821 = getDerived().TransformType(E->getClassReceiverTypeInfo());
10822 if (!ReceiverTypeInfo)
10823 return ExprError();
10825 // If nothing changed, just retain the existing message send.
10826 if (!getDerived().AlwaysRebuild() &&
10827 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged)
10828 return SemaRef.MaybeBindToTemporary(E);
10830 // Build a new class message send.
10831 SmallVector<SourceLocation, 16> SelLocs;
10832 E->getSelectorLocs(SelLocs);
10833 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo,
10836 E->getMethodDecl(),
10841 else if (E->getReceiverKind() == ObjCMessageExpr::SuperClass ||
10842 E->getReceiverKind() == ObjCMessageExpr::SuperInstance) {
10843 // Build a new class message send to 'super'.
10844 SmallVector<SourceLocation, 16> SelLocs;
10845 E->getSelectorLocs(SelLocs);
10846 return getDerived().RebuildObjCMessageExpr(E->getSuperLoc(),
10849 E->getReceiverType(),
10850 E->getMethodDecl(),
10856 // Instance message: transform the receiver
10857 assert(E->getReceiverKind() == ObjCMessageExpr::Instance &&
10858 "Only class and instance messages may be instantiated");
10859 ExprResult Receiver
10860 = getDerived().TransformExpr(E->getInstanceReceiver());
10861 if (Receiver.isInvalid())
10862 return ExprError();
10864 // If nothing changed, just retain the existing message send.
10865 if (!getDerived().AlwaysRebuild() &&
10866 Receiver.get() == E->getInstanceReceiver() && !ArgChanged)
10867 return SemaRef.MaybeBindToTemporary(E);
10869 // Build a new instance message send.
10870 SmallVector<SourceLocation, 16> SelLocs;
10871 E->getSelectorLocs(SelLocs);
10872 return getDerived().RebuildObjCMessageExpr(Receiver.get(),
10875 E->getMethodDecl(),
10881 template<typename Derived>
10883 TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) {
10887 template<typename Derived>
10889 TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) {
10893 template<typename Derived>
10895 TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) {
10896 // Transform the base expression.
10897 ExprResult Base = getDerived().TransformExpr(E->getBase());
10898 if (Base.isInvalid())
10899 return ExprError();
10901 // We don't need to transform the ivar; it will never change.
10903 // If nothing changed, just retain the existing expression.
10904 if (!getDerived().AlwaysRebuild() &&
10905 Base.get() == E->getBase())
10908 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(),
10910 E->isArrow(), E->isFreeIvar());
10913 template<typename Derived>
10915 TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
10916 // 'super' and types never change. Property never changes. Just
10917 // retain the existing expression.
10918 if (!E->isObjectReceiver())
10921 // Transform the base expression.
10922 ExprResult Base = getDerived().TransformExpr(E->getBase());
10923 if (Base.isInvalid())
10924 return ExprError();
10926 // We don't need to transform the property; it will never change.
10928 // If nothing changed, just retain the existing expression.
10929 if (!getDerived().AlwaysRebuild() &&
10930 Base.get() == E->getBase())
10933 if (E->isExplicitProperty())
10934 return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
10935 E->getExplicitProperty(),
10938 return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
10939 SemaRef.Context.PseudoObjectTy,
10940 E->getImplicitPropertyGetter(),
10941 E->getImplicitPropertySetter(),
10945 template<typename Derived>
10947 TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
10948 // Transform the base expression.
10949 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
10950 if (Base.isInvalid())
10951 return ExprError();
10953 // Transform the key expression.
10954 ExprResult Key = getDerived().TransformExpr(E->getKeyExpr());
10955 if (Key.isInvalid())
10956 return ExprError();
10958 // If nothing changed, just retain the existing expression.
10959 if (!getDerived().AlwaysRebuild() &&
10960 Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr())
10963 return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(),
10964 Base.get(), Key.get(),
10965 E->getAtIndexMethodDecl(),
10966 E->setAtIndexMethodDecl());
10969 template<typename Derived>
10971 TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) {
10972 // Transform the base expression.
10973 ExprResult Base = getDerived().TransformExpr(E->getBase());
10974 if (Base.isInvalid())
10975 return ExprError();
10977 // If nothing changed, just retain the existing expression.
10978 if (!getDerived().AlwaysRebuild() &&
10979 Base.get() == E->getBase())
10982 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(),
10987 template<typename Derived>
10989 TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) {
10990 bool ArgumentChanged = false;
10991 SmallVector<Expr*, 8> SubExprs;
10992 SubExprs.reserve(E->getNumSubExprs());
10993 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false,
10994 SubExprs, &ArgumentChanged))
10995 return ExprError();
10997 if (!getDerived().AlwaysRebuild() &&
11001 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(),
11003 E->getRParenLoc());
11006 template<typename Derived>
11008 TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *E) {
11009 ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr());
11010 if (SrcExpr.isInvalid())
11011 return ExprError();
11013 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
11015 return ExprError();
11017 if (!getDerived().AlwaysRebuild() &&
11018 Type == E->getTypeSourceInfo() &&
11019 SrcExpr.get() == E->getSrcExpr())
11022 return getDerived().RebuildConvertVectorExpr(E->getBuiltinLoc(),
11023 SrcExpr.get(), Type,
11024 E->getRParenLoc());
11027 template<typename Derived>
11029 TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) {
11030 BlockDecl *oldBlock = E->getBlockDecl();
11032 SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/nullptr);
11033 BlockScopeInfo *blockScope = SemaRef.getCurBlock();
11035 blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic());
11036 blockScope->TheDecl->setBlockMissingReturnType(
11037 oldBlock->blockMissingReturnType());
11039 SmallVector<ParmVarDecl*, 4> params;
11040 SmallVector<QualType, 4> paramTypes;
11042 // Parameter substitution.
11043 if (getDerived().TransformFunctionTypeParams(E->getCaretLocation(),
11044 oldBlock->param_begin(),
11045 oldBlock->param_size(),
11046 nullptr, paramTypes, ¶ms)) {
11047 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
11048 return ExprError();
11051 const FunctionProtoType *exprFunctionType = E->getFunctionType();
11052 QualType exprResultType =
11053 getDerived().TransformType(exprFunctionType->getReturnType());
11055 QualType functionType =
11056 getDerived().RebuildFunctionProtoType(exprResultType, paramTypes,
11057 exprFunctionType->getExtProtoInfo());
11058 blockScope->FunctionType = functionType;
11060 // Set the parameters on the block decl.
11061 if (!params.empty())
11062 blockScope->TheDecl->setParams(params);
11064 if (!oldBlock->blockMissingReturnType()) {
11065 blockScope->HasImplicitReturnType = false;
11066 blockScope->ReturnType = exprResultType;
11069 // Transform the body
11070 StmtResult body = getDerived().TransformStmt(E->getBody());
11071 if (body.isInvalid()) {
11072 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
11073 return ExprError();
11077 // In builds with assertions, make sure that we captured everything we
11078 // captured before.
11079 if (!SemaRef.getDiagnostics().hasErrorOccurred()) {
11080 for (const auto &I : oldBlock->captures()) {
11081 VarDecl *oldCapture = I.getVariable();
11083 // Ignore parameter packs.
11084 if (isa<ParmVarDecl>(oldCapture) &&
11085 cast<ParmVarDecl>(oldCapture)->isParameterPack())
11088 VarDecl *newCapture =
11089 cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(),
11091 assert(blockScope->CaptureMap.count(newCapture));
11093 assert(oldBlock->capturesCXXThis() == blockScope->isCXXThisCaptured());
11097 return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(),
11098 /*Scope=*/nullptr);
11101 template<typename Derived>
11103 TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) {
11104 llvm_unreachable("Cannot transform asType expressions yet");
11107 template<typename Derived>
11109 TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) {
11110 QualType RetTy = getDerived().TransformType(E->getType());
11111 bool ArgumentChanged = false;
11112 SmallVector<Expr*, 8> SubExprs;
11113 SubExprs.reserve(E->getNumSubExprs());
11114 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false,
11115 SubExprs, &ArgumentChanged))
11116 return ExprError();
11118 if (!getDerived().AlwaysRebuild() &&
11122 return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs,
11123 RetTy, E->getOp(), E->getRParenLoc());
11126 //===----------------------------------------------------------------------===//
11127 // Type reconstruction
11128 //===----------------------------------------------------------------------===//
11130 template<typename Derived>
11131 QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType,
11132 SourceLocation Star) {
11133 return SemaRef.BuildPointerType(PointeeType, Star,
11134 getDerived().getBaseEntity());
11137 template<typename Derived>
11138 QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType,
11139 SourceLocation Star) {
11140 return SemaRef.BuildBlockPointerType(PointeeType, Star,
11141 getDerived().getBaseEntity());
11144 template<typename Derived>
11146 TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType,
11147 bool WrittenAsLValue,
11148 SourceLocation Sigil) {
11149 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue,
11150 Sigil, getDerived().getBaseEntity());
11153 template<typename Derived>
11155 TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType,
11156 QualType ClassType,
11157 SourceLocation Sigil) {
11158 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Sigil,
11159 getDerived().getBaseEntity());
11162 template<typename Derived>
11163 QualType TreeTransform<Derived>::RebuildObjCObjectType(
11165 SourceLocation Loc,
11166 SourceLocation TypeArgsLAngleLoc,
11167 ArrayRef<TypeSourceInfo *> TypeArgs,
11168 SourceLocation TypeArgsRAngleLoc,
11169 SourceLocation ProtocolLAngleLoc,
11170 ArrayRef<ObjCProtocolDecl *> Protocols,
11171 ArrayRef<SourceLocation> ProtocolLocs,
11172 SourceLocation ProtocolRAngleLoc) {
11173 return SemaRef.BuildObjCObjectType(BaseType, Loc, TypeArgsLAngleLoc,
11174 TypeArgs, TypeArgsRAngleLoc,
11175 ProtocolLAngleLoc, Protocols, ProtocolLocs,
11177 /*FailOnError=*/true);
11180 template<typename Derived>
11181 QualType TreeTransform<Derived>::RebuildObjCObjectPointerType(
11182 QualType PointeeType,
11183 SourceLocation Star) {
11184 return SemaRef.Context.getObjCObjectPointerType(PointeeType);
11187 template<typename Derived>
11189 TreeTransform<Derived>::RebuildArrayType(QualType ElementType,
11190 ArrayType::ArraySizeModifier SizeMod,
11191 const llvm::APInt *Size,
11193 unsigned IndexTypeQuals,
11194 SourceRange BracketsRange) {
11195 if (SizeExpr || !Size)
11196 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr,
11197 IndexTypeQuals, BracketsRange,
11198 getDerived().getBaseEntity());
11200 QualType Types[] = {
11201 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy,
11202 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy,
11203 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty
11205 const unsigned NumTypes = llvm::array_lengthof(Types);
11207 for (unsigned I = 0; I != NumTypes; ++I)
11208 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) {
11209 SizeType = Types[I];
11213 // Note that we can return a VariableArrayType here in the case where
11214 // the element type was a dependent VariableArrayType.
11215 IntegerLiteral *ArraySize
11216 = IntegerLiteral::Create(SemaRef.Context, *Size, SizeType,
11217 /*FIXME*/BracketsRange.getBegin());
11218 return SemaRef.BuildArrayType(ElementType, SizeMod, ArraySize,
11219 IndexTypeQuals, BracketsRange,
11220 getDerived().getBaseEntity());
11223 template<typename Derived>
11225 TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType,
11226 ArrayType::ArraySizeModifier SizeMod,
11227 const llvm::APInt &Size,
11228 unsigned IndexTypeQuals,
11229 SourceRange BracketsRange) {
11230 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, nullptr,
11231 IndexTypeQuals, BracketsRange);
11234 template<typename Derived>
11236 TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType,
11237 ArrayType::ArraySizeModifier SizeMod,
11238 unsigned IndexTypeQuals,
11239 SourceRange BracketsRange) {
11240 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, nullptr,
11241 IndexTypeQuals, BracketsRange);
11244 template<typename Derived>
11246 TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType,
11247 ArrayType::ArraySizeModifier SizeMod,
11249 unsigned IndexTypeQuals,
11250 SourceRange BracketsRange) {
11251 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr,
11253 IndexTypeQuals, BracketsRange);
11256 template<typename Derived>
11258 TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType,
11259 ArrayType::ArraySizeModifier SizeMod,
11261 unsigned IndexTypeQuals,
11262 SourceRange BracketsRange) {
11263 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr,
11265 IndexTypeQuals, BracketsRange);
11268 template<typename Derived>
11269 QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType,
11270 unsigned NumElements,
11271 VectorType::VectorKind VecKind) {
11272 // FIXME: semantic checking!
11273 return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind);
11276 template<typename Derived>
11277 QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType,
11278 unsigned NumElements,
11279 SourceLocation AttributeLoc) {
11280 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
11281 NumElements, true);
11282 IntegerLiteral *VectorSize
11283 = IntegerLiteral::Create(SemaRef.Context, numElements, SemaRef.Context.IntTy,
11285 return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc);
11288 template<typename Derived>
11290 TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType,
11292 SourceLocation AttributeLoc) {
11293 return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc);
11296 template<typename Derived>
11297 QualType TreeTransform<Derived>::RebuildFunctionProtoType(
11299 MutableArrayRef<QualType> ParamTypes,
11300 const FunctionProtoType::ExtProtoInfo &EPI) {
11301 return SemaRef.BuildFunctionType(T, ParamTypes,
11302 getDerived().getBaseLocation(),
11303 getDerived().getBaseEntity(),
11307 template<typename Derived>
11308 QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) {
11309 return SemaRef.Context.getFunctionNoProtoType(T);
11312 template<typename Derived>
11313 QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(Decl *D) {
11314 assert(D && "no decl found");
11315 if (D->isInvalidDecl()) return QualType();
11317 // FIXME: Doesn't account for ObjCInterfaceDecl!
11319 if (isa<UsingDecl>(D)) {
11320 UsingDecl *Using = cast<UsingDecl>(D);
11321 assert(Using->hasTypename() &&
11322 "UnresolvedUsingTypenameDecl transformed to non-typename using");
11324 // A valid resolved using typename decl points to exactly one type decl.
11325 assert(++Using->shadow_begin() == Using->shadow_end());
11326 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl());
11329 assert(isa<UnresolvedUsingTypenameDecl>(D) &&
11330 "UnresolvedUsingTypenameDecl transformed to non-using decl");
11331 Ty = cast<UnresolvedUsingTypenameDecl>(D);
11334 return SemaRef.Context.getTypeDeclType(Ty);
11337 template<typename Derived>
11338 QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E,
11339 SourceLocation Loc) {
11340 return SemaRef.BuildTypeofExprType(E, Loc);
11343 template<typename Derived>
11344 QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) {
11345 return SemaRef.Context.getTypeOfType(Underlying);
11348 template<typename Derived>
11349 QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E,
11350 SourceLocation Loc) {
11351 return SemaRef.BuildDecltypeType(E, Loc);
11354 template<typename Derived>
11355 QualType TreeTransform<Derived>::RebuildUnaryTransformType(QualType BaseType,
11356 UnaryTransformType::UTTKind UKind,
11357 SourceLocation Loc) {
11358 return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc);
11361 template<typename Derived>
11362 QualType TreeTransform<Derived>::RebuildTemplateSpecializationType(
11363 TemplateName Template,
11364 SourceLocation TemplateNameLoc,
11365 TemplateArgumentListInfo &TemplateArgs) {
11366 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
11369 template<typename Derived>
11370 QualType TreeTransform<Derived>::RebuildAtomicType(QualType ValueType,
11371 SourceLocation KWLoc) {
11372 return SemaRef.BuildAtomicType(ValueType, KWLoc);
11375 template<typename Derived>
11376 QualType TreeTransform<Derived>::RebuildPipeType(QualType ValueType,
11377 SourceLocation KWLoc) {
11378 return SemaRef.BuildPipeType(ValueType, KWLoc);
11381 template<typename Derived>
11383 TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
11385 TemplateDecl *Template) {
11386 return SemaRef.Context.getQualifiedTemplateName(SS.getScopeRep(), TemplateKW,
11390 template<typename Derived>
11392 TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
11393 const IdentifierInfo &Name,
11394 SourceLocation NameLoc,
11395 QualType ObjectType,
11396 NamedDecl *FirstQualifierInScope) {
11397 UnqualifiedId TemplateName;
11398 TemplateName.setIdentifier(&Name, NameLoc);
11399 Sema::TemplateTy Template;
11400 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller.
11401 getSema().ActOnDependentTemplateName(/*Scope=*/nullptr,
11402 SS, TemplateKWLoc, TemplateName,
11403 ParsedType::make(ObjectType),
11404 /*EnteringContext=*/false,
11406 return Template.get();
11409 template<typename Derived>
11411 TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
11412 OverloadedOperatorKind Operator,
11413 SourceLocation NameLoc,
11414 QualType ObjectType) {
11415 UnqualifiedId Name;
11416 // FIXME: Bogus location information.
11417 SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc };
11418 Name.setOperatorFunctionId(NameLoc, Operator, SymbolLocations);
11419 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller.
11420 Sema::TemplateTy Template;
11421 getSema().ActOnDependentTemplateName(/*Scope=*/nullptr,
11422 SS, TemplateKWLoc, Name,
11423 ParsedType::make(ObjectType),
11424 /*EnteringContext=*/false,
11426 return Template.get();
11429 template<typename Derived>
11431 TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
11432 SourceLocation OpLoc,
11436 Expr *Callee = OrigCallee->IgnoreParenCasts();
11437 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus);
11439 if (First->getObjectKind() == OK_ObjCProperty) {
11440 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
11441 if (BinaryOperator::isAssignmentOp(Opc))
11442 return SemaRef.checkPseudoObjectAssignment(/*Scope=*/nullptr, OpLoc, Opc,
11444 ExprResult Result = SemaRef.CheckPlaceholderExpr(First);
11445 if (Result.isInvalid())
11446 return ExprError();
11447 First = Result.get();
11450 if (Second && Second->getObjectKind() == OK_ObjCProperty) {
11451 ExprResult Result = SemaRef.CheckPlaceholderExpr(Second);
11452 if (Result.isInvalid())
11453 return ExprError();
11454 Second = Result.get();
11457 // Determine whether this should be a builtin operation.
11458 if (Op == OO_Subscript) {
11459 if (!First->getType()->isOverloadableType() &&
11460 !Second->getType()->isOverloadableType())
11461 return getSema().CreateBuiltinArraySubscriptExpr(First,
11462 Callee->getLocStart(),
11464 } else if (Op == OO_Arrow) {
11465 // -> is never a builtin operation.
11466 return SemaRef.BuildOverloadedArrowExpr(nullptr, First, OpLoc);
11467 } else if (Second == nullptr || isPostIncDec) {
11468 if (!First->getType()->isOverloadableType()) {
11469 // The argument is not of overloadable type, so try to create a
11470 // built-in unary operation.
11471 UnaryOperatorKind Opc
11472 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
11474 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First);
11477 if (!First->getType()->isOverloadableType() &&
11478 !Second->getType()->isOverloadableType()) {
11479 // Neither of the arguments is an overloadable type, so try to
11480 // create a built-in binary operation.
11481 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
11483 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second);
11484 if (Result.isInvalid())
11485 return ExprError();
11491 // Compute the transformed set of functions (and function templates) to be
11492 // used during overload resolution.
11493 UnresolvedSet<16> Functions;
11495 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) {
11496 assert(ULE->requiresADL());
11497 Functions.append(ULE->decls_begin(), ULE->decls_end());
11499 // If we've resolved this to a particular non-member function, just call
11500 // that function. If we resolved it to a member function,
11501 // CreateOverloaded* will find that function for us.
11502 NamedDecl *ND = cast<DeclRefExpr>(Callee)->getDecl();
11503 if (!isa<CXXMethodDecl>(ND))
11504 Functions.addDecl(ND);
11507 // Add any functions found via argument-dependent lookup.
11508 Expr *Args[2] = { First, Second };
11509 unsigned NumArgs = 1 + (Second != nullptr);
11511 // Create the overloaded operator invocation for unary operators.
11512 if (NumArgs == 1 || isPostIncDec) {
11513 UnaryOperatorKind Opc
11514 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
11515 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First);
11518 if (Op == OO_Subscript) {
11519 SourceLocation LBrace;
11520 SourceLocation RBrace;
11522 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) {
11523 DeclarationNameLoc NameLoc = DRE->getNameInfo().getInfo();
11524 LBrace = SourceLocation::getFromRawEncoding(
11525 NameLoc.CXXOperatorName.BeginOpNameLoc);
11526 RBrace = SourceLocation::getFromRawEncoding(
11527 NameLoc.CXXOperatorName.EndOpNameLoc);
11529 LBrace = Callee->getLocStart();
11533 return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace,
11537 // Create the overloaded operator invocation for binary operators.
11538 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
11540 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]);
11541 if (Result.isInvalid())
11542 return ExprError();
11547 template<typename Derived>
11549 TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base,
11550 SourceLocation OperatorLoc,
11553 TypeSourceInfo *ScopeType,
11554 SourceLocation CCLoc,
11555 SourceLocation TildeLoc,
11556 PseudoDestructorTypeStorage Destroyed) {
11557 QualType BaseType = Base->getType();
11558 if (Base->isTypeDependent() || Destroyed.getIdentifier() ||
11559 (!isArrow && !BaseType->getAs<RecordType>()) ||
11560 (isArrow && BaseType->getAs<PointerType>() &&
11561 !BaseType->getAs<PointerType>()->getPointeeType()
11562 ->template getAs<RecordType>())){
11563 // This pseudo-destructor expression is still a pseudo-destructor.
11564 return SemaRef.BuildPseudoDestructorExpr(
11565 Base, OperatorLoc, isArrow ? tok::arrow : tok::period, SS, ScopeType,
11566 CCLoc, TildeLoc, Destroyed);
11569 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo();
11570 DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName(
11571 SemaRef.Context.getCanonicalType(DestroyedType->getType())));
11572 DeclarationNameInfo NameInfo(Name, Destroyed.getLocation());
11573 NameInfo.setNamedTypeInfo(DestroyedType);
11575 // The scope type is now known to be a valid nested name specifier
11576 // component. Tack it on to the end of the nested name specifier.
11578 if (!ScopeType->getType()->getAs<TagType>()) {
11579 getSema().Diag(ScopeType->getTypeLoc().getBeginLoc(),
11580 diag::err_expected_class_or_namespace)
11581 << ScopeType->getType() << getSema().getLangOpts().CPlusPlus;
11582 return ExprError();
11584 SS.Extend(SemaRef.Context, SourceLocation(), ScopeType->getTypeLoc(),
11588 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller.
11589 return getSema().BuildMemberReferenceExpr(Base, BaseType,
11590 OperatorLoc, isArrow,
11592 /*FIXME: FirstQualifier*/ nullptr,
11594 /*TemplateArgs*/ nullptr,
11598 template<typename Derived>
11600 TreeTransform<Derived>::TransformCapturedStmt(CapturedStmt *S) {
11601 SourceLocation Loc = S->getLocStart();
11602 CapturedDecl *CD = S->getCapturedDecl();
11603 unsigned NumParams = CD->getNumParams();
11604 unsigned ContextParamPos = CD->getContextParamPosition();
11605 SmallVector<Sema::CapturedParamNameType, 4> Params;
11606 for (unsigned I = 0; I < NumParams; ++I) {
11607 if (I != ContextParamPos) {
11610 CD->getParam(I)->getName(),
11611 getDerived().TransformType(CD->getParam(I)->getType())));
11613 Params.push_back(std::make_pair(StringRef(), QualType()));
11616 getSema().ActOnCapturedRegionStart(Loc, /*CurScope*/nullptr,
11617 S->getCapturedRegionKind(), Params);
11620 Sema::CompoundScopeRAII CompoundScope(getSema());
11621 Body = getDerived().TransformStmt(S->getCapturedStmt());
11624 if (Body.isInvalid()) {
11625 getSema().ActOnCapturedRegionError();
11626 return StmtError();
11629 return getSema().ActOnCapturedRegionEnd(Body.get());
11632 } // end namespace clang
11634 #endif // LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H