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 specified condition.
415 /// By default, this transforms the variable and expression and rebuilds
417 Sema::ConditionResult TransformCondition(SourceLocation Loc, VarDecl *Var,
419 Sema::ConditionKind Kind);
421 /// \brief Transform the attributes associated with the given declaration and
422 /// place them on the new declaration.
424 /// By default, this operation does nothing. Subclasses may override this
425 /// behavior to transform attributes.
426 void transformAttrs(Decl *Old, Decl *New) { }
428 /// \brief Note that a local declaration has been transformed by this
431 /// Local declarations are typically transformed via a call to
432 /// TransformDefinition. However, in some cases (e.g., lambda expressions),
433 /// the transformer itself has to transform the declarations. This routine
434 /// can be overridden by a subclass that keeps track of such mappings.
435 void transformedLocalDecl(Decl *Old, Decl *New) {
436 TransformedLocalDecls[Old] = New;
439 /// \brief Transform the definition of the given declaration.
441 /// By default, invokes TransformDecl() to transform the declaration.
442 /// Subclasses may override this function to provide alternate behavior.
443 Decl *TransformDefinition(SourceLocation Loc, Decl *D) {
444 return getDerived().TransformDecl(Loc, D);
447 /// \brief Transform the given declaration, which was the first part of a
448 /// nested-name-specifier in a member access expression.
450 /// This specific declaration transformation only applies to the first
451 /// identifier in a nested-name-specifier of a member access expression, e.g.,
452 /// the \c T in \c x->T::member
454 /// By default, invokes TransformDecl() to transform the declaration.
455 /// Subclasses may override this function to provide alternate behavior.
456 NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc) {
457 return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D));
460 /// Transform the set of declarations in an OverloadExpr.
461 bool TransformOverloadExprDecls(OverloadExpr *Old, bool RequiresADL,
464 /// \brief Transform the given nested-name-specifier with source-location
467 /// By default, transforms all of the types and declarations within the
468 /// nested-name-specifier. Subclasses may override this function to provide
469 /// alternate behavior.
470 NestedNameSpecifierLoc
471 TransformNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
472 QualType ObjectType = QualType(),
473 NamedDecl *FirstQualifierInScope = nullptr);
475 /// \brief Transform the given declaration name.
477 /// By default, transforms the types of conversion function, constructor,
478 /// and destructor names and then (if needed) rebuilds the declaration name.
479 /// Identifiers and selectors are returned unmodified. Sublcasses may
480 /// override this function to provide alternate behavior.
482 TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo);
484 /// \brief Transform the given template name.
486 /// \param SS The nested-name-specifier that qualifies the template
487 /// name. This nested-name-specifier must already have been transformed.
489 /// \param Name The template name to transform.
491 /// \param NameLoc The source location of the template name.
493 /// \param ObjectType If we're translating a template name within a member
494 /// access expression, this is the type of the object whose member template
495 /// is being referenced.
497 /// \param FirstQualifierInScope If the first part of a nested-name-specifier
498 /// also refers to a name within the current (lexical) scope, this is the
499 /// declaration it refers to.
501 /// By default, transforms the template name by transforming the declarations
502 /// and nested-name-specifiers that occur within the template name.
503 /// Subclasses may override this function to provide alternate behavior.
505 TransformTemplateName(CXXScopeSpec &SS, TemplateName Name,
506 SourceLocation NameLoc,
507 QualType ObjectType = QualType(),
508 NamedDecl *FirstQualifierInScope = nullptr);
510 /// \brief Transform the given template argument.
512 /// By default, this operation transforms the type, expression, or
513 /// declaration stored within the template argument and constructs a
514 /// new template argument from the transformed result. Subclasses may
515 /// override this function to provide alternate behavior.
517 /// Returns true if there was an error.
518 bool TransformTemplateArgument(const TemplateArgumentLoc &Input,
519 TemplateArgumentLoc &Output,
520 bool Uneval = false);
522 /// \brief Transform the given set of template arguments.
524 /// By default, this operation transforms all of the template arguments
525 /// in the input set using \c TransformTemplateArgument(), and appends
526 /// the transformed arguments to the output list.
528 /// Note that this overload of \c TransformTemplateArguments() is merely
529 /// a convenience function. Subclasses that wish to override this behavior
530 /// should override the iterator-based member template version.
532 /// \param Inputs The set of template arguments to be transformed.
534 /// \param NumInputs The number of template arguments in \p Inputs.
536 /// \param Outputs The set of transformed template arguments output by this
539 /// Returns true if an error occurred.
540 bool TransformTemplateArguments(const TemplateArgumentLoc *Inputs,
542 TemplateArgumentListInfo &Outputs,
543 bool Uneval = false) {
544 return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs,
548 /// \brief Transform the given set of template arguments.
550 /// By default, this operation transforms all of the template arguments
551 /// in the input set using \c TransformTemplateArgument(), and appends
552 /// the transformed arguments to the output list.
554 /// \param First An iterator to the first template argument.
556 /// \param Last An iterator one step past the last template argument.
558 /// \param Outputs The set of transformed template arguments output by this
561 /// Returns true if an error occurred.
562 template<typename InputIterator>
563 bool TransformTemplateArguments(InputIterator First,
565 TemplateArgumentListInfo &Outputs,
566 bool Uneval = false);
568 /// \brief Fakes up a TemplateArgumentLoc for a given TemplateArgument.
569 void InventTemplateArgumentLoc(const TemplateArgument &Arg,
570 TemplateArgumentLoc &ArgLoc);
572 /// \brief Fakes up a TypeSourceInfo for a type.
573 TypeSourceInfo *InventTypeSourceInfo(QualType T) {
574 return SemaRef.Context.getTrivialTypeSourceInfo(T,
575 getDerived().getBaseLocation());
578 #define ABSTRACT_TYPELOC(CLASS, PARENT)
579 #define TYPELOC(CLASS, PARENT) \
580 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
581 #include "clang/AST/TypeLocNodes.def"
583 template<typename Fn>
584 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
585 FunctionProtoTypeLoc TL,
586 CXXRecordDecl *ThisContext,
587 unsigned ThisTypeQuals,
588 Fn TransformExceptionSpec);
590 bool TransformExceptionSpec(SourceLocation Loc,
591 FunctionProtoType::ExceptionSpecInfo &ESI,
592 SmallVectorImpl<QualType> &Exceptions,
595 StmtResult TransformSEHHandler(Stmt *Handler);
598 TransformTemplateSpecializationType(TypeLocBuilder &TLB,
599 TemplateSpecializationTypeLoc TL,
600 TemplateName Template);
603 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
604 DependentTemplateSpecializationTypeLoc TL,
605 TemplateName Template,
608 QualType TransformDependentTemplateSpecializationType(
609 TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
610 NestedNameSpecifierLoc QualifierLoc);
612 /// \brief Transforms the parameters of a function type into the
615 /// The result vectors should be kept in sync; null entries in the
616 /// variables vector are acceptable.
618 /// Return true on error.
619 bool TransformFunctionTypeParams(
620 SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
621 const QualType *ParamTypes,
622 const FunctionProtoType::ExtParameterInfo *ParamInfos,
623 SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars,
624 Sema::ExtParameterInfoBuilder &PInfos);
626 /// \brief Transforms a single function-type parameter. Return null
629 /// \param indexAdjustment - A number to add to the parameter's
630 /// scope index; can be negative
631 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
633 Optional<unsigned> NumExpansions,
634 bool ExpectParameterPack);
636 QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);
638 StmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr);
639 ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *E);
641 TemplateParameterList *TransformTemplateParameterList(
642 TemplateParameterList *TPL) {
646 ExprResult TransformAddressOfOperand(Expr *E);
648 ExprResult TransformDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E,
649 bool IsAddressOfOperand,
650 TypeSourceInfo **RecoveryTSI);
652 ExprResult TransformParenDependentScopeDeclRefExpr(
653 ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool IsAddressOfOperand,
654 TypeSourceInfo **RecoveryTSI);
656 StmtResult TransformOMPExecutableDirective(OMPExecutableDirective *S);
658 // FIXME: We use LLVM_ATTRIBUTE_NOINLINE because inlining causes a ridiculous
659 // amount of stack usage with clang.
660 #define STMT(Node, Parent) \
661 LLVM_ATTRIBUTE_NOINLINE \
662 StmtResult Transform##Node(Node *S);
663 #define EXPR(Node, Parent) \
664 LLVM_ATTRIBUTE_NOINLINE \
665 ExprResult Transform##Node(Node *E);
666 #define ABSTRACT_STMT(Stmt)
667 #include "clang/AST/StmtNodes.inc"
669 #define OPENMP_CLAUSE(Name, Class) \
670 LLVM_ATTRIBUTE_NOINLINE \
671 OMPClause *Transform ## Class(Class *S);
672 #include "clang/Basic/OpenMPKinds.def"
674 /// \brief Build a new pointer type given its pointee type.
676 /// By default, performs semantic analysis when building the pointer type.
677 /// Subclasses may override this routine to provide different behavior.
678 QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);
680 /// \brief Build a new block pointer type given its pointee type.
682 /// By default, performs semantic analysis when building the block pointer
683 /// type. Subclasses may override this routine to provide different behavior.
684 QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);
686 /// \brief Build a new reference type given the type it references.
688 /// By default, performs semantic analysis when building the
689 /// reference type. Subclasses may override this routine to provide
690 /// different behavior.
692 /// \param LValue whether the type was written with an lvalue sigil
693 /// or an rvalue sigil.
694 QualType RebuildReferenceType(QualType ReferentType,
696 SourceLocation Sigil);
698 /// \brief Build a new member pointer type given the pointee type and the
699 /// class type it refers into.
701 /// By default, performs semantic analysis when building the member pointer
702 /// type. Subclasses may override this routine to provide different behavior.
703 QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
704 SourceLocation Sigil);
706 QualType RebuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
707 SourceLocation ProtocolLAngleLoc,
708 ArrayRef<ObjCProtocolDecl *> Protocols,
709 ArrayRef<SourceLocation> ProtocolLocs,
710 SourceLocation ProtocolRAngleLoc);
712 /// \brief Build an Objective-C object type.
714 /// By default, performs semantic analysis when building the object type.
715 /// Subclasses may override this routine to provide different behavior.
716 QualType RebuildObjCObjectType(QualType BaseType,
718 SourceLocation TypeArgsLAngleLoc,
719 ArrayRef<TypeSourceInfo *> TypeArgs,
720 SourceLocation TypeArgsRAngleLoc,
721 SourceLocation ProtocolLAngleLoc,
722 ArrayRef<ObjCProtocolDecl *> Protocols,
723 ArrayRef<SourceLocation> ProtocolLocs,
724 SourceLocation ProtocolRAngleLoc);
726 /// \brief Build a new Objective-C object pointer type given the pointee type.
728 /// By default, directly builds the pointer type, with no additional semantic
730 QualType RebuildObjCObjectPointerType(QualType PointeeType,
731 SourceLocation Star);
733 /// \brief Build a new array type given the element type, size
734 /// modifier, size of the array (if known), size expression, and index type
737 /// By default, performs semantic analysis when building the array type.
738 /// Subclasses may override this routine to provide different behavior.
739 /// Also by default, all of the other Rebuild*Array
740 QualType RebuildArrayType(QualType ElementType,
741 ArrayType::ArraySizeModifier SizeMod,
742 const llvm::APInt *Size,
744 unsigned IndexTypeQuals,
745 SourceRange BracketsRange);
747 /// \brief Build a new constant array type given the element type, size
748 /// modifier, (known) size of the array, and index type qualifiers.
750 /// By default, performs semantic analysis when building the array type.
751 /// Subclasses may override this routine to provide different behavior.
752 QualType RebuildConstantArrayType(QualType ElementType,
753 ArrayType::ArraySizeModifier SizeMod,
754 const llvm::APInt &Size,
755 unsigned IndexTypeQuals,
756 SourceRange BracketsRange);
758 /// \brief Build a new incomplete array type given the element type, size
759 /// modifier, and index type qualifiers.
761 /// By default, performs semantic analysis when building the array type.
762 /// Subclasses may override this routine to provide different behavior.
763 QualType RebuildIncompleteArrayType(QualType ElementType,
764 ArrayType::ArraySizeModifier SizeMod,
765 unsigned IndexTypeQuals,
766 SourceRange BracketsRange);
768 /// \brief Build a new variable-length array type given the element type,
769 /// size modifier, size expression, and index type qualifiers.
771 /// By default, performs semantic analysis when building the array type.
772 /// Subclasses may override this routine to provide different behavior.
773 QualType RebuildVariableArrayType(QualType ElementType,
774 ArrayType::ArraySizeModifier SizeMod,
776 unsigned IndexTypeQuals,
777 SourceRange BracketsRange);
779 /// \brief Build a new dependent-sized array type given the element type,
780 /// size modifier, size expression, and index type qualifiers.
782 /// By default, performs semantic analysis when building the array type.
783 /// Subclasses may override this routine to provide different behavior.
784 QualType RebuildDependentSizedArrayType(QualType ElementType,
785 ArrayType::ArraySizeModifier SizeMod,
787 unsigned IndexTypeQuals,
788 SourceRange BracketsRange);
790 /// \brief Build a new vector type given the element type and
791 /// number of elements.
793 /// By default, performs semantic analysis when building the vector type.
794 /// Subclasses may override this routine to provide different behavior.
795 QualType RebuildVectorType(QualType ElementType, unsigned NumElements,
796 VectorType::VectorKind VecKind);
798 /// \brief Build a new extended vector type given the element type and
799 /// number of elements.
801 /// By default, performs semantic analysis when building the vector type.
802 /// Subclasses may override this routine to provide different behavior.
803 QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements,
804 SourceLocation AttributeLoc);
806 /// \brief Build a new potentially dependently-sized extended vector type
807 /// given the element type and number of elements.
809 /// By default, performs semantic analysis when building the vector type.
810 /// Subclasses may override this routine to provide different behavior.
811 QualType RebuildDependentSizedExtVectorType(QualType ElementType,
813 SourceLocation AttributeLoc);
815 /// \brief Build a new function type.
817 /// By default, performs semantic analysis when building the function type.
818 /// Subclasses may override this routine to provide different behavior.
819 QualType RebuildFunctionProtoType(QualType T,
820 MutableArrayRef<QualType> ParamTypes,
821 const FunctionProtoType::ExtProtoInfo &EPI);
823 /// \brief Build a new unprototyped function type.
824 QualType RebuildFunctionNoProtoType(QualType ResultType);
826 /// \brief Rebuild an unresolved typename type, given the decl that
827 /// the UnresolvedUsingTypenameDecl was transformed to.
828 QualType RebuildUnresolvedUsingType(SourceLocation NameLoc, Decl *D);
830 /// \brief Build a new typedef type.
831 QualType RebuildTypedefType(TypedefNameDecl *Typedef) {
832 return SemaRef.Context.getTypeDeclType(Typedef);
835 /// \brief Build a new class/struct/union type.
836 QualType RebuildRecordType(RecordDecl *Record) {
837 return SemaRef.Context.getTypeDeclType(Record);
840 /// \brief Build a new Enum type.
841 QualType RebuildEnumType(EnumDecl *Enum) {
842 return SemaRef.Context.getTypeDeclType(Enum);
845 /// \brief Build a new typeof(expr) type.
847 /// By default, performs semantic analysis when building the typeof type.
848 /// Subclasses may override this routine to provide different behavior.
849 QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc);
851 /// \brief Build a new typeof(type) type.
853 /// By default, builds a new TypeOfType with the given underlying type.
854 QualType RebuildTypeOfType(QualType Underlying);
856 /// \brief Build a new unary transform type.
857 QualType RebuildUnaryTransformType(QualType BaseType,
858 UnaryTransformType::UTTKind UKind,
861 /// \brief Build a new C++11 decltype type.
863 /// By default, performs semantic analysis when building the decltype type.
864 /// Subclasses may override this routine to provide different behavior.
865 QualType RebuildDecltypeType(Expr *Underlying, SourceLocation Loc);
867 /// \brief Build a new C++11 auto type.
869 /// By default, builds a new AutoType with the given deduced type.
870 QualType RebuildAutoType(QualType Deduced, AutoTypeKeyword Keyword) {
871 // Note, IsDependent is always false here: we implicitly convert an 'auto'
872 // which has been deduced to a dependent type into an undeduced 'auto', so
873 // that we'll retry deduction after the transformation.
874 return SemaRef.Context.getAutoType(Deduced, Keyword,
875 /*IsDependent*/ false);
878 /// \brief Build a new template specialization type.
880 /// By default, performs semantic analysis when building the template
881 /// specialization type. Subclasses may override this routine to provide
882 /// different behavior.
883 QualType RebuildTemplateSpecializationType(TemplateName Template,
884 SourceLocation TemplateLoc,
885 TemplateArgumentListInfo &Args);
887 /// \brief Build a new parenthesized type.
889 /// By default, builds a new ParenType type from the inner type.
890 /// Subclasses may override this routine to provide different behavior.
891 QualType RebuildParenType(QualType InnerType) {
892 return SemaRef.Context.getParenType(InnerType);
895 /// \brief Build a new qualified name type.
897 /// By default, builds a new ElaboratedType type from the keyword,
898 /// the nested-name-specifier and the named type.
899 /// Subclasses may override this routine to provide different behavior.
900 QualType RebuildElaboratedType(SourceLocation KeywordLoc,
901 ElaboratedTypeKeyword Keyword,
902 NestedNameSpecifierLoc QualifierLoc,
904 return SemaRef.Context.getElaboratedType(Keyword,
905 QualifierLoc.getNestedNameSpecifier(),
909 /// \brief Build a new typename type that refers to a template-id.
911 /// By default, builds a new DependentNameType type from the
912 /// nested-name-specifier and the given type. Subclasses may override
913 /// this routine to provide different behavior.
914 QualType RebuildDependentTemplateSpecializationType(
915 ElaboratedTypeKeyword Keyword,
916 NestedNameSpecifierLoc QualifierLoc,
917 const IdentifierInfo *Name,
918 SourceLocation NameLoc,
919 TemplateArgumentListInfo &Args) {
920 // Rebuild the template name.
921 // TODO: avoid TemplateName abstraction
923 SS.Adopt(QualifierLoc);
924 TemplateName InstName
925 = getDerived().RebuildTemplateName(SS, *Name, NameLoc, QualType(),
928 if (InstName.isNull())
931 // If it's still dependent, make a dependent specialization.
932 if (InstName.getAsDependentTemplateName())
933 return SemaRef.Context.getDependentTemplateSpecializationType(Keyword,
934 QualifierLoc.getNestedNameSpecifier(),
938 // Otherwise, make an elaborated type wrapping a non-dependent
941 getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
942 if (T.isNull()) return QualType();
944 if (Keyword == ETK_None && QualifierLoc.getNestedNameSpecifier() == nullptr)
947 return SemaRef.Context.getElaboratedType(Keyword,
948 QualifierLoc.getNestedNameSpecifier(),
952 /// \brief Build a new typename type that refers to an identifier.
954 /// By default, performs semantic analysis when building the typename type
955 /// (or elaborated type). Subclasses may override this routine to provide
956 /// different behavior.
957 QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword,
958 SourceLocation KeywordLoc,
959 NestedNameSpecifierLoc QualifierLoc,
960 const IdentifierInfo *Id,
961 SourceLocation IdLoc) {
963 SS.Adopt(QualifierLoc);
965 if (QualifierLoc.getNestedNameSpecifier()->isDependent()) {
966 // If the name is still dependent, just build a new dependent name type.
967 if (!SemaRef.computeDeclContext(SS))
968 return SemaRef.Context.getDependentNameType(Keyword,
969 QualifierLoc.getNestedNameSpecifier(),
973 if (Keyword == ETK_None || Keyword == ETK_Typename)
974 return SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc,
977 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
979 // We had a dependent elaborated-type-specifier that has been transformed
980 // into a non-dependent elaborated-type-specifier. Find the tag we're
982 LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
983 DeclContext *DC = SemaRef.computeDeclContext(SS, false);
987 if (SemaRef.RequireCompleteDeclContext(SS, DC))
990 TagDecl *Tag = nullptr;
991 SemaRef.LookupQualifiedName(Result, DC);
992 switch (Result.getResultKind()) {
993 case LookupResult::NotFound:
994 case LookupResult::NotFoundInCurrentInstantiation:
997 case LookupResult::Found:
998 Tag = Result.getAsSingle<TagDecl>();
1001 case LookupResult::FoundOverloaded:
1002 case LookupResult::FoundUnresolvedValue:
1003 llvm_unreachable("Tag lookup cannot find non-tags");
1005 case LookupResult::Ambiguous:
1006 // Let the LookupResult structure handle ambiguities.
1011 // Check where the name exists but isn't a tag type and use that to emit
1012 // better diagnostics.
1013 LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
1014 SemaRef.LookupQualifiedName(Result, DC);
1015 switch (Result.getResultKind()) {
1016 case LookupResult::Found:
1017 case LookupResult::FoundOverloaded:
1018 case LookupResult::FoundUnresolvedValue: {
1019 NamedDecl *SomeDecl = Result.getRepresentativeDecl();
1020 Sema::NonTagKind NTK = SemaRef.getNonTagTypeDeclKind(SomeDecl, Kind);
1021 SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) << SomeDecl
1023 SemaRef.Diag(SomeDecl->getLocation(), diag::note_declared_at);
1027 SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope)
1028 << Kind << Id << DC << QualifierLoc.getSourceRange();
1034 if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind, /*isDefinition*/false,
1036 SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id;
1037 SemaRef.Diag(Tag->getLocation(), diag::note_previous_use);
1041 // Build the elaborated-type-specifier type.
1042 QualType T = SemaRef.Context.getTypeDeclType(Tag);
1043 return SemaRef.Context.getElaboratedType(Keyword,
1044 QualifierLoc.getNestedNameSpecifier(),
1048 /// \brief Build a new pack expansion type.
1050 /// By default, builds a new PackExpansionType type from the given pattern.
1051 /// Subclasses may override this routine to provide different behavior.
1052 QualType RebuildPackExpansionType(QualType Pattern,
1053 SourceRange PatternRange,
1054 SourceLocation EllipsisLoc,
1055 Optional<unsigned> NumExpansions) {
1056 return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc,
1060 /// \brief Build a new atomic type given its value type.
1062 /// By default, performs semantic analysis when building the atomic type.
1063 /// Subclasses may override this routine to provide different behavior.
1064 QualType RebuildAtomicType(QualType ValueType, SourceLocation KWLoc);
1066 /// \brief Build a new pipe type given its value type.
1067 QualType RebuildPipeType(QualType ValueType, SourceLocation KWLoc,
1070 /// \brief Build a new template name given a nested name specifier, a flag
1071 /// indicating whether the "template" keyword was provided, and the template
1072 /// that the template name refers to.
1074 /// By default, builds the new template name directly. Subclasses may override
1075 /// this routine to provide different behavior.
1076 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1078 TemplateDecl *Template);
1080 /// \brief Build a new template name given a nested name specifier and the
1081 /// name that is referred to as a template.
1083 /// By default, performs semantic analysis to determine whether the name can
1084 /// be resolved to a specific template, then builds the appropriate kind of
1085 /// template name. Subclasses may override this routine to provide different
1087 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1088 const IdentifierInfo &Name,
1089 SourceLocation NameLoc,
1090 QualType ObjectType,
1091 NamedDecl *FirstQualifierInScope);
1093 /// \brief Build a new template name given a nested name specifier and the
1094 /// overloaded operator name that is referred to as a template.
1096 /// By default, performs semantic analysis to determine whether the name can
1097 /// be resolved to a specific template, then builds the appropriate kind of
1098 /// template name. Subclasses may override this routine to provide different
1100 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1101 OverloadedOperatorKind Operator,
1102 SourceLocation NameLoc,
1103 QualType ObjectType);
1105 /// \brief Build a new template name given a template template parameter pack
1108 /// By default, performs semantic analysis to determine whether the name can
1109 /// be resolved to a specific template, then builds the appropriate kind of
1110 /// template name. Subclasses may override this routine to provide different
1112 TemplateName RebuildTemplateName(TemplateTemplateParmDecl *Param,
1113 const TemplateArgument &ArgPack) {
1114 return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
1117 /// \brief Build a new compound statement.
1119 /// By default, performs semantic analysis to build the new statement.
1120 /// Subclasses may override this routine to provide different behavior.
1121 StmtResult RebuildCompoundStmt(SourceLocation LBraceLoc,
1122 MultiStmtArg Statements,
1123 SourceLocation RBraceLoc,
1125 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements,
1129 /// \brief Build a new case statement.
1131 /// By default, performs semantic analysis to build the new statement.
1132 /// Subclasses may override this routine to provide different behavior.
1133 StmtResult RebuildCaseStmt(SourceLocation CaseLoc,
1135 SourceLocation EllipsisLoc,
1137 SourceLocation ColonLoc) {
1138 return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS,
1142 /// \brief Attach the body to a new case statement.
1144 /// By default, performs semantic analysis to build the new statement.
1145 /// Subclasses may override this routine to provide different behavior.
1146 StmtResult RebuildCaseStmtBody(Stmt *S, Stmt *Body) {
1147 getSema().ActOnCaseStmtBody(S, Body);
1151 /// \brief Build a new default statement.
1153 /// By default, performs semantic analysis to build the new statement.
1154 /// Subclasses may override this routine to provide different behavior.
1155 StmtResult RebuildDefaultStmt(SourceLocation DefaultLoc,
1156 SourceLocation ColonLoc,
1158 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt,
1159 /*CurScope=*/nullptr);
1162 /// \brief Build a new label statement.
1164 /// By default, performs semantic analysis to build the new statement.
1165 /// Subclasses may override this routine to provide different behavior.
1166 StmtResult RebuildLabelStmt(SourceLocation IdentLoc, LabelDecl *L,
1167 SourceLocation ColonLoc, Stmt *SubStmt) {
1168 return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt);
1171 /// \brief Build a new label statement.
1173 /// By default, performs semantic analysis to build the new statement.
1174 /// Subclasses may override this routine to provide different behavior.
1175 StmtResult RebuildAttributedStmt(SourceLocation AttrLoc,
1176 ArrayRef<const Attr*> Attrs,
1178 return SemaRef.ActOnAttributedStmt(AttrLoc, Attrs, SubStmt);
1181 /// \brief Build a new "if" statement.
1183 /// By default, performs semantic analysis to build the new statement.
1184 /// Subclasses may override this routine to provide different behavior.
1185 StmtResult RebuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
1186 Sema::ConditionResult Cond, Stmt *Init, Stmt *Then,
1187 SourceLocation ElseLoc, Stmt *Else) {
1188 return getSema().ActOnIfStmt(IfLoc, IsConstexpr, Init, Cond, Then,
1192 /// \brief Start building a new switch statement.
1194 /// By default, performs semantic analysis to build the new statement.
1195 /// Subclasses may override this routine to provide different behavior.
1196 StmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc, Stmt *Init,
1197 Sema::ConditionResult Cond) {
1198 return getSema().ActOnStartOfSwitchStmt(SwitchLoc, Init, Cond);
1201 /// \brief Attach the body to the switch statement.
1203 /// By default, performs semantic analysis to build the new statement.
1204 /// Subclasses may override this routine to provide different behavior.
1205 StmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc,
1206 Stmt *Switch, Stmt *Body) {
1207 return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body);
1210 /// \brief Build a new while statement.
1212 /// By default, performs semantic analysis to build the new statement.
1213 /// Subclasses may override this routine to provide different behavior.
1214 StmtResult RebuildWhileStmt(SourceLocation WhileLoc,
1215 Sema::ConditionResult Cond, Stmt *Body) {
1216 return getSema().ActOnWhileStmt(WhileLoc, Cond, Body);
1219 /// \brief Build a new do-while statement.
1221 /// By default, performs semantic analysis to build the new statement.
1222 /// Subclasses may override this routine to provide different behavior.
1223 StmtResult RebuildDoStmt(SourceLocation DoLoc, Stmt *Body,
1224 SourceLocation WhileLoc, SourceLocation LParenLoc,
1225 Expr *Cond, SourceLocation RParenLoc) {
1226 return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
1230 /// \brief Build a new for statement.
1232 /// By default, performs semantic analysis to build the new statement.
1233 /// Subclasses may override this routine to provide different behavior.
1234 StmtResult RebuildForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1235 Stmt *Init, Sema::ConditionResult Cond,
1236 Sema::FullExprArg Inc, SourceLocation RParenLoc,
1238 return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
1239 Inc, RParenLoc, Body);
1242 /// \brief Build a new goto statement.
1244 /// By default, performs semantic analysis to build the new statement.
1245 /// Subclasses may override this routine to provide different behavior.
1246 StmtResult RebuildGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc,
1248 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label);
1251 /// \brief Build a new indirect goto statement.
1253 /// By default, performs semantic analysis to build the new statement.
1254 /// Subclasses may override this routine to provide different behavior.
1255 StmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc,
1256 SourceLocation StarLoc,
1258 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target);
1261 /// \brief Build a new return statement.
1263 /// By default, performs semantic analysis to build the new statement.
1264 /// Subclasses may override this routine to provide different behavior.
1265 StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, Expr *Result) {
1266 return getSema().BuildReturnStmt(ReturnLoc, Result);
1269 /// \brief Build a new declaration statement.
1271 /// By default, performs semantic analysis to build the new statement.
1272 /// Subclasses may override this routine to provide different behavior.
1273 StmtResult RebuildDeclStmt(MutableArrayRef<Decl *> Decls,
1274 SourceLocation StartLoc, SourceLocation EndLoc) {
1275 Sema::DeclGroupPtrTy DG = getSema().BuildDeclaratorGroup(Decls);
1276 return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc);
1279 /// \brief Build a new inline asm statement.
1281 /// By default, performs semantic analysis to build the new statement.
1282 /// Subclasses may override this routine to provide different behavior.
1283 StmtResult RebuildGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
1284 bool IsVolatile, unsigned NumOutputs,
1285 unsigned NumInputs, IdentifierInfo **Names,
1286 MultiExprArg Constraints, MultiExprArg Exprs,
1287 Expr *AsmString, MultiExprArg Clobbers,
1288 SourceLocation RParenLoc) {
1289 return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
1290 NumInputs, Names, Constraints, Exprs,
1291 AsmString, Clobbers, RParenLoc);
1294 /// \brief Build a new MS style inline asm statement.
1296 /// By default, performs semantic analysis to build the new statement.
1297 /// Subclasses may override this routine to provide different behavior.
1298 StmtResult RebuildMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
1299 ArrayRef<Token> AsmToks,
1300 StringRef AsmString,
1301 unsigned NumOutputs, unsigned NumInputs,
1302 ArrayRef<StringRef> Constraints,
1303 ArrayRef<StringRef> Clobbers,
1304 ArrayRef<Expr*> Exprs,
1305 SourceLocation EndLoc) {
1306 return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString,
1307 NumOutputs, NumInputs,
1308 Constraints, Clobbers, Exprs, EndLoc);
1311 /// \brief Build a new co_return statement.
1313 /// By default, performs semantic analysis to build the new statement.
1314 /// Subclasses may override this routine to provide different behavior.
1315 StmtResult RebuildCoreturnStmt(SourceLocation CoreturnLoc, Expr *Result) {
1316 return getSema().BuildCoreturnStmt(CoreturnLoc, Result);
1319 /// \brief Build a new co_await expression.
1321 /// By default, performs semantic analysis to build the new expression.
1322 /// Subclasses may override this routine to provide different behavior.
1323 ExprResult RebuildCoawaitExpr(SourceLocation CoawaitLoc, Expr *Result) {
1324 return getSema().BuildCoawaitExpr(CoawaitLoc, Result);
1327 /// \brief Build a new co_yield expression.
1329 /// By default, performs semantic analysis to build the new expression.
1330 /// Subclasses may override this routine to provide different behavior.
1331 ExprResult RebuildCoyieldExpr(SourceLocation CoyieldLoc, Expr *Result) {
1332 return getSema().BuildCoyieldExpr(CoyieldLoc, Result);
1335 /// \brief Build a new Objective-C \@try statement.
1337 /// By default, performs semantic analysis to build the new statement.
1338 /// Subclasses may override this routine to provide different behavior.
1339 StmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc,
1341 MultiStmtArg CatchStmts,
1343 return getSema().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts,
1347 /// \brief Rebuild an Objective-C exception declaration.
1349 /// By default, performs semantic analysis to build the new declaration.
1350 /// Subclasses may override this routine to provide different behavior.
1351 VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
1352 TypeSourceInfo *TInfo, QualType T) {
1353 return getSema().BuildObjCExceptionDecl(TInfo, T,
1354 ExceptionDecl->getInnerLocStart(),
1355 ExceptionDecl->getLocation(),
1356 ExceptionDecl->getIdentifier());
1359 /// \brief Build a new Objective-C \@catch statement.
1361 /// By default, performs semantic analysis to build the new statement.
1362 /// Subclasses may override this routine to provide different behavior.
1363 StmtResult RebuildObjCAtCatchStmt(SourceLocation AtLoc,
1364 SourceLocation RParenLoc,
1367 return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
1371 /// \brief Build a new Objective-C \@finally statement.
1373 /// By default, performs semantic analysis to build the new statement.
1374 /// Subclasses may override this routine to provide different behavior.
1375 StmtResult RebuildObjCAtFinallyStmt(SourceLocation AtLoc,
1377 return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body);
1380 /// \brief Build a new Objective-C \@throw statement.
1382 /// By default, performs semantic analysis to build the new statement.
1383 /// Subclasses may override this routine to provide different behavior.
1384 StmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc,
1386 return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
1389 /// \brief Build a new OpenMP executable directive.
1391 /// By default, performs semantic analysis to build the new statement.
1392 /// Subclasses may override this routine to provide different behavior.
1393 StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind,
1394 DeclarationNameInfo DirName,
1395 OpenMPDirectiveKind CancelRegion,
1396 ArrayRef<OMPClause *> Clauses,
1397 Stmt *AStmt, SourceLocation StartLoc,
1398 SourceLocation EndLoc) {
1399 return getSema().ActOnOpenMPExecutableDirective(
1400 Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
1403 /// \brief Build a new OpenMP 'if' clause.
1405 /// By default, performs semantic analysis to build the new OpenMP clause.
1406 /// Subclasses may override this routine to provide different behavior.
1407 OMPClause *RebuildOMPIfClause(OpenMPDirectiveKind NameModifier,
1408 Expr *Condition, SourceLocation StartLoc,
1409 SourceLocation LParenLoc,
1410 SourceLocation NameModifierLoc,
1411 SourceLocation ColonLoc,
1412 SourceLocation EndLoc) {
1413 return getSema().ActOnOpenMPIfClause(NameModifier, Condition, StartLoc,
1414 LParenLoc, NameModifierLoc, ColonLoc,
1418 /// \brief Build a new OpenMP 'final' clause.
1420 /// By default, performs semantic analysis to build the new OpenMP clause.
1421 /// Subclasses may override this routine to provide different behavior.
1422 OMPClause *RebuildOMPFinalClause(Expr *Condition, SourceLocation StartLoc,
1423 SourceLocation LParenLoc,
1424 SourceLocation EndLoc) {
1425 return getSema().ActOnOpenMPFinalClause(Condition, StartLoc, LParenLoc,
1429 /// \brief Build a new OpenMP 'num_threads' clause.
1431 /// By default, performs semantic analysis to build the new OpenMP clause.
1432 /// Subclasses may override this routine to provide different behavior.
1433 OMPClause *RebuildOMPNumThreadsClause(Expr *NumThreads,
1434 SourceLocation StartLoc,
1435 SourceLocation LParenLoc,
1436 SourceLocation EndLoc) {
1437 return getSema().ActOnOpenMPNumThreadsClause(NumThreads, StartLoc,
1441 /// \brief Build a new OpenMP 'safelen' clause.
1443 /// By default, performs semantic analysis to build the new OpenMP clause.
1444 /// Subclasses may override this routine to provide different behavior.
1445 OMPClause *RebuildOMPSafelenClause(Expr *Len, SourceLocation StartLoc,
1446 SourceLocation LParenLoc,
1447 SourceLocation EndLoc) {
1448 return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc);
1451 /// \brief Build a new OpenMP 'simdlen' clause.
1453 /// By default, performs semantic analysis to build the new OpenMP clause.
1454 /// Subclasses may override this routine to provide different behavior.
1455 OMPClause *RebuildOMPSimdlenClause(Expr *Len, SourceLocation StartLoc,
1456 SourceLocation LParenLoc,
1457 SourceLocation EndLoc) {
1458 return getSema().ActOnOpenMPSimdlenClause(Len, StartLoc, LParenLoc, EndLoc);
1461 /// \brief Build a new OpenMP 'collapse' clause.
1463 /// By default, performs semantic analysis to build the new OpenMP clause.
1464 /// Subclasses may override this routine to provide different behavior.
1465 OMPClause *RebuildOMPCollapseClause(Expr *Num, SourceLocation StartLoc,
1466 SourceLocation LParenLoc,
1467 SourceLocation EndLoc) {
1468 return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc,
1472 /// \brief Build a new OpenMP 'default' clause.
1474 /// By default, performs semantic analysis to build the new OpenMP clause.
1475 /// Subclasses may override this routine to provide different behavior.
1476 OMPClause *RebuildOMPDefaultClause(OpenMPDefaultClauseKind Kind,
1477 SourceLocation KindKwLoc,
1478 SourceLocation StartLoc,
1479 SourceLocation LParenLoc,
1480 SourceLocation EndLoc) {
1481 return getSema().ActOnOpenMPDefaultClause(Kind, KindKwLoc,
1482 StartLoc, LParenLoc, EndLoc);
1485 /// \brief Build a new OpenMP 'proc_bind' clause.
1487 /// By default, performs semantic analysis to build the new OpenMP clause.
1488 /// Subclasses may override this routine to provide different behavior.
1489 OMPClause *RebuildOMPProcBindClause(OpenMPProcBindClauseKind Kind,
1490 SourceLocation KindKwLoc,
1491 SourceLocation StartLoc,
1492 SourceLocation LParenLoc,
1493 SourceLocation EndLoc) {
1494 return getSema().ActOnOpenMPProcBindClause(Kind, KindKwLoc,
1495 StartLoc, LParenLoc, EndLoc);
1498 /// \brief Build a new OpenMP 'schedule' clause.
1500 /// By default, performs semantic analysis to build the new OpenMP clause.
1501 /// Subclasses may override this routine to provide different behavior.
1502 OMPClause *RebuildOMPScheduleClause(
1503 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
1504 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
1505 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
1506 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) {
1507 return getSema().ActOnOpenMPScheduleClause(
1508 M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
1512 /// \brief Build a new OpenMP 'ordered' clause.
1514 /// By default, performs semantic analysis to build the new OpenMP clause.
1515 /// Subclasses may override this routine to provide different behavior.
1516 OMPClause *RebuildOMPOrderedClause(SourceLocation StartLoc,
1517 SourceLocation EndLoc,
1518 SourceLocation LParenLoc, Expr *Num) {
1519 return getSema().ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Num);
1522 /// \brief Build a new OpenMP 'private' clause.
1524 /// By default, performs semantic analysis to build the new OpenMP clause.
1525 /// Subclasses may override this routine to provide different behavior.
1526 OMPClause *RebuildOMPPrivateClause(ArrayRef<Expr *> VarList,
1527 SourceLocation StartLoc,
1528 SourceLocation LParenLoc,
1529 SourceLocation EndLoc) {
1530 return getSema().ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc,
1534 /// \brief Build a new OpenMP 'firstprivate' clause.
1536 /// By default, performs semantic analysis to build the new OpenMP clause.
1537 /// Subclasses may override this routine to provide different behavior.
1538 OMPClause *RebuildOMPFirstprivateClause(ArrayRef<Expr *> VarList,
1539 SourceLocation StartLoc,
1540 SourceLocation LParenLoc,
1541 SourceLocation EndLoc) {
1542 return getSema().ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc,
1546 /// \brief Build a new OpenMP 'lastprivate' clause.
1548 /// By default, performs semantic analysis to build the new OpenMP clause.
1549 /// Subclasses may override this routine to provide different behavior.
1550 OMPClause *RebuildOMPLastprivateClause(ArrayRef<Expr *> VarList,
1551 SourceLocation StartLoc,
1552 SourceLocation LParenLoc,
1553 SourceLocation EndLoc) {
1554 return getSema().ActOnOpenMPLastprivateClause(VarList, StartLoc, LParenLoc,
1558 /// \brief Build a new OpenMP 'shared' clause.
1560 /// By default, performs semantic analysis to build the new OpenMP clause.
1561 /// Subclasses may override this routine to provide different behavior.
1562 OMPClause *RebuildOMPSharedClause(ArrayRef<Expr *> VarList,
1563 SourceLocation StartLoc,
1564 SourceLocation LParenLoc,
1565 SourceLocation EndLoc) {
1566 return getSema().ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc,
1570 /// \brief Build a new OpenMP 'reduction' clause.
1572 /// By default, performs semantic analysis to build the new statement.
1573 /// Subclasses may override this routine to provide different behavior.
1574 OMPClause *RebuildOMPReductionClause(ArrayRef<Expr *> VarList,
1575 SourceLocation StartLoc,
1576 SourceLocation LParenLoc,
1577 SourceLocation ColonLoc,
1578 SourceLocation EndLoc,
1579 CXXScopeSpec &ReductionIdScopeSpec,
1580 const DeclarationNameInfo &ReductionId,
1581 ArrayRef<Expr *> UnresolvedReductions) {
1582 return getSema().ActOnOpenMPReductionClause(
1583 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1584 ReductionId, UnresolvedReductions);
1587 /// \brief Build a new OpenMP 'linear' clause.
1589 /// By default, performs semantic analysis to build the new OpenMP clause.
1590 /// Subclasses may override this routine to provide different behavior.
1591 OMPClause *RebuildOMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
1592 SourceLocation StartLoc,
1593 SourceLocation LParenLoc,
1594 OpenMPLinearClauseKind Modifier,
1595 SourceLocation ModifierLoc,
1596 SourceLocation ColonLoc,
1597 SourceLocation EndLoc) {
1598 return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc,
1599 Modifier, ModifierLoc, ColonLoc,
1603 /// \brief Build a new OpenMP 'aligned' clause.
1605 /// By default, performs semantic analysis to build the new OpenMP clause.
1606 /// Subclasses may override this routine to provide different behavior.
1607 OMPClause *RebuildOMPAlignedClause(ArrayRef<Expr *> VarList, Expr *Alignment,
1608 SourceLocation StartLoc,
1609 SourceLocation LParenLoc,
1610 SourceLocation ColonLoc,
1611 SourceLocation EndLoc) {
1612 return getSema().ActOnOpenMPAlignedClause(VarList, Alignment, StartLoc,
1613 LParenLoc, ColonLoc, EndLoc);
1616 /// \brief Build a new OpenMP 'copyin' clause.
1618 /// By default, performs semantic analysis to build the new OpenMP clause.
1619 /// Subclasses may override this routine to provide different behavior.
1620 OMPClause *RebuildOMPCopyinClause(ArrayRef<Expr *> VarList,
1621 SourceLocation StartLoc,
1622 SourceLocation LParenLoc,
1623 SourceLocation EndLoc) {
1624 return getSema().ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc,
1628 /// \brief Build a new OpenMP 'copyprivate' clause.
1630 /// By default, performs semantic analysis to build the new OpenMP clause.
1631 /// Subclasses may override this routine to provide different behavior.
1632 OMPClause *RebuildOMPCopyprivateClause(ArrayRef<Expr *> VarList,
1633 SourceLocation StartLoc,
1634 SourceLocation LParenLoc,
1635 SourceLocation EndLoc) {
1636 return getSema().ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc,
1640 /// \brief Build a new OpenMP 'flush' pseudo clause.
1642 /// By default, performs semantic analysis to build the new OpenMP clause.
1643 /// Subclasses may override this routine to provide different behavior.
1644 OMPClause *RebuildOMPFlushClause(ArrayRef<Expr *> VarList,
1645 SourceLocation StartLoc,
1646 SourceLocation LParenLoc,
1647 SourceLocation EndLoc) {
1648 return getSema().ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc,
1652 /// \brief Build a new OpenMP 'depend' pseudo clause.
1654 /// By default, performs semantic analysis to build the new OpenMP clause.
1655 /// Subclasses may override this routine to provide different behavior.
1657 RebuildOMPDependClause(OpenMPDependClauseKind DepKind, SourceLocation DepLoc,
1658 SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
1659 SourceLocation StartLoc, SourceLocation LParenLoc,
1660 SourceLocation EndLoc) {
1661 return getSema().ActOnOpenMPDependClause(DepKind, DepLoc, ColonLoc, VarList,
1662 StartLoc, LParenLoc, EndLoc);
1665 /// \brief Build a new OpenMP 'device' clause.
1667 /// By default, performs semantic analysis to build the new statement.
1668 /// Subclasses may override this routine to provide different behavior.
1669 OMPClause *RebuildOMPDeviceClause(Expr *Device, SourceLocation StartLoc,
1670 SourceLocation LParenLoc,
1671 SourceLocation EndLoc) {
1672 return getSema().ActOnOpenMPDeviceClause(Device, StartLoc, LParenLoc,
1676 /// \brief Build a new OpenMP 'map' clause.
1678 /// By default, performs semantic analysis to build the new OpenMP clause.
1679 /// Subclasses may override this routine to provide different behavior.
1681 RebuildOMPMapClause(OpenMPMapClauseKind MapTypeModifier,
1682 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
1683 SourceLocation MapLoc, SourceLocation ColonLoc,
1684 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
1685 SourceLocation LParenLoc, SourceLocation EndLoc) {
1686 return getSema().ActOnOpenMPMapClause(MapTypeModifier, MapType,
1687 IsMapTypeImplicit, MapLoc, ColonLoc,
1688 VarList, StartLoc, LParenLoc, EndLoc);
1691 /// \brief Build a new OpenMP 'num_teams' clause.
1693 /// By default, performs semantic analysis to build the new statement.
1694 /// Subclasses may override this routine to provide different behavior.
1695 OMPClause *RebuildOMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc,
1696 SourceLocation LParenLoc,
1697 SourceLocation EndLoc) {
1698 return getSema().ActOnOpenMPNumTeamsClause(NumTeams, StartLoc, LParenLoc,
1702 /// \brief Build a new OpenMP 'thread_limit' clause.
1704 /// By default, performs semantic analysis to build the new statement.
1705 /// Subclasses may override this routine to provide different behavior.
1706 OMPClause *RebuildOMPThreadLimitClause(Expr *ThreadLimit,
1707 SourceLocation StartLoc,
1708 SourceLocation LParenLoc,
1709 SourceLocation EndLoc) {
1710 return getSema().ActOnOpenMPThreadLimitClause(ThreadLimit, StartLoc,
1714 /// \brief Build a new OpenMP 'priority' clause.
1716 /// By default, performs semantic analysis to build the new statement.
1717 /// Subclasses may override this routine to provide different behavior.
1718 OMPClause *RebuildOMPPriorityClause(Expr *Priority, SourceLocation StartLoc,
1719 SourceLocation LParenLoc,
1720 SourceLocation EndLoc) {
1721 return getSema().ActOnOpenMPPriorityClause(Priority, StartLoc, LParenLoc,
1725 /// \brief Build a new OpenMP 'grainsize' clause.
1727 /// By default, performs semantic analysis to build the new statement.
1728 /// Subclasses may override this routine to provide different behavior.
1729 OMPClause *RebuildOMPGrainsizeClause(Expr *Grainsize, SourceLocation StartLoc,
1730 SourceLocation LParenLoc,
1731 SourceLocation EndLoc) {
1732 return getSema().ActOnOpenMPGrainsizeClause(Grainsize, StartLoc, LParenLoc,
1736 /// \brief Build a new OpenMP 'num_tasks' clause.
1738 /// By default, performs semantic analysis to build the new statement.
1739 /// Subclasses may override this routine to provide different behavior.
1740 OMPClause *RebuildOMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc,
1741 SourceLocation LParenLoc,
1742 SourceLocation EndLoc) {
1743 return getSema().ActOnOpenMPNumTasksClause(NumTasks, StartLoc, LParenLoc,
1747 /// \brief Build a new OpenMP 'hint' clause.
1749 /// By default, performs semantic analysis to build the new statement.
1750 /// Subclasses may override this routine to provide different behavior.
1751 OMPClause *RebuildOMPHintClause(Expr *Hint, SourceLocation StartLoc,
1752 SourceLocation LParenLoc,
1753 SourceLocation EndLoc) {
1754 return getSema().ActOnOpenMPHintClause(Hint, StartLoc, LParenLoc, EndLoc);
1757 /// \brief Build a new OpenMP 'dist_schedule' clause.
1759 /// By default, performs semantic analysis to build the new OpenMP clause.
1760 /// Subclasses may override this routine to provide different behavior.
1762 RebuildOMPDistScheduleClause(OpenMPDistScheduleClauseKind Kind,
1763 Expr *ChunkSize, SourceLocation StartLoc,
1764 SourceLocation LParenLoc, SourceLocation KindLoc,
1765 SourceLocation CommaLoc, SourceLocation EndLoc) {
1766 return getSema().ActOnOpenMPDistScheduleClause(
1767 Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
1770 /// \brief Build a new OpenMP 'to' clause.
1772 /// By default, performs semantic analysis to build the new statement.
1773 /// Subclasses may override this routine to provide different behavior.
1774 OMPClause *RebuildOMPToClause(ArrayRef<Expr *> VarList,
1775 SourceLocation StartLoc,
1776 SourceLocation LParenLoc,
1777 SourceLocation EndLoc) {
1778 return getSema().ActOnOpenMPToClause(VarList, StartLoc, LParenLoc, EndLoc);
1781 /// \brief Build a new OpenMP 'from' clause.
1783 /// By default, performs semantic analysis to build the new statement.
1784 /// Subclasses may override this routine to provide different behavior.
1785 OMPClause *RebuildOMPFromClause(ArrayRef<Expr *> VarList,
1786 SourceLocation StartLoc,
1787 SourceLocation LParenLoc,
1788 SourceLocation EndLoc) {
1789 return getSema().ActOnOpenMPFromClause(VarList, StartLoc, LParenLoc,
1793 /// Build a new OpenMP 'use_device_ptr' clause.
1795 /// By default, performs semantic analysis to build the new OpenMP clause.
1796 /// Subclasses may override this routine to provide different behavior.
1797 OMPClause *RebuildOMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
1798 SourceLocation StartLoc,
1799 SourceLocation LParenLoc,
1800 SourceLocation EndLoc) {
1801 return getSema().ActOnOpenMPUseDevicePtrClause(VarList, StartLoc, LParenLoc,
1805 /// Build a new OpenMP 'is_device_ptr' clause.
1807 /// By default, performs semantic analysis to build the new OpenMP clause.
1808 /// Subclasses may override this routine to provide different behavior.
1809 OMPClause *RebuildOMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
1810 SourceLocation StartLoc,
1811 SourceLocation LParenLoc,
1812 SourceLocation EndLoc) {
1813 return getSema().ActOnOpenMPIsDevicePtrClause(VarList, StartLoc, LParenLoc,
1817 /// \brief Rebuild the operand to an Objective-C \@synchronized statement.
1819 /// By default, performs semantic analysis to build the new statement.
1820 /// Subclasses may override this routine to provide different behavior.
1821 ExprResult RebuildObjCAtSynchronizedOperand(SourceLocation atLoc,
1823 return getSema().ActOnObjCAtSynchronizedOperand(atLoc, object);
1826 /// \brief Build a new Objective-C \@synchronized statement.
1828 /// By default, performs semantic analysis to build the new statement.
1829 /// Subclasses may override this routine to provide different behavior.
1830 StmtResult RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc,
1831 Expr *Object, Stmt *Body) {
1832 return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body);
1835 /// \brief Build a new Objective-C \@autoreleasepool statement.
1837 /// By default, performs semantic analysis to build the new statement.
1838 /// Subclasses may override this routine to provide different behavior.
1839 StmtResult RebuildObjCAutoreleasePoolStmt(SourceLocation AtLoc,
1841 return getSema().ActOnObjCAutoreleasePoolStmt(AtLoc, Body);
1844 /// \brief Build a new Objective-C fast enumeration statement.
1846 /// By default, performs semantic analysis to build the new statement.
1847 /// Subclasses may override this routine to provide different behavior.
1848 StmtResult RebuildObjCForCollectionStmt(SourceLocation ForLoc,
1851 SourceLocation RParenLoc,
1853 StmtResult ForEachStmt = getSema().ActOnObjCForCollectionStmt(ForLoc,
1857 if (ForEachStmt.isInvalid())
1860 return getSema().FinishObjCForCollectionStmt(ForEachStmt.get(), Body);
1863 /// \brief Build a new C++ exception declaration.
1865 /// By default, performs semantic analysis to build the new decaration.
1866 /// Subclasses may override this routine to provide different behavior.
1867 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
1868 TypeSourceInfo *Declarator,
1869 SourceLocation StartLoc,
1870 SourceLocation IdLoc,
1871 IdentifierInfo *Id) {
1872 VarDecl *Var = getSema().BuildExceptionDeclaration(nullptr, Declarator,
1873 StartLoc, IdLoc, Id);
1875 getSema().CurContext->addDecl(Var);
1879 /// \brief Build a new C++ catch statement.
1881 /// By default, performs semantic analysis to build the new statement.
1882 /// Subclasses may override this routine to provide different behavior.
1883 StmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc,
1884 VarDecl *ExceptionDecl,
1886 return Owned(new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl,
1890 /// \brief Build a new C++ try statement.
1892 /// By default, performs semantic analysis to build the new statement.
1893 /// Subclasses may override this routine to provide different behavior.
1894 StmtResult RebuildCXXTryStmt(SourceLocation TryLoc, Stmt *TryBlock,
1895 ArrayRef<Stmt *> Handlers) {
1896 return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers);
1899 /// \brief Build a new C++0x range-based for statement.
1901 /// By default, performs semantic analysis to build the new statement.
1902 /// Subclasses may override this routine to provide different behavior.
1903 StmtResult RebuildCXXForRangeStmt(SourceLocation ForLoc,
1904 SourceLocation CoawaitLoc,
1905 SourceLocation ColonLoc,
1906 Stmt *Range, Stmt *Begin, Stmt *End,
1907 Expr *Cond, Expr *Inc,
1909 SourceLocation RParenLoc) {
1910 // If we've just learned that the range is actually an Objective-C
1911 // collection, treat this as an Objective-C fast enumeration loop.
1912 if (DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) {
1913 if (RangeStmt->isSingleDecl()) {
1914 if (VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
1915 if (RangeVar->isInvalidDecl())
1918 Expr *RangeExpr = RangeVar->getInit();
1919 if (!RangeExpr->isTypeDependent() &&
1920 RangeExpr->getType()->isObjCObjectPointerType())
1921 return getSema().ActOnObjCForCollectionStmt(ForLoc, LoopVar, RangeExpr,
1927 return getSema().BuildCXXForRangeStmt(ForLoc, CoawaitLoc, ColonLoc,
1929 Cond, Inc, LoopVar, RParenLoc,
1930 Sema::BFRK_Rebuild);
1933 /// \brief Build a new C++0x range-based for statement.
1935 /// By default, performs semantic analysis to build the new statement.
1936 /// Subclasses may override this routine to provide different behavior.
1937 StmtResult RebuildMSDependentExistsStmt(SourceLocation KeywordLoc,
1939 NestedNameSpecifierLoc QualifierLoc,
1940 DeclarationNameInfo NameInfo,
1942 return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
1943 QualifierLoc, NameInfo, Nested);
1946 /// \brief Attach body to a C++0x range-based for statement.
1948 /// By default, performs semantic analysis to finish the new statement.
1949 /// Subclasses may override this routine to provide different behavior.
1950 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body) {
1951 return getSema().FinishCXXForRangeStmt(ForRange, Body);
1954 StmtResult RebuildSEHTryStmt(bool IsCXXTry, SourceLocation TryLoc,
1955 Stmt *TryBlock, Stmt *Handler) {
1956 return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler);
1959 StmtResult RebuildSEHExceptStmt(SourceLocation Loc, Expr *FilterExpr,
1961 return getSema().ActOnSEHExceptBlock(Loc, FilterExpr, Block);
1964 StmtResult RebuildSEHFinallyStmt(SourceLocation Loc, Stmt *Block) {
1965 return SEHFinallyStmt::Create(getSema().getASTContext(), Loc, Block);
1968 /// \brief Build a new predefined expression.
1970 /// By default, performs semantic analysis to build the new expression.
1971 /// Subclasses may override this routine to provide different behavior.
1972 ExprResult RebuildPredefinedExpr(SourceLocation Loc,
1973 PredefinedExpr::IdentType IT) {
1974 return getSema().BuildPredefinedExpr(Loc, IT);
1977 /// \brief Build a new expression that references a declaration.
1979 /// By default, performs semantic analysis to build the new expression.
1980 /// Subclasses may override this routine to provide different behavior.
1981 ExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS,
1984 return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
1988 /// \brief Build a new expression that references a declaration.
1990 /// By default, performs semantic analysis to build the new expression.
1991 /// Subclasses may override this routine to provide different behavior.
1992 ExprResult RebuildDeclRefExpr(NestedNameSpecifierLoc QualifierLoc,
1994 const DeclarationNameInfo &NameInfo,
1995 TemplateArgumentListInfo *TemplateArgs) {
1997 SS.Adopt(QualifierLoc);
1999 // FIXME: loses template args.
2001 return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD);
2004 /// \brief Build a new expression in parentheses.
2006 /// By default, performs semantic analysis to build the new expression.
2007 /// Subclasses may override this routine to provide different behavior.
2008 ExprResult RebuildParenExpr(Expr *SubExpr, SourceLocation LParen,
2009 SourceLocation RParen) {
2010 return getSema().ActOnParenExpr(LParen, RParen, SubExpr);
2013 /// \brief Build a new pseudo-destructor expression.
2015 /// By default, performs semantic analysis to build the new expression.
2016 /// Subclasses may override this routine to provide different behavior.
2017 ExprResult RebuildCXXPseudoDestructorExpr(Expr *Base,
2018 SourceLocation OperatorLoc,
2021 TypeSourceInfo *ScopeType,
2022 SourceLocation CCLoc,
2023 SourceLocation TildeLoc,
2024 PseudoDestructorTypeStorage Destroyed);
2026 /// \brief Build a new unary operator expression.
2028 /// By default, performs semantic analysis to build the new expression.
2029 /// Subclasses may override this routine to provide different behavior.
2030 ExprResult RebuildUnaryOperator(SourceLocation OpLoc,
2031 UnaryOperatorKind Opc,
2033 return getSema().BuildUnaryOp(/*Scope=*/nullptr, OpLoc, Opc, SubExpr);
2036 /// \brief Build a new builtin offsetof expression.
2038 /// By default, performs semantic analysis to build the new expression.
2039 /// Subclasses may override this routine to provide different behavior.
2040 ExprResult RebuildOffsetOfExpr(SourceLocation OperatorLoc,
2041 TypeSourceInfo *Type,
2042 ArrayRef<Sema::OffsetOfComponent> Components,
2043 SourceLocation RParenLoc) {
2044 return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
2048 /// \brief Build a new sizeof, alignof or vec_step expression with a
2051 /// By default, performs semantic analysis to build the new expression.
2052 /// Subclasses may override this routine to provide different behavior.
2053 ExprResult RebuildUnaryExprOrTypeTrait(TypeSourceInfo *TInfo,
2054 SourceLocation OpLoc,
2055 UnaryExprOrTypeTrait ExprKind,
2057 return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R);
2060 /// \brief Build a new sizeof, alignof or vec step expression with an
2061 /// expression argument.
2063 /// By default, performs semantic analysis to build the new expression.
2064 /// Subclasses may override this routine to provide different behavior.
2065 ExprResult RebuildUnaryExprOrTypeTrait(Expr *SubExpr, SourceLocation OpLoc,
2066 UnaryExprOrTypeTrait ExprKind,
2069 = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind);
2070 if (Result.isInvalid())
2076 /// \brief Build a new array subscript expression.
2078 /// By default, performs semantic analysis to build the new expression.
2079 /// Subclasses may override this routine to provide different behavior.
2080 ExprResult RebuildArraySubscriptExpr(Expr *LHS,
2081 SourceLocation LBracketLoc,
2083 SourceLocation RBracketLoc) {
2084 return getSema().ActOnArraySubscriptExpr(/*Scope=*/nullptr, LHS,
2089 /// \brief Build a new array section expression.
2091 /// By default, performs semantic analysis to build the new expression.
2092 /// Subclasses may override this routine to provide different behavior.
2093 ExprResult RebuildOMPArraySectionExpr(Expr *Base, SourceLocation LBracketLoc,
2095 SourceLocation ColonLoc, Expr *Length,
2096 SourceLocation RBracketLoc) {
2097 return getSema().ActOnOMPArraySectionExpr(Base, LBracketLoc, LowerBound,
2098 ColonLoc, Length, RBracketLoc);
2101 /// \brief Build a new call expression.
2103 /// By default, performs semantic analysis to build the new expression.
2104 /// Subclasses may override this routine to provide different behavior.
2105 ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc,
2107 SourceLocation RParenLoc,
2108 Expr *ExecConfig = nullptr) {
2109 return getSema().ActOnCallExpr(/*Scope=*/nullptr, Callee, LParenLoc,
2110 Args, RParenLoc, ExecConfig);
2113 /// \brief Build a new member access expression.
2115 /// By default, performs semantic analysis to build the new expression.
2116 /// Subclasses may override this routine to provide different behavior.
2117 ExprResult RebuildMemberExpr(Expr *Base, SourceLocation OpLoc,
2119 NestedNameSpecifierLoc QualifierLoc,
2120 SourceLocation TemplateKWLoc,
2121 const DeclarationNameInfo &MemberNameInfo,
2123 NamedDecl *FoundDecl,
2124 const TemplateArgumentListInfo *ExplicitTemplateArgs,
2125 NamedDecl *FirstQualifierInScope) {
2126 ExprResult BaseResult = getSema().PerformMemberExprBaseConversion(Base,
2128 if (!Member->getDeclName()) {
2129 // We have a reference to an unnamed field. This is always the
2130 // base of an anonymous struct/union member access, i.e. the
2131 // field is always of record type.
2132 assert(!QualifierLoc && "Can't have an unnamed field with a qualifier!");
2133 assert(Member->getType()->isRecordType() &&
2134 "unnamed member not of record type?");
2137 getSema().PerformObjectMemberConversion(BaseResult.get(),
2138 QualifierLoc.getNestedNameSpecifier(),
2140 if (BaseResult.isInvalid())
2142 Base = BaseResult.get();
2143 ExprValueKind VK = isArrow ? VK_LValue : Base->getValueKind();
2144 MemberExpr *ME = new (getSema().Context)
2145 MemberExpr(Base, isArrow, OpLoc, Member, MemberNameInfo,
2146 cast<FieldDecl>(Member)->getType(), VK, OK_Ordinary);
2151 SS.Adopt(QualifierLoc);
2153 Base = BaseResult.get();
2154 QualType BaseType = Base->getType();
2156 // FIXME: this involves duplicating earlier analysis in a lot of
2157 // cases; we should avoid this when possible.
2158 LookupResult R(getSema(), MemberNameInfo, Sema::LookupMemberName);
2159 R.addDecl(FoundDecl);
2162 return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow,
2164 FirstQualifierInScope,
2165 R, ExplicitTemplateArgs,
2169 /// \brief Build a new binary operator expression.
2171 /// By default, performs semantic analysis to build the new expression.
2172 /// Subclasses may override this routine to provide different behavior.
2173 ExprResult RebuildBinaryOperator(SourceLocation OpLoc,
2174 BinaryOperatorKind Opc,
2175 Expr *LHS, Expr *RHS) {
2176 return getSema().BuildBinOp(/*Scope=*/nullptr, OpLoc, Opc, LHS, RHS);
2179 /// \brief Build a new conditional operator expression.
2181 /// By default, performs semantic analysis to build the new expression.
2182 /// Subclasses may override this routine to provide different behavior.
2183 ExprResult RebuildConditionalOperator(Expr *Cond,
2184 SourceLocation QuestionLoc,
2186 SourceLocation ColonLoc,
2188 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond,
2192 /// \brief Build a new C-style cast expression.
2194 /// By default, performs semantic analysis to build the new expression.
2195 /// Subclasses may override this routine to provide different behavior.
2196 ExprResult RebuildCStyleCastExpr(SourceLocation LParenLoc,
2197 TypeSourceInfo *TInfo,
2198 SourceLocation RParenLoc,
2200 return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
2204 /// \brief Build a new compound literal expression.
2206 /// By default, performs semantic analysis to build the new expression.
2207 /// Subclasses may override this routine to provide different behavior.
2208 ExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc,
2209 TypeSourceInfo *TInfo,
2210 SourceLocation RParenLoc,
2212 return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
2216 /// \brief Build a new extended vector element access expression.
2218 /// By default, performs semantic analysis to build the new expression.
2219 /// Subclasses may override this routine to provide different behavior.
2220 ExprResult RebuildExtVectorElementExpr(Expr *Base,
2221 SourceLocation OpLoc,
2222 SourceLocation AccessorLoc,
2223 IdentifierInfo &Accessor) {
2226 DeclarationNameInfo NameInfo(&Accessor, AccessorLoc);
2227 return getSema().BuildMemberReferenceExpr(Base, Base->getType(),
2228 OpLoc, /*IsArrow*/ false,
2229 SS, SourceLocation(),
2230 /*FirstQualifierInScope*/ nullptr,
2232 /* TemplateArgs */ nullptr,
2236 /// \brief Build a new initializer list expression.
2238 /// By default, performs semantic analysis to build the new expression.
2239 /// Subclasses may override this routine to provide different behavior.
2240 ExprResult RebuildInitList(SourceLocation LBraceLoc,
2242 SourceLocation RBraceLoc,
2243 QualType ResultTy) {
2245 = SemaRef.ActOnInitList(LBraceLoc, Inits, RBraceLoc);
2246 if (Result.isInvalid() || ResultTy->isDependentType())
2249 // Patch in the result type we were given, which may have been computed
2250 // when the initial InitListExpr was built.
2251 InitListExpr *ILE = cast<InitListExpr>((Expr *)Result.get());
2252 ILE->setType(ResultTy);
2256 /// \brief Build a new designated initializer expression.
2258 /// By default, performs semantic analysis to build the new expression.
2259 /// Subclasses may override this routine to provide different behavior.
2260 ExprResult RebuildDesignatedInitExpr(Designation &Desig,
2261 MultiExprArg ArrayExprs,
2262 SourceLocation EqualOrColonLoc,
2266 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
2268 if (Result.isInvalid())
2274 /// \brief Build a new value-initialized expression.
2276 /// By default, builds the implicit value initialization without performing
2277 /// any semantic analysis. Subclasses may override this routine to provide
2278 /// different behavior.
2279 ExprResult RebuildImplicitValueInitExpr(QualType T) {
2280 return new (SemaRef.Context) ImplicitValueInitExpr(T);
2283 /// \brief Build a new \c va_arg expression.
2285 /// By default, performs semantic analysis to build the new expression.
2286 /// Subclasses may override this routine to provide different behavior.
2287 ExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc,
2288 Expr *SubExpr, TypeSourceInfo *TInfo,
2289 SourceLocation RParenLoc) {
2290 return getSema().BuildVAArgExpr(BuiltinLoc,
2295 /// \brief Build a new expression list in parentheses.
2297 /// By default, performs semantic analysis to build the new expression.
2298 /// Subclasses may override this routine to provide different behavior.
2299 ExprResult RebuildParenListExpr(SourceLocation LParenLoc,
2300 MultiExprArg SubExprs,
2301 SourceLocation RParenLoc) {
2302 return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs);
2305 /// \brief Build a new address-of-label expression.
2307 /// By default, performs semantic analysis, using the name of the label
2308 /// rather than attempting to map the label statement itself.
2309 /// Subclasses may override this routine to provide different behavior.
2310 ExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc,
2311 SourceLocation LabelLoc, LabelDecl *Label) {
2312 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label);
2315 /// \brief Build a new GNU statement expression.
2317 /// By default, performs semantic analysis to build the new expression.
2318 /// Subclasses may override this routine to provide different behavior.
2319 ExprResult RebuildStmtExpr(SourceLocation LParenLoc,
2321 SourceLocation RParenLoc) {
2322 return getSema().ActOnStmtExpr(LParenLoc, SubStmt, RParenLoc);
2325 /// \brief Build a new __builtin_choose_expr expression.
2327 /// By default, performs semantic analysis to build the new expression.
2328 /// Subclasses may override this routine to provide different behavior.
2329 ExprResult RebuildChooseExpr(SourceLocation BuiltinLoc,
2330 Expr *Cond, Expr *LHS, Expr *RHS,
2331 SourceLocation RParenLoc) {
2332 return SemaRef.ActOnChooseExpr(BuiltinLoc,
2337 /// \brief Build a new generic selection expression.
2339 /// By default, performs semantic analysis to build the new expression.
2340 /// Subclasses may override this routine to provide different behavior.
2341 ExprResult RebuildGenericSelectionExpr(SourceLocation KeyLoc,
2342 SourceLocation DefaultLoc,
2343 SourceLocation RParenLoc,
2344 Expr *ControllingExpr,
2345 ArrayRef<TypeSourceInfo *> Types,
2346 ArrayRef<Expr *> Exprs) {
2347 return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
2348 ControllingExpr, Types, Exprs);
2351 /// \brief Build a new overloaded operator call expression.
2353 /// By default, performs semantic analysis to build the new expression.
2354 /// The semantic analysis provides the behavior of template instantiation,
2355 /// copying with transformations that turn what looks like an overloaded
2356 /// operator call into a use of a builtin operator, performing
2357 /// argument-dependent lookup, etc. Subclasses may override this routine to
2358 /// provide different behavior.
2359 ExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
2360 SourceLocation OpLoc,
2365 /// \brief Build a new C++ "named" cast expression, such as static_cast or
2366 /// reinterpret_cast.
2368 /// By default, this routine dispatches to one of the more-specific routines
2369 /// for a particular named case, e.g., RebuildCXXStaticCastExpr().
2370 /// Subclasses may override this routine to provide different behavior.
2371 ExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc,
2372 Stmt::StmtClass Class,
2373 SourceLocation LAngleLoc,
2374 TypeSourceInfo *TInfo,
2375 SourceLocation RAngleLoc,
2376 SourceLocation LParenLoc,
2378 SourceLocation RParenLoc) {
2380 case Stmt::CXXStaticCastExprClass:
2381 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
2382 RAngleLoc, LParenLoc,
2383 SubExpr, RParenLoc);
2385 case Stmt::CXXDynamicCastExprClass:
2386 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
2387 RAngleLoc, LParenLoc,
2388 SubExpr, RParenLoc);
2390 case Stmt::CXXReinterpretCastExprClass:
2391 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
2392 RAngleLoc, LParenLoc,
2396 case Stmt::CXXConstCastExprClass:
2397 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
2398 RAngleLoc, LParenLoc,
2399 SubExpr, RParenLoc);
2402 llvm_unreachable("Invalid C++ named cast");
2406 /// \brief Build a new C++ static_cast expression.
2408 /// By default, performs semantic analysis to build the new expression.
2409 /// Subclasses may override this routine to provide different behavior.
2410 ExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc,
2411 SourceLocation LAngleLoc,
2412 TypeSourceInfo *TInfo,
2413 SourceLocation RAngleLoc,
2414 SourceLocation LParenLoc,
2416 SourceLocation RParenLoc) {
2417 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
2419 SourceRange(LAngleLoc, RAngleLoc),
2420 SourceRange(LParenLoc, RParenLoc));
2423 /// \brief Build a new C++ dynamic_cast expression.
2425 /// By default, performs semantic analysis to build the new expression.
2426 /// Subclasses may override this routine to provide different behavior.
2427 ExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc,
2428 SourceLocation LAngleLoc,
2429 TypeSourceInfo *TInfo,
2430 SourceLocation RAngleLoc,
2431 SourceLocation LParenLoc,
2433 SourceLocation RParenLoc) {
2434 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
2436 SourceRange(LAngleLoc, RAngleLoc),
2437 SourceRange(LParenLoc, RParenLoc));
2440 /// \brief Build a new C++ reinterpret_cast expression.
2442 /// By default, performs semantic analysis to build the new expression.
2443 /// Subclasses may override this routine to provide different behavior.
2444 ExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc,
2445 SourceLocation LAngleLoc,
2446 TypeSourceInfo *TInfo,
2447 SourceLocation RAngleLoc,
2448 SourceLocation LParenLoc,
2450 SourceLocation RParenLoc) {
2451 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
2453 SourceRange(LAngleLoc, RAngleLoc),
2454 SourceRange(LParenLoc, RParenLoc));
2457 /// \brief Build a new C++ const_cast expression.
2459 /// By default, performs semantic analysis to build the new expression.
2460 /// Subclasses may override this routine to provide different behavior.
2461 ExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc,
2462 SourceLocation LAngleLoc,
2463 TypeSourceInfo *TInfo,
2464 SourceLocation RAngleLoc,
2465 SourceLocation LParenLoc,
2467 SourceLocation RParenLoc) {
2468 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
2470 SourceRange(LAngleLoc, RAngleLoc),
2471 SourceRange(LParenLoc, RParenLoc));
2474 /// \brief Build a new C++ functional-style cast expression.
2476 /// By default, performs semantic analysis to build the new expression.
2477 /// Subclasses may override this routine to provide different behavior.
2478 ExprResult RebuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo,
2479 SourceLocation LParenLoc,
2481 SourceLocation RParenLoc) {
2482 return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc,
2483 MultiExprArg(&Sub, 1),
2487 /// \brief Build a new C++ typeid(type) expression.
2489 /// By default, performs semantic analysis to build the new expression.
2490 /// Subclasses may override this routine to provide different behavior.
2491 ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
2492 SourceLocation TypeidLoc,
2493 TypeSourceInfo *Operand,
2494 SourceLocation RParenLoc) {
2495 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2500 /// \brief Build a new C++ typeid(expr) expression.
2502 /// By default, performs semantic analysis to build the new expression.
2503 /// Subclasses may override this routine to provide different behavior.
2504 ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
2505 SourceLocation TypeidLoc,
2507 SourceLocation RParenLoc) {
2508 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2512 /// \brief Build a new C++ __uuidof(type) expression.
2514 /// By default, performs semantic analysis to build the new expression.
2515 /// Subclasses may override this routine to provide different behavior.
2516 ExprResult RebuildCXXUuidofExpr(QualType TypeInfoType,
2517 SourceLocation TypeidLoc,
2518 TypeSourceInfo *Operand,
2519 SourceLocation RParenLoc) {
2520 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
2524 /// \brief Build a new C++ __uuidof(expr) expression.
2526 /// By default, performs semantic analysis to build the new expression.
2527 /// Subclasses may override this routine to provide different behavior.
2528 ExprResult RebuildCXXUuidofExpr(QualType TypeInfoType,
2529 SourceLocation TypeidLoc,
2531 SourceLocation RParenLoc) {
2532 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
2536 /// \brief Build a new C++ "this" expression.
2538 /// By default, builds a new "this" expression without performing any
2539 /// semantic analysis. Subclasses may override this routine to provide
2540 /// different behavior.
2541 ExprResult RebuildCXXThisExpr(SourceLocation ThisLoc,
2544 getSema().CheckCXXThisCapture(ThisLoc);
2545 return new (getSema().Context) CXXThisExpr(ThisLoc, ThisType, isImplicit);
2548 /// \brief Build a new C++ throw expression.
2550 /// By default, performs semantic analysis to build the new expression.
2551 /// Subclasses may override this routine to provide different behavior.
2552 ExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, Expr *Sub,
2553 bool IsThrownVariableInScope) {
2554 return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope);
2557 /// \brief Build a new C++ default-argument expression.
2559 /// By default, builds a new default-argument expression, which does not
2560 /// require any semantic analysis. Subclasses may override this routine to
2561 /// provide different behavior.
2562 ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc,
2563 ParmVarDecl *Param) {
2564 return CXXDefaultArgExpr::Create(getSema().Context, Loc, Param);
2567 /// \brief Build a new C++11 default-initialization expression.
2569 /// By default, builds a new default field initialization expression, which
2570 /// does not require any semantic analysis. Subclasses may override this
2571 /// routine to provide different behavior.
2572 ExprResult RebuildCXXDefaultInitExpr(SourceLocation Loc,
2574 return CXXDefaultInitExpr::Create(getSema().Context, Loc, Field);
2577 /// \brief Build a new C++ zero-initialization expression.
2579 /// By default, performs semantic analysis to build the new expression.
2580 /// Subclasses may override this routine to provide different behavior.
2581 ExprResult RebuildCXXScalarValueInitExpr(TypeSourceInfo *TSInfo,
2582 SourceLocation LParenLoc,
2583 SourceLocation RParenLoc) {
2584 return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc,
2588 /// \brief Build a new C++ "new" expression.
2590 /// By default, performs semantic analysis to build the new expression.
2591 /// Subclasses may override this routine to provide different behavior.
2592 ExprResult RebuildCXXNewExpr(SourceLocation StartLoc,
2594 SourceLocation PlacementLParen,
2595 MultiExprArg PlacementArgs,
2596 SourceLocation PlacementRParen,
2597 SourceRange TypeIdParens,
2598 QualType AllocatedType,
2599 TypeSourceInfo *AllocatedTypeInfo,
2601 SourceRange DirectInitRange,
2602 Expr *Initializer) {
2603 return getSema().BuildCXXNew(StartLoc, UseGlobal,
2615 /// \brief Build a new C++ "delete" expression.
2617 /// By default, performs semantic analysis to build the new expression.
2618 /// Subclasses may override this routine to provide different behavior.
2619 ExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc,
2620 bool IsGlobalDelete,
2623 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
2627 /// \brief Build a new type trait expression.
2629 /// By default, performs semantic analysis to build the new expression.
2630 /// Subclasses may override this routine to provide different behavior.
2631 ExprResult RebuildTypeTrait(TypeTrait Trait,
2632 SourceLocation StartLoc,
2633 ArrayRef<TypeSourceInfo *> Args,
2634 SourceLocation RParenLoc) {
2635 return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc);
2638 /// \brief Build a new array type trait expression.
2640 /// By default, performs semantic analysis to build the new expression.
2641 /// Subclasses may override this routine to provide different behavior.
2642 ExprResult RebuildArrayTypeTrait(ArrayTypeTrait Trait,
2643 SourceLocation StartLoc,
2644 TypeSourceInfo *TSInfo,
2646 SourceLocation RParenLoc) {
2647 return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc);
2650 /// \brief Build a new expression trait expression.
2652 /// By default, performs semantic analysis to build the new expression.
2653 /// Subclasses may override this routine to provide different behavior.
2654 ExprResult RebuildExpressionTrait(ExpressionTrait Trait,
2655 SourceLocation StartLoc,
2657 SourceLocation RParenLoc) {
2658 return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc);
2661 /// \brief Build a new (previously unresolved) declaration reference
2664 /// By default, performs semantic analysis to build the new expression.
2665 /// Subclasses may override this routine to provide different behavior.
2666 ExprResult RebuildDependentScopeDeclRefExpr(
2667 NestedNameSpecifierLoc QualifierLoc,
2668 SourceLocation TemplateKWLoc,
2669 const DeclarationNameInfo &NameInfo,
2670 const TemplateArgumentListInfo *TemplateArgs,
2671 bool IsAddressOfOperand,
2672 TypeSourceInfo **RecoveryTSI) {
2674 SS.Adopt(QualifierLoc);
2676 if (TemplateArgs || TemplateKWLoc.isValid())
2677 return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc, NameInfo,
2680 return getSema().BuildQualifiedDeclarationNameExpr(
2681 SS, NameInfo, IsAddressOfOperand, /*S*/nullptr, RecoveryTSI);
2684 /// \brief Build a new template-id expression.
2686 /// By default, performs semantic analysis to build the new expression.
2687 /// Subclasses may override this routine to provide different behavior.
2688 ExprResult RebuildTemplateIdExpr(const CXXScopeSpec &SS,
2689 SourceLocation TemplateKWLoc,
2692 const TemplateArgumentListInfo *TemplateArgs) {
2693 return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL,
2697 /// \brief Build a new object-construction expression.
2699 /// By default, performs semantic analysis to build the new expression.
2700 /// Subclasses may override this routine to provide different behavior.
2701 ExprResult RebuildCXXConstructExpr(QualType T,
2703 CXXConstructorDecl *Constructor,
2706 bool HadMultipleCandidates,
2707 bool ListInitialization,
2708 bool StdInitListInitialization,
2709 bool RequiresZeroInit,
2710 CXXConstructExpr::ConstructionKind ConstructKind,
2711 SourceRange ParenRange) {
2712 SmallVector<Expr*, 8> ConvertedArgs;
2713 if (getSema().CompleteConstructorCall(Constructor, Args, Loc,
2717 return getSema().BuildCXXConstructExpr(Loc, T, Constructor,
2720 HadMultipleCandidates,
2722 StdInitListInitialization,
2723 RequiresZeroInit, ConstructKind,
2727 /// \brief Build a new implicit construction via inherited constructor
2729 ExprResult RebuildCXXInheritedCtorInitExpr(QualType T, SourceLocation Loc,
2730 CXXConstructorDecl *Constructor,
2731 bool ConstructsVBase,
2732 bool InheritedFromVBase) {
2733 return new (getSema().Context) CXXInheritedCtorInitExpr(
2734 Loc, T, Constructor, ConstructsVBase, InheritedFromVBase);
2737 /// \brief Build a new object-construction expression.
2739 /// By default, performs semantic analysis to build the new expression.
2740 /// Subclasses may override this routine to provide different behavior.
2741 ExprResult RebuildCXXTemporaryObjectExpr(TypeSourceInfo *TSInfo,
2742 SourceLocation LParenLoc,
2744 SourceLocation RParenLoc) {
2745 return getSema().BuildCXXTypeConstructExpr(TSInfo,
2751 /// \brief Build a new object-construction expression.
2753 /// By default, performs semantic analysis to build the new expression.
2754 /// Subclasses may override this routine to provide different behavior.
2755 ExprResult RebuildCXXUnresolvedConstructExpr(TypeSourceInfo *TSInfo,
2756 SourceLocation LParenLoc,
2758 SourceLocation RParenLoc) {
2759 return getSema().BuildCXXTypeConstructExpr(TSInfo,
2765 /// \brief Build a new member reference expression.
2767 /// By default, performs semantic analysis to build the new expression.
2768 /// Subclasses may override this routine to provide different behavior.
2769 ExprResult RebuildCXXDependentScopeMemberExpr(Expr *BaseE,
2772 SourceLocation OperatorLoc,
2773 NestedNameSpecifierLoc QualifierLoc,
2774 SourceLocation TemplateKWLoc,
2775 NamedDecl *FirstQualifierInScope,
2776 const DeclarationNameInfo &MemberNameInfo,
2777 const TemplateArgumentListInfo *TemplateArgs) {
2779 SS.Adopt(QualifierLoc);
2781 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
2782 OperatorLoc, IsArrow,
2784 FirstQualifierInScope,
2786 TemplateArgs, /*S*/nullptr);
2789 /// \brief Build a new member reference expression.
2791 /// By default, performs semantic analysis to build the new expression.
2792 /// Subclasses may override this routine to provide different behavior.
2793 ExprResult RebuildUnresolvedMemberExpr(Expr *BaseE, QualType BaseType,
2794 SourceLocation OperatorLoc,
2796 NestedNameSpecifierLoc QualifierLoc,
2797 SourceLocation TemplateKWLoc,
2798 NamedDecl *FirstQualifierInScope,
2800 const TemplateArgumentListInfo *TemplateArgs) {
2802 SS.Adopt(QualifierLoc);
2804 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
2805 OperatorLoc, IsArrow,
2807 FirstQualifierInScope,
2808 R, TemplateArgs, /*S*/nullptr);
2811 /// \brief Build a new noexcept expression.
2813 /// By default, performs semantic analysis to build the new expression.
2814 /// Subclasses may override this routine to provide different behavior.
2815 ExprResult RebuildCXXNoexceptExpr(SourceRange Range, Expr *Arg) {
2816 return SemaRef.BuildCXXNoexceptExpr(Range.getBegin(), Arg, Range.getEnd());
2819 /// \brief Build a new expression to compute the length of a parameter pack.
2820 ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc,
2822 SourceLocation PackLoc,
2823 SourceLocation RParenLoc,
2824 Optional<unsigned> Length,
2825 ArrayRef<TemplateArgument> PartialArgs) {
2826 return SizeOfPackExpr::Create(SemaRef.Context, OperatorLoc, Pack, PackLoc,
2827 RParenLoc, Length, PartialArgs);
2830 /// \brief Build a new Objective-C boxed expression.
2832 /// By default, performs semantic analysis to build the new expression.
2833 /// Subclasses may override this routine to provide different behavior.
2834 ExprResult RebuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) {
2835 return getSema().BuildObjCBoxedExpr(SR, ValueExpr);
2838 /// \brief Build a new Objective-C array literal.
2840 /// By default, performs semantic analysis to build the new expression.
2841 /// Subclasses may override this routine to provide different behavior.
2842 ExprResult RebuildObjCArrayLiteral(SourceRange Range,
2843 Expr **Elements, unsigned NumElements) {
2844 return getSema().BuildObjCArrayLiteral(Range,
2845 MultiExprArg(Elements, NumElements));
2848 ExprResult RebuildObjCSubscriptRefExpr(SourceLocation RB,
2849 Expr *Base, Expr *Key,
2850 ObjCMethodDecl *getterMethod,
2851 ObjCMethodDecl *setterMethod) {
2852 return getSema().BuildObjCSubscriptExpression(RB, Base, Key,
2853 getterMethod, setterMethod);
2856 /// \brief Build a new Objective-C dictionary literal.
2858 /// By default, performs semantic analysis to build the new expression.
2859 /// Subclasses may override this routine to provide different behavior.
2860 ExprResult RebuildObjCDictionaryLiteral(SourceRange Range,
2861 MutableArrayRef<ObjCDictionaryElement> Elements) {
2862 return getSema().BuildObjCDictionaryLiteral(Range, Elements);
2865 /// \brief Build a new Objective-C \@encode expression.
2867 /// By default, performs semantic analysis to build the new expression.
2868 /// Subclasses may override this routine to provide different behavior.
2869 ExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc,
2870 TypeSourceInfo *EncodeTypeInfo,
2871 SourceLocation RParenLoc) {
2872 return SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo, RParenLoc);
2875 /// \brief Build a new Objective-C class message.
2876 ExprResult RebuildObjCMessageExpr(TypeSourceInfo *ReceiverTypeInfo,
2878 ArrayRef<SourceLocation> SelectorLocs,
2879 ObjCMethodDecl *Method,
2880 SourceLocation LBracLoc,
2882 SourceLocation RBracLoc) {
2883 return SemaRef.BuildClassMessage(ReceiverTypeInfo,
2884 ReceiverTypeInfo->getType(),
2885 /*SuperLoc=*/SourceLocation(),
2886 Sel, Method, LBracLoc, SelectorLocs,
2890 /// \brief Build a new Objective-C instance message.
2891 ExprResult RebuildObjCMessageExpr(Expr *Receiver,
2893 ArrayRef<SourceLocation> SelectorLocs,
2894 ObjCMethodDecl *Method,
2895 SourceLocation LBracLoc,
2897 SourceLocation RBracLoc) {
2898 return SemaRef.BuildInstanceMessage(Receiver,
2899 Receiver->getType(),
2900 /*SuperLoc=*/SourceLocation(),
2901 Sel, Method, LBracLoc, SelectorLocs,
2905 /// \brief Build a new Objective-C instance/class message to 'super'.
2906 ExprResult RebuildObjCMessageExpr(SourceLocation SuperLoc,
2908 ArrayRef<SourceLocation> SelectorLocs,
2910 ObjCMethodDecl *Method,
2911 SourceLocation LBracLoc,
2913 SourceLocation RBracLoc) {
2914 return Method->isInstanceMethod() ? SemaRef.BuildInstanceMessage(nullptr,
2917 Sel, Method, LBracLoc, SelectorLocs,
2919 : SemaRef.BuildClassMessage(nullptr,
2922 Sel, Method, LBracLoc, SelectorLocs,
2928 /// \brief Build a new Objective-C ivar reference expression.
2930 /// By default, performs semantic analysis to build the new expression.
2931 /// Subclasses may override this routine to provide different behavior.
2932 ExprResult RebuildObjCIvarRefExpr(Expr *BaseArg, ObjCIvarDecl *Ivar,
2933 SourceLocation IvarLoc,
2934 bool IsArrow, bool IsFreeIvar) {
2936 DeclarationNameInfo NameInfo(Ivar->getDeclName(), IvarLoc);
2937 ExprResult Result = getSema().BuildMemberReferenceExpr(
2938 BaseArg, BaseArg->getType(),
2939 /*FIXME:*/ IvarLoc, IsArrow, SS, SourceLocation(),
2940 /*FirstQualifierInScope=*/nullptr, NameInfo,
2941 /*TemplateArgs=*/nullptr,
2943 if (IsFreeIvar && Result.isUsable())
2944 cast<ObjCIvarRefExpr>(Result.get())->setIsFreeIvar(IsFreeIvar);
2948 /// \brief Build a new Objective-C property reference expression.
2950 /// By default, performs semantic analysis to build the new expression.
2951 /// Subclasses may override this routine to provide different behavior.
2952 ExprResult RebuildObjCPropertyRefExpr(Expr *BaseArg,
2953 ObjCPropertyDecl *Property,
2954 SourceLocation PropertyLoc) {
2956 DeclarationNameInfo NameInfo(Property->getDeclName(), PropertyLoc);
2957 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
2958 /*FIXME:*/PropertyLoc,
2960 SS, SourceLocation(),
2961 /*FirstQualifierInScope=*/nullptr,
2963 /*TemplateArgs=*/nullptr,
2967 /// \brief Build a new Objective-C property reference expression.
2969 /// By default, performs semantic analysis to build the new expression.
2970 /// Subclasses may override this routine to provide different behavior.
2971 ExprResult RebuildObjCPropertyRefExpr(Expr *Base, QualType T,
2972 ObjCMethodDecl *Getter,
2973 ObjCMethodDecl *Setter,
2974 SourceLocation PropertyLoc) {
2975 // Since these expressions can only be value-dependent, we do not
2976 // need to perform semantic analysis again.
2978 new (getSema().Context) ObjCPropertyRefExpr(Getter, Setter, T,
2979 VK_LValue, OK_ObjCProperty,
2980 PropertyLoc, Base));
2983 /// \brief Build a new Objective-C "isa" expression.
2985 /// By default, performs semantic analysis to build the new expression.
2986 /// Subclasses may override this routine to provide different behavior.
2987 ExprResult RebuildObjCIsaExpr(Expr *BaseArg, SourceLocation IsaLoc,
2988 SourceLocation OpLoc, bool IsArrow) {
2990 DeclarationNameInfo NameInfo(&getSema().Context.Idents.get("isa"), IsaLoc);
2991 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
2993 SS, SourceLocation(),
2994 /*FirstQualifierInScope=*/nullptr,
2996 /*TemplateArgs=*/nullptr,
3000 /// \brief Build a new shuffle vector expression.
3002 /// By default, performs semantic analysis to build the new expression.
3003 /// Subclasses may override this routine to provide different behavior.
3004 ExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc,
3005 MultiExprArg SubExprs,
3006 SourceLocation RParenLoc) {
3007 // Find the declaration for __builtin_shufflevector
3008 const IdentifierInfo &Name
3009 = SemaRef.Context.Idents.get("__builtin_shufflevector");
3010 TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl();
3011 DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name));
3012 assert(!Lookup.empty() && "No __builtin_shufflevector?");
3014 // Build a reference to the __builtin_shufflevector builtin
3015 FunctionDecl *Builtin = cast<FunctionDecl>(Lookup.front());
3016 Expr *Callee = new (SemaRef.Context) DeclRefExpr(Builtin, false,
3017 SemaRef.Context.BuiltinFnTy,
3018 VK_RValue, BuiltinLoc);
3019 QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType());
3020 Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy,
3021 CK_BuiltinFnToFnPtr).get();
3023 // Build the CallExpr
3024 ExprResult TheCall = new (SemaRef.Context) CallExpr(
3025 SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(),
3026 Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc);
3028 // Type-check the __builtin_shufflevector expression.
3029 return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.get()));
3032 /// \brief Build a new convert vector expression.
3033 ExprResult RebuildConvertVectorExpr(SourceLocation BuiltinLoc,
3034 Expr *SrcExpr, TypeSourceInfo *DstTInfo,
3035 SourceLocation RParenLoc) {
3036 return SemaRef.SemaConvertVectorExpr(SrcExpr, DstTInfo,
3037 BuiltinLoc, RParenLoc);
3040 /// \brief Build a new template argument pack expansion.
3042 /// By default, performs semantic analysis to build a new pack expansion
3043 /// for a template argument. Subclasses may override this routine to provide
3044 /// different behavior.
3045 TemplateArgumentLoc RebuildPackExpansion(TemplateArgumentLoc Pattern,
3046 SourceLocation EllipsisLoc,
3047 Optional<unsigned> NumExpansions) {
3048 switch (Pattern.getArgument().getKind()) {
3049 case TemplateArgument::Expression: {
3051 = getSema().CheckPackExpansion(Pattern.getSourceExpression(),
3052 EllipsisLoc, NumExpansions);
3053 if (Result.isInvalid())
3054 return TemplateArgumentLoc();
3056 return TemplateArgumentLoc(Result.get(), Result.get());
3059 case TemplateArgument::Template:
3060 return TemplateArgumentLoc(TemplateArgument(
3061 Pattern.getArgument().getAsTemplate(),
3063 Pattern.getTemplateQualifierLoc(),
3064 Pattern.getTemplateNameLoc(),
3067 case TemplateArgument::Null:
3068 case TemplateArgument::Integral:
3069 case TemplateArgument::Declaration:
3070 case TemplateArgument::Pack:
3071 case TemplateArgument::TemplateExpansion:
3072 case TemplateArgument::NullPtr:
3073 llvm_unreachable("Pack expansion pattern has no parameter packs");
3075 case TemplateArgument::Type:
3076 if (TypeSourceInfo *Expansion
3077 = getSema().CheckPackExpansion(Pattern.getTypeSourceInfo(),
3080 return TemplateArgumentLoc(TemplateArgument(Expansion->getType()),
3085 return TemplateArgumentLoc();
3088 /// \brief Build a new expression pack expansion.
3090 /// By default, performs semantic analysis to build a new pack expansion
3091 /// for an expression. Subclasses may override this routine to provide
3092 /// different behavior.
3093 ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
3094 Optional<unsigned> NumExpansions) {
3095 return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions);
3098 /// \brief Build a new C++1z fold-expression.
3100 /// By default, performs semantic analysis in order to build a new fold
3102 ExprResult RebuildCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
3103 BinaryOperatorKind Operator,
3104 SourceLocation EllipsisLoc, Expr *RHS,
3105 SourceLocation RParenLoc) {
3106 return getSema().BuildCXXFoldExpr(LParenLoc, LHS, Operator, EllipsisLoc,
3110 /// \brief Build an empty C++1z fold-expression with the given operator.
3112 /// By default, produces the fallback value for the fold-expression, or
3113 /// produce an error if there is no fallback value.
3114 ExprResult RebuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
3115 BinaryOperatorKind Operator) {
3116 return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator);
3119 /// \brief Build a new atomic operation expression.
3121 /// By default, performs semantic analysis to build the new expression.
3122 /// Subclasses may override this routine to provide different behavior.
3123 ExprResult RebuildAtomicExpr(SourceLocation BuiltinLoc,
3124 MultiExprArg SubExprs,
3126 AtomicExpr::AtomicOp Op,
3127 SourceLocation RParenLoc) {
3128 // Just create the expression; there is not any interesting semantic
3129 // analysis here because we can't actually build an AtomicExpr until
3130 // we are sure it is semantically sound.
3131 return new (SemaRef.Context) AtomicExpr(BuiltinLoc, SubExprs, RetTy, Op,
3136 TypeLoc TransformTypeInObjectScope(TypeLoc TL,
3137 QualType ObjectType,
3138 NamedDecl *FirstQualifierInScope,
3141 TypeSourceInfo *TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
3142 QualType ObjectType,
3143 NamedDecl *FirstQualifierInScope,
3146 TypeSourceInfo *TransformTSIInObjectScope(TypeLoc TL, QualType ObjectType,
3147 NamedDecl *FirstQualifierInScope,
3151 template<typename Derived>
3152 StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) {
3156 switch (S->getStmtClass()) {
3157 case Stmt::NoStmtClass: break;
3159 // Transform individual statement nodes
3160 #define STMT(Node, Parent) \
3161 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
3162 #define ABSTRACT_STMT(Node)
3163 #define EXPR(Node, Parent)
3164 #include "clang/AST/StmtNodes.inc"
3166 // Transform expressions by calling TransformExpr.
3167 #define STMT(Node, Parent)
3168 #define ABSTRACT_STMT(Stmt)
3169 #define EXPR(Node, Parent) case Stmt::Node##Class:
3170 #include "clang/AST/StmtNodes.inc"
3172 ExprResult E = getDerived().TransformExpr(cast<Expr>(S));
3176 return getSema().ActOnExprStmt(E);
3183 template<typename Derived>
3184 OMPClause *TreeTransform<Derived>::TransformOMPClause(OMPClause *S) {
3188 switch (S->getClauseKind()) {
3190 // Transform individual clause nodes
3191 #define OPENMP_CLAUSE(Name, Class) \
3192 case OMPC_ ## Name : \
3193 return getDerived().Transform ## Class(cast<Class>(S));
3194 #include "clang/Basic/OpenMPKinds.def"
3201 template<typename Derived>
3202 ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) {
3206 switch (E->getStmtClass()) {
3207 case Stmt::NoStmtClass: break;
3208 #define STMT(Node, Parent) case Stmt::Node##Class: break;
3209 #define ABSTRACT_STMT(Stmt)
3210 #define EXPR(Node, Parent) \
3211 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
3212 #include "clang/AST/StmtNodes.inc"
3218 template<typename Derived>
3219 ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init,
3221 // Initializers are instantiated like expressions, except that various outer
3222 // layers are stripped.
3226 if (ExprWithCleanups *ExprTemp = dyn_cast<ExprWithCleanups>(Init))
3227 Init = ExprTemp->getSubExpr();
3229 if (auto *AIL = dyn_cast<ArrayInitLoopExpr>(Init))
3230 Init = AIL->getCommonExpr();
3232 if (MaterializeTemporaryExpr *MTE = dyn_cast<MaterializeTemporaryExpr>(Init))
3233 Init = MTE->GetTemporaryExpr();
3235 while (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(Init))
3236 Init = Binder->getSubExpr();
3238 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Init))
3239 Init = ICE->getSubExprAsWritten();
3241 if (CXXStdInitializerListExpr *ILE =
3242 dyn_cast<CXXStdInitializerListExpr>(Init))
3243 return TransformInitializer(ILE->getSubExpr(), NotCopyInit);
3245 // If this is copy-initialization, we only need to reconstruct
3246 // InitListExprs. Other forms of copy-initialization will be a no-op if
3247 // the initializer is already the right type.
3248 CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init);
3249 if (!NotCopyInit && !(Construct && Construct->isListInitialization()))
3250 return getDerived().TransformExpr(Init);
3252 // Revert value-initialization back to empty parens.
3253 if (CXXScalarValueInitExpr *VIE = dyn_cast<CXXScalarValueInitExpr>(Init)) {
3254 SourceRange Parens = VIE->getSourceRange();
3255 return getDerived().RebuildParenListExpr(Parens.getBegin(), None,
3259 // FIXME: We shouldn't build ImplicitValueInitExprs for direct-initialization.
3260 if (isa<ImplicitValueInitExpr>(Init))
3261 return getDerived().RebuildParenListExpr(SourceLocation(), None,
3264 // Revert initialization by constructor back to a parenthesized or braced list
3265 // of expressions. Any other form of initializer can just be reused directly.
3266 if (!Construct || isa<CXXTemporaryObjectExpr>(Construct))
3267 return getDerived().TransformExpr(Init);
3269 // If the initialization implicitly converted an initializer list to a
3270 // std::initializer_list object, unwrap the std::initializer_list too.
3271 if (Construct && Construct->isStdInitListInitialization())
3272 return TransformInitializer(Construct->getArg(0), NotCopyInit);
3274 SmallVector<Expr*, 8> NewArgs;
3275 bool ArgChanged = false;
3276 if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(),
3277 /*IsCall*/true, NewArgs, &ArgChanged))
3280 // If this was list initialization, revert to list form.
3281 if (Construct->isListInitialization())
3282 return getDerived().RebuildInitList(Construct->getLocStart(), NewArgs,
3283 Construct->getLocEnd(),
3284 Construct->getType());
3286 // Build a ParenListExpr to represent anything else.
3287 SourceRange Parens = Construct->getParenOrBraceRange();
3288 if (Parens.isInvalid()) {
3289 // This was a variable declaration's initialization for which no initializer
3291 assert(NewArgs.empty() &&
3292 "no parens or braces but have direct init with arguments?");
3295 return getDerived().RebuildParenListExpr(Parens.getBegin(), NewArgs,
3299 template<typename Derived>
3300 bool TreeTransform<Derived>::TransformExprs(Expr *const *Inputs,
3303 SmallVectorImpl<Expr *> &Outputs,
3305 for (unsigned I = 0; I != NumInputs; ++I) {
3306 // If requested, drop call arguments that need to be dropped.
3307 if (IsCall && getDerived().DropCallArgument(Inputs[I])) {
3314 if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(Inputs[I])) {
3315 Expr *Pattern = Expansion->getPattern();
3317 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
3318 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
3319 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
3321 // Determine whether the set of unexpanded parameter packs can and should
3324 bool RetainExpansion = false;
3325 Optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions();
3326 Optional<unsigned> NumExpansions = OrigNumExpansions;
3327 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
3328 Pattern->getSourceRange(),
3330 Expand, RetainExpansion,
3335 // The transform has determined that we should perform a simple
3336 // transformation on the pack expansion, producing another pack
3338 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
3339 ExprResult OutPattern = getDerived().TransformExpr(Pattern);
3340 if (OutPattern.isInvalid())
3343 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(),
3344 Expansion->getEllipsisLoc(),
3346 if (Out.isInvalid())
3351 Outputs.push_back(Out.get());
3355 // Record right away that the argument was changed. This needs
3356 // to happen even if the array expands to nothing.
3357 if (ArgChanged) *ArgChanged = true;
3359 // The transform has determined that we should perform an elementwise
3360 // expansion of the pattern. Do so.
3361 for (unsigned I = 0; I != *NumExpansions; ++I) {
3362 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
3363 ExprResult Out = getDerived().TransformExpr(Pattern);
3364 if (Out.isInvalid())
3367 if (Out.get()->containsUnexpandedParameterPack()) {
3368 Out = getDerived().RebuildPackExpansion(
3369 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
3370 if (Out.isInvalid())
3374 Outputs.push_back(Out.get());
3377 // If we're supposed to retain a pack expansion, do so by temporarily
3378 // forgetting the partially-substituted parameter pack.
3379 if (RetainExpansion) {
3380 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
3382 ExprResult Out = getDerived().TransformExpr(Pattern);
3383 if (Out.isInvalid())
3386 Out = getDerived().RebuildPackExpansion(
3387 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
3388 if (Out.isInvalid())
3391 Outputs.push_back(Out.get());
3398 IsCall ? getDerived().TransformInitializer(Inputs[I], /*DirectInit*/false)
3399 : getDerived().TransformExpr(Inputs[I]);
3400 if (Result.isInvalid())
3403 if (Result.get() != Inputs[I] && ArgChanged)
3406 Outputs.push_back(Result.get());
3412 template <typename Derived>
3413 Sema::ConditionResult TreeTransform<Derived>::TransformCondition(
3414 SourceLocation Loc, VarDecl *Var, Expr *Expr, Sema::ConditionKind Kind) {
3416 VarDecl *ConditionVar = cast_or_null<VarDecl>(
3417 getDerived().TransformDefinition(Var->getLocation(), Var));
3420 return Sema::ConditionError();
3422 return getSema().ActOnConditionVariable(ConditionVar, Loc, Kind);
3426 ExprResult CondExpr = getDerived().TransformExpr(Expr);
3428 if (CondExpr.isInvalid())
3429 return Sema::ConditionError();
3431 return getSema().ActOnCondition(nullptr, Loc, CondExpr.get(), Kind);
3434 return Sema::ConditionResult();
3437 template<typename Derived>
3438 NestedNameSpecifierLoc
3439 TreeTransform<Derived>::TransformNestedNameSpecifierLoc(
3440 NestedNameSpecifierLoc NNS,
3441 QualType ObjectType,
3442 NamedDecl *FirstQualifierInScope) {
3443 SmallVector<NestedNameSpecifierLoc, 4> Qualifiers;
3444 for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier;
3445 Qualifier = Qualifier.getPrefix())
3446 Qualifiers.push_back(Qualifier);
3449 while (!Qualifiers.empty()) {
3450 NestedNameSpecifierLoc Q = Qualifiers.pop_back_val();
3451 NestedNameSpecifier *QNNS = Q.getNestedNameSpecifier();
3453 switch (QNNS->getKind()) {
3454 case NestedNameSpecifier::Identifier: {
3455 Sema::NestedNameSpecInfo IdInfo(QNNS->getAsIdentifier(),
3456 Q.getLocalBeginLoc(), Q.getLocalEndLoc(), ObjectType);
3457 if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/nullptr, IdInfo, false,
3458 SS, FirstQualifierInScope, false))
3459 return NestedNameSpecifierLoc();
3463 case NestedNameSpecifier::Namespace: {
3465 = cast_or_null<NamespaceDecl>(
3466 getDerived().TransformDecl(
3467 Q.getLocalBeginLoc(),
3468 QNNS->getAsNamespace()));
3469 SS.Extend(SemaRef.Context, NS, Q.getLocalBeginLoc(), Q.getLocalEndLoc());
3473 case NestedNameSpecifier::NamespaceAlias: {
3474 NamespaceAliasDecl *Alias
3475 = cast_or_null<NamespaceAliasDecl>(
3476 getDerived().TransformDecl(Q.getLocalBeginLoc(),
3477 QNNS->getAsNamespaceAlias()));
3478 SS.Extend(SemaRef.Context, Alias, Q.getLocalBeginLoc(),
3479 Q.getLocalEndLoc());
3483 case NestedNameSpecifier::Global:
3484 // There is no meaningful transformation that one could perform on the
3486 SS.MakeGlobal(SemaRef.Context, Q.getBeginLoc());
3489 case NestedNameSpecifier::Super: {
3491 cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
3492 SourceLocation(), QNNS->getAsRecordDecl()));
3493 SS.MakeSuper(SemaRef.Context, RD, Q.getBeginLoc(), Q.getEndLoc());
3497 case NestedNameSpecifier::TypeSpecWithTemplate:
3498 case NestedNameSpecifier::TypeSpec: {
3499 TypeLoc TL = TransformTypeInObjectScope(Q.getTypeLoc(), ObjectType,
3500 FirstQualifierInScope, SS);
3503 return NestedNameSpecifierLoc();
3505 if (TL.getType()->isDependentType() || TL.getType()->isRecordType() ||
3506 (SemaRef.getLangOpts().CPlusPlus11 &&
3507 TL.getType()->isEnumeralType())) {
3508 assert(!TL.getType().hasLocalQualifiers() &&
3509 "Can't get cv-qualifiers here");
3510 if (TL.getType()->isEnumeralType())
3511 SemaRef.Diag(TL.getBeginLoc(),
3512 diag::warn_cxx98_compat_enum_nested_name_spec);
3513 SS.Extend(SemaRef.Context, /*FIXME:*/SourceLocation(), TL,
3514 Q.getLocalEndLoc());
3517 // If the nested-name-specifier is an invalid type def, don't emit an
3518 // error because a previous error should have already been emitted.
3519 TypedefTypeLoc TTL = TL.getAs<TypedefTypeLoc>();
3520 if (!TTL || !TTL.getTypedefNameDecl()->isInvalidDecl()) {
3521 SemaRef.Diag(TL.getBeginLoc(), diag::err_nested_name_spec_non_tag)
3522 << TL.getType() << SS.getRange();
3524 return NestedNameSpecifierLoc();
3528 // The qualifier-in-scope and object type only apply to the leftmost entity.
3529 FirstQualifierInScope = nullptr;
3530 ObjectType = QualType();
3533 // Don't rebuild the nested-name-specifier if we don't have to.
3534 if (SS.getScopeRep() == NNS.getNestedNameSpecifier() &&
3535 !getDerived().AlwaysRebuild())
3538 // If we can re-use the source-location data from the original
3539 // nested-name-specifier, do so.
3540 if (SS.location_size() == NNS.getDataLength() &&
3541 memcmp(SS.location_data(), NNS.getOpaqueData(), SS.location_size()) == 0)
3542 return NestedNameSpecifierLoc(SS.getScopeRep(), NNS.getOpaqueData());
3544 // Allocate new nested-name-specifier location information.
3545 return SS.getWithLocInContext(SemaRef.Context);
3548 template<typename Derived>
3550 TreeTransform<Derived>
3551 ::TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo) {
3552 DeclarationName Name = NameInfo.getName();
3554 return DeclarationNameInfo();
3556 switch (Name.getNameKind()) {
3557 case DeclarationName::Identifier:
3558 case DeclarationName::ObjCZeroArgSelector:
3559 case DeclarationName::ObjCOneArgSelector:
3560 case DeclarationName::ObjCMultiArgSelector:
3561 case DeclarationName::CXXOperatorName:
3562 case DeclarationName::CXXLiteralOperatorName:
3563 case DeclarationName::CXXUsingDirective:
3566 case DeclarationName::CXXConstructorName:
3567 case DeclarationName::CXXDestructorName:
3568 case DeclarationName::CXXConversionFunctionName: {
3569 TypeSourceInfo *NewTInfo;
3570 CanQualType NewCanTy;
3571 if (TypeSourceInfo *OldTInfo = NameInfo.getNamedTypeInfo()) {
3572 NewTInfo = getDerived().TransformType(OldTInfo);
3574 return DeclarationNameInfo();
3575 NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->getType());
3579 TemporaryBase Rebase(*this, NameInfo.getLoc(), Name);
3580 QualType NewT = getDerived().TransformType(Name.getCXXNameType());
3582 return DeclarationNameInfo();
3583 NewCanTy = SemaRef.Context.getCanonicalType(NewT);
3586 DeclarationName NewName
3587 = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.getNameKind(),
3589 DeclarationNameInfo NewNameInfo(NameInfo);
3590 NewNameInfo.setName(NewName);
3591 NewNameInfo.setNamedTypeInfo(NewTInfo);
3596 llvm_unreachable("Unknown name kind.");
3599 template<typename Derived>
3601 TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS,
3603 SourceLocation NameLoc,
3604 QualType ObjectType,
3605 NamedDecl *FirstQualifierInScope) {
3606 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) {
3607 TemplateDecl *Template = QTN->getTemplateDecl();
3608 assert(Template && "qualified template name must refer to a template");
3610 TemplateDecl *TransTemplate
3611 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
3614 return TemplateName();
3616 if (!getDerived().AlwaysRebuild() &&
3617 SS.getScopeRep() == QTN->getQualifier() &&
3618 TransTemplate == Template)
3621 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
3625 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) {
3626 if (SS.getScopeRep()) {
3627 // These apply to the scope specifier, not the template.
3628 ObjectType = QualType();
3629 FirstQualifierInScope = nullptr;
3632 if (!getDerived().AlwaysRebuild() &&
3633 SS.getScopeRep() == DTN->getQualifier() &&
3634 ObjectType.isNull())
3637 if (DTN->isIdentifier()) {
3638 return getDerived().RebuildTemplateName(SS,
3639 *DTN->getIdentifier(),
3642 FirstQualifierInScope);
3645 return getDerived().RebuildTemplateName(SS, DTN->getOperator(), NameLoc,
3649 if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
3650 TemplateDecl *TransTemplate
3651 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
3654 return TemplateName();
3656 if (!getDerived().AlwaysRebuild() &&
3657 TransTemplate == Template)
3660 return TemplateName(TransTemplate);
3663 if (SubstTemplateTemplateParmPackStorage *SubstPack
3664 = Name.getAsSubstTemplateTemplateParmPack()) {
3665 TemplateTemplateParmDecl *TransParam
3666 = cast_or_null<TemplateTemplateParmDecl>(
3667 getDerived().TransformDecl(NameLoc, SubstPack->getParameterPack()));
3669 return TemplateName();
3671 if (!getDerived().AlwaysRebuild() &&
3672 TransParam == SubstPack->getParameterPack())
3675 return getDerived().RebuildTemplateName(TransParam,
3676 SubstPack->getArgumentPack());
3679 // These should be getting filtered out before they reach the AST.
3680 llvm_unreachable("overloaded function decl survived to here");
3683 template<typename Derived>
3684 void TreeTransform<Derived>::InventTemplateArgumentLoc(
3685 const TemplateArgument &Arg,
3686 TemplateArgumentLoc &Output) {
3687 SourceLocation Loc = getDerived().getBaseLocation();
3688 switch (Arg.getKind()) {
3689 case TemplateArgument::Null:
3690 llvm_unreachable("null template argument in TreeTransform");
3693 case TemplateArgument::Type:
3694 Output = TemplateArgumentLoc(Arg,
3695 SemaRef.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc));
3699 case TemplateArgument::Template:
3700 case TemplateArgument::TemplateExpansion: {
3701 NestedNameSpecifierLocBuilder Builder;
3702 TemplateName Template = Arg.getAsTemplateOrTemplatePattern();
3703 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
3704 Builder.MakeTrivial(SemaRef.Context, DTN->getQualifier(), Loc);
3705 else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
3706 Builder.MakeTrivial(SemaRef.Context, QTN->getQualifier(), Loc);
3708 if (Arg.getKind() == TemplateArgument::Template)
3709 Output = TemplateArgumentLoc(Arg,
3710 Builder.getWithLocInContext(SemaRef.Context),
3713 Output = TemplateArgumentLoc(Arg,
3714 Builder.getWithLocInContext(SemaRef.Context),
3720 case TemplateArgument::Expression:
3721 Output = TemplateArgumentLoc(Arg, Arg.getAsExpr());
3724 case TemplateArgument::Declaration:
3725 case TemplateArgument::Integral:
3726 case TemplateArgument::Pack:
3727 case TemplateArgument::NullPtr:
3728 Output = TemplateArgumentLoc(Arg, TemplateArgumentLocInfo());
3733 template<typename Derived>
3734 bool TreeTransform<Derived>::TransformTemplateArgument(
3735 const TemplateArgumentLoc &Input,
3736 TemplateArgumentLoc &Output, bool Uneval) {
3737 const TemplateArgument &Arg = Input.getArgument();
3738 switch (Arg.getKind()) {
3739 case TemplateArgument::Null:
3740 case TemplateArgument::Integral:
3741 case TemplateArgument::Pack:
3742 case TemplateArgument::Declaration:
3743 case TemplateArgument::NullPtr:
3744 llvm_unreachable("Unexpected TemplateArgument");
3746 case TemplateArgument::Type: {
3747 TypeSourceInfo *DI = Input.getTypeSourceInfo();
3749 DI = InventTypeSourceInfo(Input.getArgument().getAsType());
3751 DI = getDerived().TransformType(DI);
3752 if (!DI) return true;
3754 Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
3758 case TemplateArgument::Template: {
3759 NestedNameSpecifierLoc QualifierLoc = Input.getTemplateQualifierLoc();
3761 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
3767 SS.Adopt(QualifierLoc);
3768 TemplateName Template
3769 = getDerived().TransformTemplateName(SS, Arg.getAsTemplate(),
3770 Input.getTemplateNameLoc());
3771 if (Template.isNull())
3774 Output = TemplateArgumentLoc(TemplateArgument(Template), QualifierLoc,
3775 Input.getTemplateNameLoc());
3779 case TemplateArgument::TemplateExpansion:
3780 llvm_unreachable("Caller should expand pack expansions");
3782 case TemplateArgument::Expression: {
3783 // Template argument expressions are constant expressions.
3784 EnterExpressionEvaluationContext Unevaluated(
3785 getSema(), Uneval ? Sema::Unevaluated : Sema::ConstantEvaluated);
3787 Expr *InputExpr = Input.getSourceExpression();
3788 if (!InputExpr) InputExpr = Input.getArgument().getAsExpr();
3790 ExprResult E = getDerived().TransformExpr(InputExpr);
3791 E = SemaRef.ActOnConstantExpression(E);
3792 if (E.isInvalid()) return true;
3793 Output = TemplateArgumentLoc(TemplateArgument(E.get()), E.get());
3798 // Work around bogus GCC warning
3802 /// \brief Iterator adaptor that invents template argument location information
3803 /// for each of the template arguments in its underlying iterator.
3804 template<typename Derived, typename InputIterator>
3805 class TemplateArgumentLocInventIterator {
3806 TreeTransform<Derived> &Self;
3810 typedef TemplateArgumentLoc value_type;
3811 typedef TemplateArgumentLoc reference;
3812 typedef typename std::iterator_traits<InputIterator>::difference_type
3814 typedef std::input_iterator_tag iterator_category;
3817 TemplateArgumentLoc Arg;
3820 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }
3822 const TemplateArgumentLoc *operator->() const { return &Arg; }
3825 TemplateArgumentLocInventIterator() { }
3827 explicit TemplateArgumentLocInventIterator(TreeTransform<Derived> &Self,
3829 : Self(Self), Iter(Iter) { }
3831 TemplateArgumentLocInventIterator &operator++() {
3836 TemplateArgumentLocInventIterator operator++(int) {
3837 TemplateArgumentLocInventIterator Old(*this);
3842 reference operator*() const {
3843 TemplateArgumentLoc Result;
3844 Self.InventTemplateArgumentLoc(*Iter, Result);
3848 pointer operator->() const { return pointer(**this); }
3850 friend bool operator==(const TemplateArgumentLocInventIterator &X,
3851 const TemplateArgumentLocInventIterator &Y) {
3852 return X.Iter == Y.Iter;
3855 friend bool operator!=(const TemplateArgumentLocInventIterator &X,
3856 const TemplateArgumentLocInventIterator &Y) {
3857 return X.Iter != Y.Iter;
3861 template<typename Derived>
3862 template<typename InputIterator>
3863 bool TreeTransform<Derived>::TransformTemplateArguments(
3864 InputIterator First, InputIterator Last, TemplateArgumentListInfo &Outputs,
3866 for (; First != Last; ++First) {
3867 TemplateArgumentLoc Out;
3868 TemplateArgumentLoc In = *First;
3870 if (In.getArgument().getKind() == TemplateArgument::Pack) {
3871 // Unpack argument packs, which we translate them into separate
3873 // FIXME: We could do much better if we could guarantee that the
3874 // TemplateArgumentLocInfo for the pack expansion would be usable for
3875 // all of the template arguments in the argument pack.
3876 typedef TemplateArgumentLocInventIterator<Derived,
3877 TemplateArgument::pack_iterator>
3879 if (TransformTemplateArguments(PackLocIterator(*this,
3880 In.getArgument().pack_begin()),
3881 PackLocIterator(*this,
3882 In.getArgument().pack_end()),
3889 if (In.getArgument().isPackExpansion()) {
3890 // We have a pack expansion, for which we will be substituting into
3892 SourceLocation Ellipsis;
3893 Optional<unsigned> OrigNumExpansions;
3894 TemplateArgumentLoc Pattern
3895 = getSema().getTemplateArgumentPackExpansionPattern(
3896 In, Ellipsis, OrigNumExpansions);
3898 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
3899 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
3900 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
3902 // Determine whether the set of unexpanded parameter packs can and should
3905 bool RetainExpansion = false;
3906 Optional<unsigned> NumExpansions = OrigNumExpansions;
3907 if (getDerived().TryExpandParameterPacks(Ellipsis,
3908 Pattern.getSourceRange(),
3916 // The transform has determined that we should perform a simple
3917 // transformation on the pack expansion, producing another pack
3919 TemplateArgumentLoc OutPattern;
3920 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
3921 if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))
3924 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,
3926 if (Out.getArgument().isNull())
3929 Outputs.addArgument(Out);
3933 // The transform has determined that we should perform an elementwise
3934 // expansion of the pattern. Do so.
3935 for (unsigned I = 0; I != *NumExpansions; ++I) {
3936 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
3938 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
3941 if (Out.getArgument().containsUnexpandedParameterPack()) {
3942 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
3944 if (Out.getArgument().isNull())
3948 Outputs.addArgument(Out);
3951 // If we're supposed to retain a pack expansion, do so by temporarily
3952 // forgetting the partially-substituted parameter pack.
3953 if (RetainExpansion) {
3954 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
3956 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
3959 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
3961 if (Out.getArgument().isNull())
3964 Outputs.addArgument(Out);
3971 if (getDerived().TransformTemplateArgument(In, Out, Uneval))
3974 Outputs.addArgument(Out);
3981 //===----------------------------------------------------------------------===//
3982 // Type transformation
3983 //===----------------------------------------------------------------------===//
3985 template<typename Derived>
3986 QualType TreeTransform<Derived>::TransformType(QualType T) {
3987 if (getDerived().AlreadyTransformed(T))
3990 // Temporary workaround. All of these transformations should
3991 // eventually turn into transformations on TypeLocs.
3992 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
3993 getDerived().getBaseLocation());
3995 TypeSourceInfo *NewDI = getDerived().TransformType(DI);
4000 return NewDI->getType();
4003 template<typename Derived>
4004 TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *DI) {
4005 // Refine the base location to the type's location.
4006 TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(),
4007 getDerived().getBaseEntity());
4008 if (getDerived().AlreadyTransformed(DI->getType()))
4013 TypeLoc TL = DI->getTypeLoc();
4014 TLB.reserve(TL.getFullDataSize());
4016 QualType Result = getDerived().TransformType(TLB, TL);
4017 if (Result.isNull())
4020 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
4023 template<typename Derived>
4025 TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) {
4026 switch (T.getTypeLocClass()) {
4027 #define ABSTRACT_TYPELOC(CLASS, PARENT)
4028 #define TYPELOC(CLASS, PARENT) \
4029 case TypeLoc::CLASS: \
4030 return getDerived().Transform##CLASS##Type(TLB, \
4031 T.castAs<CLASS##TypeLoc>());
4032 #include "clang/AST/TypeLocNodes.def"
4035 llvm_unreachable("unhandled type loc!");
4038 /// FIXME: By default, this routine adds type qualifiers only to types
4039 /// that can have qualifiers, and silently suppresses those qualifiers
4040 /// that are not permitted (e.g., qualifiers on reference or function
4041 /// types). This is the right thing for template instantiation, but
4042 /// probably not for other clients.
4043 template<typename Derived>
4045 TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB,
4046 QualifiedTypeLoc T) {
4047 Qualifiers Quals = T.getType().getLocalQualifiers();
4049 QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc());
4050 if (Result.isNull())
4053 // Silently suppress qualifiers if the result type can't be qualified.
4054 // FIXME: this is the right thing for template instantiation, but
4055 // probably not for other clients.
4056 if (Result->isFunctionType() || Result->isReferenceType())
4059 // Suppress Objective-C lifetime qualifiers if they don't make sense for the
4061 if (Quals.hasObjCLifetime()) {
4062 if (!Result->isObjCLifetimeType() && !Result->isDependentType())
4063 Quals.removeObjCLifetime();
4064 else if (Result.getObjCLifetime()) {
4066 // A lifetime qualifier applied to a substituted template parameter
4067 // overrides the lifetime qualifier from the template argument.
4068 const AutoType *AutoTy;
4069 if (const SubstTemplateTypeParmType *SubstTypeParam
4070 = dyn_cast<SubstTemplateTypeParmType>(Result)) {
4071 QualType Replacement = SubstTypeParam->getReplacementType();
4072 Qualifiers Qs = Replacement.getQualifiers();
4073 Qs.removeObjCLifetime();
4075 = SemaRef.Context.getQualifiedType(Replacement.getUnqualifiedType(),
4077 Result = SemaRef.Context.getSubstTemplateTypeParmType(
4078 SubstTypeParam->getReplacedParameter(),
4080 TLB.TypeWasModifiedSafely(Result);
4081 } else if ((AutoTy = dyn_cast<AutoType>(Result)) && AutoTy->isDeduced()) {
4082 // 'auto' types behave the same way as template parameters.
4083 QualType Deduced = AutoTy->getDeducedType();
4084 Qualifiers Qs = Deduced.getQualifiers();
4085 Qs.removeObjCLifetime();
4086 Deduced = SemaRef.Context.getQualifiedType(Deduced.getUnqualifiedType(),
4088 Result = SemaRef.Context.getAutoType(Deduced, AutoTy->getKeyword(),
4089 AutoTy->isDependentType());
4090 TLB.TypeWasModifiedSafely(Result);
4092 // Otherwise, complain about the addition of a qualifier to an
4093 // already-qualified type.
4094 SourceRange R = T.getUnqualifiedLoc().getSourceRange();
4095 SemaRef.Diag(R.getBegin(), diag::err_attr_objc_ownership_redundant)
4098 Quals.removeObjCLifetime();
4102 if (!Quals.empty()) {
4103 Result = SemaRef.BuildQualifiedType(Result, T.getBeginLoc(), Quals);
4104 // BuildQualifiedType might not add qualifiers if they are invalid.
4105 if (Result.hasLocalQualifiers())
4106 TLB.push<QualifiedTypeLoc>(Result);
4107 // No location information to preserve.
4113 template<typename Derived>
4115 TreeTransform<Derived>::TransformTypeInObjectScope(TypeLoc TL,
4116 QualType ObjectType,
4117 NamedDecl *UnqualLookup,
4119 if (getDerived().AlreadyTransformed(TL.getType()))
4122 TypeSourceInfo *TSI =
4123 TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
4125 return TSI->getTypeLoc();
4129 template<typename Derived>
4131 TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
4132 QualType ObjectType,
4133 NamedDecl *UnqualLookup,
4135 if (getDerived().AlreadyTransformed(TSInfo->getType()))
4138 return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType,
4142 template <typename Derived>
4143 TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope(
4144 TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup,
4146 QualType T = TL.getType();
4147 assert(!getDerived().AlreadyTransformed(T));
4152 if (isa<TemplateSpecializationType>(T)) {
4153 TemplateSpecializationTypeLoc SpecTL =
4154 TL.castAs<TemplateSpecializationTypeLoc>();
4156 TemplateName Template
4157 = getDerived().TransformTemplateName(SS,
4158 SpecTL.getTypePtr()->getTemplateName(),
4159 SpecTL.getTemplateNameLoc(),
4160 ObjectType, UnqualLookup);
4161 if (Template.isNull())
4164 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL,
4166 } else if (isa<DependentTemplateSpecializationType>(T)) {
4167 DependentTemplateSpecializationTypeLoc SpecTL =
4168 TL.castAs<DependentTemplateSpecializationTypeLoc>();
4170 TemplateName Template
4171 = getDerived().RebuildTemplateName(SS,
4172 *SpecTL.getTypePtr()->getIdentifier(),
4173 SpecTL.getTemplateNameLoc(),
4174 ObjectType, UnqualLookup);
4175 if (Template.isNull())
4178 Result = getDerived().TransformDependentTemplateSpecializationType(TLB,
4183 // Nothing special needs to be done for these.
4184 Result = getDerived().TransformType(TLB, TL);
4187 if (Result.isNull())
4190 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
4193 template <class TyLoc> static inline
4194 QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) {
4195 TyLoc NewT = TLB.push<TyLoc>(T.getType());
4196 NewT.setNameLoc(T.getNameLoc());
4200 template<typename Derived>
4201 QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
4203 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType());
4204 NewT.setBuiltinLoc(T.getBuiltinLoc());
4205 if (T.needsExtraLocalData())
4206 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs();
4210 template<typename Derived>
4211 QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
4214 return TransformTypeSpecType(TLB, T);
4217 template <typename Derived>
4218 QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB,
4219 AdjustedTypeLoc TL) {
4220 // Adjustments applied during transformation are handled elsewhere.
4221 return getDerived().TransformType(TLB, TL.getOriginalLoc());
4224 template<typename Derived>
4225 QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB,
4226 DecayedTypeLoc TL) {
4227 QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc());
4228 if (OriginalType.isNull())
4231 QualType Result = TL.getType();
4232 if (getDerived().AlwaysRebuild() ||
4233 OriginalType != TL.getOriginalLoc().getType())
4234 Result = SemaRef.Context.getDecayedType(OriginalType);
4235 TLB.push<DecayedTypeLoc>(Result);
4236 // Nothing to set for DecayedTypeLoc.
4240 template<typename Derived>
4241 QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
4242 PointerTypeLoc TL) {
4243 QualType PointeeType
4244 = getDerived().TransformType(TLB, TL.getPointeeLoc());
4245 if (PointeeType.isNull())
4248 QualType Result = TL.getType();
4249 if (PointeeType->getAs<ObjCObjectType>()) {
4250 // A dependent pointer type 'T *' has is being transformed such
4251 // that an Objective-C class type is being replaced for 'T'. The
4252 // resulting pointer type is an ObjCObjectPointerType, not a
4254 Result = SemaRef.Context.getObjCObjectPointerType(PointeeType);
4256 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
4257 NewT.setStarLoc(TL.getStarLoc());
4261 if (getDerived().AlwaysRebuild() ||
4262 PointeeType != TL.getPointeeLoc().getType()) {
4263 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
4264 if (Result.isNull())
4268 // Objective-C ARC can add lifetime qualifiers to the type that we're
4270 TLB.TypeWasModifiedSafely(Result->getPointeeType());
4272 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result);
4273 NewT.setSigilLoc(TL.getSigilLoc());
4277 template<typename Derived>
4279 TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
4280 BlockPointerTypeLoc TL) {
4281 QualType PointeeType
4282 = getDerived().TransformType(TLB, TL.getPointeeLoc());
4283 if (PointeeType.isNull())
4286 QualType Result = TL.getType();
4287 if (getDerived().AlwaysRebuild() ||
4288 PointeeType != TL.getPointeeLoc().getType()) {
4289 Result = getDerived().RebuildBlockPointerType(PointeeType,
4291 if (Result.isNull())
4295 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result);
4296 NewT.setSigilLoc(TL.getSigilLoc());
4300 /// Transforms a reference type. Note that somewhat paradoxically we
4301 /// don't care whether the type itself is an l-value type or an r-value
4302 /// type; we only care if the type was *written* as an l-value type
4303 /// or an r-value type.
4304 template<typename Derived>
4306 TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB,
4307 ReferenceTypeLoc TL) {
4308 const ReferenceType *T = TL.getTypePtr();
4310 // Note that this works with the pointee-as-written.
4311 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
4312 if (PointeeType.isNull())
4315 QualType Result = TL.getType();
4316 if (getDerived().AlwaysRebuild() ||
4317 PointeeType != T->getPointeeTypeAsWritten()) {
4318 Result = getDerived().RebuildReferenceType(PointeeType,
4319 T->isSpelledAsLValue(),
4321 if (Result.isNull())
4325 // Objective-C ARC can add lifetime qualifiers to the type that we're
4327 TLB.TypeWasModifiedSafely(
4328 Result->getAs<ReferenceType>()->getPointeeTypeAsWritten());
4330 // r-value references can be rebuilt as l-value references.
4331 ReferenceTypeLoc NewTL;
4332 if (isa<LValueReferenceType>(Result))
4333 NewTL = TLB.push<LValueReferenceTypeLoc>(Result);
4335 NewTL = TLB.push<RValueReferenceTypeLoc>(Result);
4336 NewTL.setSigilLoc(TL.getSigilLoc());
4341 template<typename Derived>
4343 TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB,
4344 LValueReferenceTypeLoc TL) {
4345 return TransformReferenceType(TLB, TL);
4348 template<typename Derived>
4350 TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
4351 RValueReferenceTypeLoc TL) {
4352 return TransformReferenceType(TLB, TL);
4355 template<typename Derived>
4357 TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
4358 MemberPointerTypeLoc TL) {
4359 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
4360 if (PointeeType.isNull())
4363 TypeSourceInfo* OldClsTInfo = TL.getClassTInfo();
4364 TypeSourceInfo *NewClsTInfo = nullptr;
4366 NewClsTInfo = getDerived().TransformType(OldClsTInfo);
4371 const MemberPointerType *T = TL.getTypePtr();
4372 QualType OldClsType = QualType(T->getClass(), 0);
4373 QualType NewClsType;
4375 NewClsType = NewClsTInfo->getType();
4377 NewClsType = getDerived().TransformType(OldClsType);
4378 if (NewClsType.isNull())
4382 QualType Result = TL.getType();
4383 if (getDerived().AlwaysRebuild() ||
4384 PointeeType != T->getPointeeType() ||
4385 NewClsType != OldClsType) {
4386 Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType,
4388 if (Result.isNull())
4392 // If we had to adjust the pointee type when building a member pointer, make
4393 // sure to push TypeLoc info for it.
4394 const MemberPointerType *MPT = Result->getAs<MemberPointerType>();
4395 if (MPT && PointeeType != MPT->getPointeeType()) {
4396 assert(isa<AdjustedType>(MPT->getPointeeType()));
4397 TLB.push<AdjustedTypeLoc>(MPT->getPointeeType());
4400 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
4401 NewTL.setSigilLoc(TL.getSigilLoc());
4402 NewTL.setClassTInfo(NewClsTInfo);
4407 template<typename Derived>
4409 TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
4410 ConstantArrayTypeLoc TL) {
4411 const ConstantArrayType *T = TL.getTypePtr();
4412 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4413 if (ElementType.isNull())
4416 QualType Result = TL.getType();
4417 if (getDerived().AlwaysRebuild() ||
4418 ElementType != T->getElementType()) {
4419 Result = getDerived().RebuildConstantArrayType(ElementType,
4420 T->getSizeModifier(),
4422 T->getIndexTypeCVRQualifiers(),
4423 TL.getBracketsRange());
4424 if (Result.isNull())
4428 // We might have either a ConstantArrayType or a VariableArrayType now:
4429 // a ConstantArrayType is allowed to have an element type which is a
4430 // VariableArrayType if the type is dependent. Fortunately, all array
4431 // types have the same location layout.
4432 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4433 NewTL.setLBracketLoc(TL.getLBracketLoc());
4434 NewTL.setRBracketLoc(TL.getRBracketLoc());
4436 Expr *Size = TL.getSizeExpr();
4438 EnterExpressionEvaluationContext Unevaluated(SemaRef,
4439 Sema::ConstantEvaluated);
4440 Size = getDerived().TransformExpr(Size).template getAs<Expr>();
4441 Size = SemaRef.ActOnConstantExpression(Size).get();
4443 NewTL.setSizeExpr(Size);
4448 template<typename Derived>
4449 QualType TreeTransform<Derived>::TransformIncompleteArrayType(
4450 TypeLocBuilder &TLB,
4451 IncompleteArrayTypeLoc TL) {
4452 const IncompleteArrayType *T = TL.getTypePtr();
4453 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4454 if (ElementType.isNull())
4457 QualType Result = TL.getType();
4458 if (getDerived().AlwaysRebuild() ||
4459 ElementType != T->getElementType()) {
4460 Result = getDerived().RebuildIncompleteArrayType(ElementType,
4461 T->getSizeModifier(),
4462 T->getIndexTypeCVRQualifiers(),
4463 TL.getBracketsRange());
4464 if (Result.isNull())
4468 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
4469 NewTL.setLBracketLoc(TL.getLBracketLoc());
4470 NewTL.setRBracketLoc(TL.getRBracketLoc());
4471 NewTL.setSizeExpr(nullptr);
4476 template<typename Derived>
4478 TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
4479 VariableArrayTypeLoc TL) {
4480 const VariableArrayType *T = TL.getTypePtr();
4481 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4482 if (ElementType.isNull())
4485 ExprResult SizeResult
4486 = getDerived().TransformExpr(T->getSizeExpr());
4487 if (SizeResult.isInvalid())
4490 Expr *Size = SizeResult.get();
4492 QualType Result = TL.getType();
4493 if (getDerived().AlwaysRebuild() ||
4494 ElementType != T->getElementType() ||
4495 Size != T->getSizeExpr()) {
4496 Result = getDerived().RebuildVariableArrayType(ElementType,
4497 T->getSizeModifier(),
4499 T->getIndexTypeCVRQualifiers(),
4500 TL.getBracketsRange());
4501 if (Result.isNull())
4505 // We might have constant size array now, but fortunately it has the same
4507 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4508 NewTL.setLBracketLoc(TL.getLBracketLoc());
4509 NewTL.setRBracketLoc(TL.getRBracketLoc());
4510 NewTL.setSizeExpr(Size);
4515 template<typename Derived>
4517 TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
4518 DependentSizedArrayTypeLoc TL) {
4519 const DependentSizedArrayType *T = TL.getTypePtr();
4520 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4521 if (ElementType.isNull())
4524 // Array bounds are constant expressions.
4525 EnterExpressionEvaluationContext Unevaluated(SemaRef,
4526 Sema::ConstantEvaluated);
4528 // Prefer the expression from the TypeLoc; the other may have been uniqued.
4529 Expr *origSize = TL.getSizeExpr();
4530 if (!origSize) origSize = T->getSizeExpr();
4532 ExprResult sizeResult
4533 = getDerived().TransformExpr(origSize);
4534 sizeResult = SemaRef.ActOnConstantExpression(sizeResult);
4535 if (sizeResult.isInvalid())
4538 Expr *size = sizeResult.get();
4540 QualType Result = TL.getType();
4541 if (getDerived().AlwaysRebuild() ||
4542 ElementType != T->getElementType() ||
4544 Result = getDerived().RebuildDependentSizedArrayType(ElementType,
4545 T->getSizeModifier(),
4547 T->getIndexTypeCVRQualifiers(),
4548 TL.getBracketsRange());
4549 if (Result.isNull())
4553 // We might have any sort of array type now, but fortunately they
4554 // all have the same location layout.
4555 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
4556 NewTL.setLBracketLoc(TL.getLBracketLoc());
4557 NewTL.setRBracketLoc(TL.getRBracketLoc());
4558 NewTL.setSizeExpr(size);
4563 template<typename Derived>
4564 QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
4565 TypeLocBuilder &TLB,
4566 DependentSizedExtVectorTypeLoc TL) {
4567 const DependentSizedExtVectorType *T = TL.getTypePtr();
4569 // FIXME: ext vector locs should be nested
4570 QualType ElementType = getDerived().TransformType(T->getElementType());
4571 if (ElementType.isNull())
4574 // Vector sizes are constant expressions.
4575 EnterExpressionEvaluationContext Unevaluated(SemaRef,
4576 Sema::ConstantEvaluated);
4578 ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
4579 Size = SemaRef.ActOnConstantExpression(Size);
4580 if (Size.isInvalid())
4583 QualType Result = TL.getType();
4584 if (getDerived().AlwaysRebuild() ||
4585 ElementType != T->getElementType() ||
4586 Size.get() != T->getSizeExpr()) {
4587 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
4589 T->getAttributeLoc());
4590 if (Result.isNull())
4594 // Result might be dependent or not.
4595 if (isa<DependentSizedExtVectorType>(Result)) {
4596 DependentSizedExtVectorTypeLoc NewTL
4597 = TLB.push<DependentSizedExtVectorTypeLoc>(Result);
4598 NewTL.setNameLoc(TL.getNameLoc());
4600 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
4601 NewTL.setNameLoc(TL.getNameLoc());
4607 template<typename Derived>
4608 QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
4610 const VectorType *T = TL.getTypePtr();
4611 QualType ElementType = getDerived().TransformType(T->getElementType());
4612 if (ElementType.isNull())
4615 QualType Result = TL.getType();
4616 if (getDerived().AlwaysRebuild() ||
4617 ElementType != T->getElementType()) {
4618 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(),
4619 T->getVectorKind());
4620 if (Result.isNull())
4624 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
4625 NewTL.setNameLoc(TL.getNameLoc());
4630 template<typename Derived>
4631 QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
4632 ExtVectorTypeLoc TL) {
4633 const VectorType *T = TL.getTypePtr();
4634 QualType ElementType = getDerived().TransformType(T->getElementType());
4635 if (ElementType.isNull())
4638 QualType Result = TL.getType();
4639 if (getDerived().AlwaysRebuild() ||
4640 ElementType != T->getElementType()) {
4641 Result = getDerived().RebuildExtVectorType(ElementType,
4642 T->getNumElements(),
4643 /*FIXME*/ SourceLocation());
4644 if (Result.isNull())
4648 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
4649 NewTL.setNameLoc(TL.getNameLoc());
4654 template <typename Derived>
4655 ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam(
4656 ParmVarDecl *OldParm, int indexAdjustment, Optional<unsigned> NumExpansions,
4657 bool ExpectParameterPack) {
4658 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
4659 TypeSourceInfo *NewDI = nullptr;
4661 if (NumExpansions && isa<PackExpansionType>(OldDI->getType())) {
4662 // If we're substituting into a pack expansion type and we know the
4663 // length we want to expand to, just substitute for the pattern.
4664 TypeLoc OldTL = OldDI->getTypeLoc();
4665 PackExpansionTypeLoc OldExpansionTL = OldTL.castAs<PackExpansionTypeLoc>();
4668 TypeLoc NewTL = OldDI->getTypeLoc();
4669 TLB.reserve(NewTL.getFullDataSize());
4671 QualType Result = getDerived().TransformType(TLB,
4672 OldExpansionTL.getPatternLoc());
4673 if (Result.isNull())
4676 Result = RebuildPackExpansionType(Result,
4677 OldExpansionTL.getPatternLoc().getSourceRange(),
4678 OldExpansionTL.getEllipsisLoc(),
4680 if (Result.isNull())
4683 PackExpansionTypeLoc NewExpansionTL
4684 = TLB.push<PackExpansionTypeLoc>(Result);
4685 NewExpansionTL.setEllipsisLoc(OldExpansionTL.getEllipsisLoc());
4686 NewDI = TLB.getTypeSourceInfo(SemaRef.Context, Result);
4688 NewDI = getDerived().TransformType(OldDI);
4692 if (NewDI == OldDI && indexAdjustment == 0)
4695 ParmVarDecl *newParm = ParmVarDecl::Create(SemaRef.Context,
4696 OldParm->getDeclContext(),
4697 OldParm->getInnerLocStart(),
4698 OldParm->getLocation(),
4699 OldParm->getIdentifier(),
4702 OldParm->getStorageClass(),
4703 /* DefArg */ nullptr);
4704 newParm->setScopeInfo(OldParm->getFunctionScopeDepth(),
4705 OldParm->getFunctionScopeIndex() + indexAdjustment);
4709 template <typename Derived>
4710 bool TreeTransform<Derived>::TransformFunctionTypeParams(
4711 SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
4712 const QualType *ParamTypes,
4713 const FunctionProtoType::ExtParameterInfo *ParamInfos,
4714 SmallVectorImpl<QualType> &OutParamTypes,
4715 SmallVectorImpl<ParmVarDecl *> *PVars,
4716 Sema::ExtParameterInfoBuilder &PInfos) {
4717 int indexAdjustment = 0;
4719 unsigned NumParams = Params.size();
4720 for (unsigned i = 0; i != NumParams; ++i) {
4721 if (ParmVarDecl *OldParm = Params[i]) {
4722 assert(OldParm->getFunctionScopeIndex() == i);
4724 Optional<unsigned> NumExpansions;
4725 ParmVarDecl *NewParm = nullptr;
4726 if (OldParm->isParameterPack()) {
4727 // We have a function parameter pack that may need to be expanded.
4728 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
4730 // Find the parameter packs that could be expanded.
4731 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc();
4732 PackExpansionTypeLoc ExpansionTL = TL.castAs<PackExpansionTypeLoc>();
4733 TypeLoc Pattern = ExpansionTL.getPatternLoc();
4734 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
4735 assert(Unexpanded.size() > 0 && "Could not find parameter packs!");
4737 // Determine whether we should expand the parameter packs.
4738 bool ShouldExpand = false;
4739 bool RetainExpansion = false;
4740 Optional<unsigned> OrigNumExpansions =
4741 ExpansionTL.getTypePtr()->getNumExpansions();
4742 NumExpansions = OrigNumExpansions;
4743 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
4744 Pattern.getSourceRange(),
4753 // Expand the function parameter pack into multiple, separate
4755 getDerived().ExpandingFunctionParameterPack(OldParm);
4756 for (unsigned I = 0; I != *NumExpansions; ++I) {
4757 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
4758 ParmVarDecl *NewParm
4759 = getDerived().TransformFunctionTypeParam(OldParm,
4762 /*ExpectParameterPack=*/false);
4767 PInfos.set(OutParamTypes.size(), ParamInfos[i]);
4768 OutParamTypes.push_back(NewParm->getType());
4770 PVars->push_back(NewParm);
4773 // If we're supposed to retain a pack expansion, do so by temporarily
4774 // forgetting the partially-substituted parameter pack.
4775 if (RetainExpansion) {
4776 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4777 ParmVarDecl *NewParm
4778 = getDerived().TransformFunctionTypeParam(OldParm,
4781 /*ExpectParameterPack=*/false);
4786 PInfos.set(OutParamTypes.size(), ParamInfos[i]);
4787 OutParamTypes.push_back(NewParm->getType());
4789 PVars->push_back(NewParm);
4792 // The next parameter should have the same adjustment as the
4793 // last thing we pushed, but we post-incremented indexAdjustment
4794 // on every push. Also, if we push nothing, the adjustment should
4798 // We're done with the pack expansion.
4802 // We'll substitute the parameter now without expanding the pack
4804 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
4805 NewParm = getDerived().TransformFunctionTypeParam(OldParm,
4808 /*ExpectParameterPack=*/true);
4810 NewParm = getDerived().TransformFunctionTypeParam(
4811 OldParm, indexAdjustment, None, /*ExpectParameterPack=*/ false);
4818 PInfos.set(OutParamTypes.size(), ParamInfos[i]);
4819 OutParamTypes.push_back(NewParm->getType());
4821 PVars->push_back(NewParm);
4825 // Deal with the possibility that we don't have a parameter
4826 // declaration for this parameter.
4827 QualType OldType = ParamTypes[i];
4828 bool IsPackExpansion = false;
4829 Optional<unsigned> NumExpansions;
4831 if (const PackExpansionType *Expansion
4832 = dyn_cast<PackExpansionType>(OldType)) {
4833 // We have a function parameter pack that may need to be expanded.
4834 QualType Pattern = Expansion->getPattern();
4835 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
4836 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
4838 // Determine whether we should expand the parameter packs.
4839 bool ShouldExpand = false;
4840 bool RetainExpansion = false;
4841 if (getDerived().TryExpandParameterPacks(Loc, SourceRange(),
4850 // Expand the function parameter pack into multiple, separate
4852 for (unsigned I = 0; I != *NumExpansions; ++I) {
4853 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
4854 QualType NewType = getDerived().TransformType(Pattern);
4855 if (NewType.isNull())
4858 if (NewType->containsUnexpandedParameterPack()) {
4860 getSema().getASTContext().getPackExpansionType(NewType, None);
4862 if (NewType.isNull())
4867 PInfos.set(OutParamTypes.size(), ParamInfos[i]);
4868 OutParamTypes.push_back(NewType);
4870 PVars->push_back(nullptr);
4873 // We're done with the pack expansion.
4877 // If we're supposed to retain a pack expansion, do so by temporarily
4878 // forgetting the partially-substituted parameter pack.
4879 if (RetainExpansion) {
4880 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4881 QualType NewType = getDerived().TransformType(Pattern);
4882 if (NewType.isNull())
4886 PInfos.set(OutParamTypes.size(), ParamInfos[i]);
4887 OutParamTypes.push_back(NewType);
4889 PVars->push_back(nullptr);
4892 // We'll substitute the parameter now without expanding the pack
4894 OldType = Expansion->getPattern();
4895 IsPackExpansion = true;
4896 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
4897 NewType = getDerived().TransformType(OldType);
4899 NewType = getDerived().TransformType(OldType);
4902 if (NewType.isNull())
4905 if (IsPackExpansion)
4906 NewType = getSema().Context.getPackExpansionType(NewType,
4910 PInfos.set(OutParamTypes.size(), ParamInfos[i]);
4911 OutParamTypes.push_back(NewType);
4913 PVars->push_back(nullptr);
4918 for (unsigned i = 0, e = PVars->size(); i != e; ++i)
4919 if (ParmVarDecl *parm = (*PVars)[i])
4920 assert(parm->getFunctionScopeIndex() == i);
4927 template<typename Derived>
4929 TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB,
4930 FunctionProtoTypeLoc TL) {
4931 SmallVector<QualType, 4> ExceptionStorage;
4932 TreeTransform *This = this; // Work around gcc.gnu.org/PR56135.
4933 return getDerived().TransformFunctionProtoType(
4934 TLB, TL, nullptr, 0,
4935 [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) {
4936 return This->TransformExceptionSpec(TL.getBeginLoc(), ESI,
4937 ExceptionStorage, Changed);
4941 template<typename Derived> template<typename Fn>
4942 QualType TreeTransform<Derived>::TransformFunctionProtoType(
4943 TypeLocBuilder &TLB, FunctionProtoTypeLoc TL, CXXRecordDecl *ThisContext,
4944 unsigned ThisTypeQuals, Fn TransformExceptionSpec) {
4946 // Transform the parameters and return type.
4948 // We are required to instantiate the params and return type in source order.
4949 // When the function has a trailing return type, we instantiate the
4950 // parameters before the return type, since the return type can then refer
4951 // to the parameters themselves (via decltype, sizeof, etc.).
4953 SmallVector<QualType, 4> ParamTypes;
4954 SmallVector<ParmVarDecl*, 4> ParamDecls;
4955 Sema::ExtParameterInfoBuilder ExtParamInfos;
4956 const FunctionProtoType *T = TL.getTypePtr();
4958 QualType ResultType;
4960 if (T->hasTrailingReturn()) {
4961 if (getDerived().TransformFunctionTypeParams(
4962 TL.getBeginLoc(), TL.getParams(),
4963 TL.getTypePtr()->param_type_begin(),
4964 T->getExtParameterInfosOrNull(),
4965 ParamTypes, &ParamDecls, ExtParamInfos))
4969 // C++11 [expr.prim.general]p3:
4970 // If a declaration declares a member function or member function
4971 // template of a class X, the expression this is a prvalue of type
4972 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
4973 // and the end of the function-definition, member-declarator, or
4975 Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, ThisTypeQuals);
4977 ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
4978 if (ResultType.isNull())
4983 ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
4984 if (ResultType.isNull())
4987 if (getDerived().TransformFunctionTypeParams(
4988 TL.getBeginLoc(), TL.getParams(),
4989 TL.getTypePtr()->param_type_begin(),
4990 T->getExtParameterInfosOrNull(),
4991 ParamTypes, &ParamDecls, ExtParamInfos))
4995 FunctionProtoType::ExtProtoInfo EPI = T->getExtProtoInfo();
4997 bool EPIChanged = false;
4998 if (TransformExceptionSpec(EPI.ExceptionSpec, EPIChanged))
5001 // Handle extended parameter information.
5002 if (auto NewExtParamInfos =
5003 ExtParamInfos.getPointerOrNull(ParamTypes.size())) {
5004 if (!EPI.ExtParameterInfos ||
5005 llvm::makeArrayRef(EPI.ExtParameterInfos, TL.getNumParams())
5006 != llvm::makeArrayRef(NewExtParamInfos, ParamTypes.size())) {
5009 EPI.ExtParameterInfos = NewExtParamInfos;
5010 } else if (EPI.ExtParameterInfos) {
5012 EPI.ExtParameterInfos = nullptr;
5015 QualType Result = TL.getType();
5016 if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType() ||
5017 T->getParamTypes() != llvm::makeArrayRef(ParamTypes) || EPIChanged) {
5018 Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI);
5019 if (Result.isNull())
5023 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result);
5024 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin());
5025 NewTL.setLParenLoc(TL.getLParenLoc());
5026 NewTL.setRParenLoc(TL.getRParenLoc());
5027 NewTL.setExceptionSpecRange(TL.getExceptionSpecRange());
5028 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());
5029 for (unsigned i = 0, e = NewTL.getNumParams(); i != e; ++i)
5030 NewTL.setParam(i, ParamDecls[i]);
5035 template<typename Derived>
5036 bool TreeTransform<Derived>::TransformExceptionSpec(
5037 SourceLocation Loc, FunctionProtoType::ExceptionSpecInfo &ESI,
5038 SmallVectorImpl<QualType> &Exceptions, bool &Changed) {
5039 assert(ESI.Type != EST_Uninstantiated && ESI.Type != EST_Unevaluated);
5041 // Instantiate a dynamic noexcept expression, if any.
5042 if (ESI.Type == EST_ComputedNoexcept) {
5043 EnterExpressionEvaluationContext Unevaluated(getSema(),
5044 Sema::ConstantEvaluated);
5045 ExprResult NoexceptExpr = getDerived().TransformExpr(ESI.NoexceptExpr);
5046 if (NoexceptExpr.isInvalid())
5049 // FIXME: This is bogus, a noexcept expression is not a condition.
5050 NoexceptExpr = getSema().CheckBooleanCondition(Loc, NoexceptExpr.get());
5051 if (NoexceptExpr.isInvalid())
5054 if (!NoexceptExpr.get()->isValueDependent()) {
5055 NoexceptExpr = getSema().VerifyIntegerConstantExpression(
5056 NoexceptExpr.get(), nullptr,
5057 diag::err_noexcept_needs_constant_expression,
5058 /*AllowFold*/false);
5059 if (NoexceptExpr.isInvalid())
5063 if (ESI.NoexceptExpr != NoexceptExpr.get())
5065 ESI.NoexceptExpr = NoexceptExpr.get();
5068 if (ESI.Type != EST_Dynamic)
5071 // Instantiate a dynamic exception specification's type.
5072 for (QualType T : ESI.Exceptions) {
5073 if (const PackExpansionType *PackExpansion =
5074 T->getAs<PackExpansionType>()) {
5077 // We have a pack expansion. Instantiate it.
5078 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
5079 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
5081 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
5083 // Determine whether the set of unexpanded parameter packs can and
5086 bool Expand = false;
5087 bool RetainExpansion = false;
5088 Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
5089 // FIXME: Track the location of the ellipsis (and track source location
5090 // information for the types in the exception specification in general).
5091 if (getDerived().TryExpandParameterPacks(
5092 Loc, SourceRange(), Unexpanded, Expand,
5093 RetainExpansion, NumExpansions))
5097 // We can't expand this pack expansion into separate arguments yet;
5098 // just substitute into the pattern and create a new pack expansion
5100 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
5101 QualType U = getDerived().TransformType(PackExpansion->getPattern());
5105 U = SemaRef.Context.getPackExpansionType(U, NumExpansions);
5106 Exceptions.push_back(U);
5110 // Substitute into the pack expansion pattern for each slice of the
5112 for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
5113 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);
5115 QualType U = getDerived().TransformType(PackExpansion->getPattern());
5116 if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
5119 Exceptions.push_back(U);
5122 QualType U = getDerived().TransformType(T);
5123 if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
5128 Exceptions.push_back(U);
5132 ESI.Exceptions = Exceptions;
5133 if (ESI.Exceptions.empty())
5134 ESI.Type = EST_DynamicNone;
5138 template<typename Derived>
5139 QualType TreeTransform<Derived>::TransformFunctionNoProtoType(
5140 TypeLocBuilder &TLB,
5141 FunctionNoProtoTypeLoc TL) {
5142 const FunctionNoProtoType *T = TL.getTypePtr();
5143 QualType ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
5144 if (ResultType.isNull())
5147 QualType Result = TL.getType();
5148 if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType())
5149 Result = getDerived().RebuildFunctionNoProtoType(ResultType);
5151 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result);
5152 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin());
5153 NewTL.setLParenLoc(TL.getLParenLoc());
5154 NewTL.setRParenLoc(TL.getRParenLoc());
5155 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());
5160 template<typename Derived> QualType
5161 TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB,
5162 UnresolvedUsingTypeLoc TL) {
5163 const UnresolvedUsingType *T = TL.getTypePtr();
5164 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl());
5168 QualType Result = TL.getType();
5169 if (getDerived().AlwaysRebuild() || D != T->getDecl()) {
5170 Result = getDerived().RebuildUnresolvedUsingType(TL.getNameLoc(), D);
5171 if (Result.isNull())
5175 // We might get an arbitrary type spec type back. We should at
5176 // least always get a type spec type, though.
5177 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result);
5178 NewTL.setNameLoc(TL.getNameLoc());
5183 template<typename Derived>
5184 QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
5185 TypedefTypeLoc TL) {
5186 const TypedefType *T = TL.getTypePtr();
5187 TypedefNameDecl *Typedef
5188 = cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5193 QualType Result = TL.getType();
5194 if (getDerived().AlwaysRebuild() ||
5195 Typedef != T->getDecl()) {
5196 Result = getDerived().RebuildTypedefType(Typedef);
5197 if (Result.isNull())
5201 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result);
5202 NewTL.setNameLoc(TL.getNameLoc());
5207 template<typename Derived>
5208 QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
5209 TypeOfExprTypeLoc TL) {
5210 // typeof expressions are not potentially evaluated contexts
5211 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated,
5212 Sema::ReuseLambdaContextDecl);
5214 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
5218 E = SemaRef.HandleExprEvaluationContextForTypeof(E.get());
5222 QualType Result = TL.getType();
5223 if (getDerived().AlwaysRebuild() ||
5224 E.get() != TL.getUnderlyingExpr()) {
5225 Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc());
5226 if (Result.isNull())
5231 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result);
5232 NewTL.setTypeofLoc(TL.getTypeofLoc());
5233 NewTL.setLParenLoc(TL.getLParenLoc());
5234 NewTL.setRParenLoc(TL.getRParenLoc());
5239 template<typename Derived>
5240 QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
5242 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo();
5243 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);
5247 QualType Result = TL.getType();
5248 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {
5249 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType());
5250 if (Result.isNull())
5254 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result);
5255 NewTL.setTypeofLoc(TL.getTypeofLoc());
5256 NewTL.setLParenLoc(TL.getLParenLoc());
5257 NewTL.setRParenLoc(TL.getRParenLoc());
5258 NewTL.setUnderlyingTInfo(New_Under_TI);
5263 template<typename Derived>
5264 QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
5265 DecltypeTypeLoc TL) {
5266 const DecltypeType *T = TL.getTypePtr();
5268 // decltype expressions are not potentially evaluated contexts
5269 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated,
5270 nullptr, /*IsDecltype=*/ true);
5272 ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
5276 E = getSema().ActOnDecltypeExpression(E.get());
5280 QualType Result = TL.getType();
5281 if (getDerived().AlwaysRebuild() ||
5282 E.get() != T->getUnderlyingExpr()) {
5283 Result = getDerived().RebuildDecltypeType(E.get(), TL.getNameLoc());
5284 if (Result.isNull())
5289 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
5290 NewTL.setNameLoc(TL.getNameLoc());
5295 template<typename Derived>
5296 QualType TreeTransform<Derived>::TransformUnaryTransformType(
5297 TypeLocBuilder &TLB,
5298 UnaryTransformTypeLoc TL) {
5299 QualType Result = TL.getType();
5300 if (Result->isDependentType()) {
5301 const UnaryTransformType *T = TL.getTypePtr();
5303 getDerived().TransformType(TL.getUnderlyingTInfo())->getType();
5304 Result = getDerived().RebuildUnaryTransformType(NewBase,
5307 if (Result.isNull())
5311 UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result);
5312 NewTL.setKWLoc(TL.getKWLoc());
5313 NewTL.setParensRange(TL.getParensRange());
5314 NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo());
5318 template<typename Derived>
5319 QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
5321 const AutoType *T = TL.getTypePtr();
5322 QualType OldDeduced = T->getDeducedType();
5323 QualType NewDeduced;
5324 if (!OldDeduced.isNull()) {
5325 NewDeduced = getDerived().TransformType(OldDeduced);
5326 if (NewDeduced.isNull())
5330 QualType Result = TL.getType();
5331 if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
5332 T->isDependentType()) {
5333 Result = getDerived().RebuildAutoType(NewDeduced, T->getKeyword());
5334 if (Result.isNull())
5338 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
5339 NewTL.setNameLoc(TL.getNameLoc());
5344 template<typename Derived>
5345 QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,
5347 const RecordType *T = TL.getTypePtr();
5349 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5354 QualType Result = TL.getType();
5355 if (getDerived().AlwaysRebuild() ||
5356 Record != T->getDecl()) {
5357 Result = getDerived().RebuildRecordType(Record);
5358 if (Result.isNull())
5362 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
5363 NewTL.setNameLoc(TL.getNameLoc());
5368 template<typename Derived>
5369 QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
5371 const EnumType *T = TL.getTypePtr();
5373 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5378 QualType Result = TL.getType();
5379 if (getDerived().AlwaysRebuild() ||
5380 Enum != T->getDecl()) {
5381 Result = getDerived().RebuildEnumType(Enum);
5382 if (Result.isNull())
5386 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result);
5387 NewTL.setNameLoc(TL.getNameLoc());
5392 template<typename Derived>
5393 QualType TreeTransform<Derived>::TransformInjectedClassNameType(
5394 TypeLocBuilder &TLB,
5395 InjectedClassNameTypeLoc TL) {
5396 Decl *D = getDerived().TransformDecl(TL.getNameLoc(),
5397 TL.getTypePtr()->getDecl());
5398 if (!D) return QualType();
5400 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D));
5401 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc());
5405 template<typename Derived>
5406 QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
5407 TypeLocBuilder &TLB,
5408 TemplateTypeParmTypeLoc TL) {
5409 return TransformTypeSpecType(TLB, TL);
5412 template<typename Derived>
5413 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
5414 TypeLocBuilder &TLB,
5415 SubstTemplateTypeParmTypeLoc TL) {
5416 const SubstTemplateTypeParmType *T = TL.getTypePtr();
5418 // Substitute into the replacement type, which itself might involve something
5419 // that needs to be transformed. This only tends to occur with default
5420 // template arguments of template template parameters.
5421 TemporaryBase Rebase(*this, TL.getNameLoc(), DeclarationName());
5422 QualType Replacement = getDerived().TransformType(T->getReplacementType());
5423 if (Replacement.isNull())
5426 // Always canonicalize the replacement type.
5427 Replacement = SemaRef.Context.getCanonicalType(Replacement);
5429 = SemaRef.Context.getSubstTemplateTypeParmType(T->getReplacedParameter(),
5432 // Propagate type-source information.
5433 SubstTemplateTypeParmTypeLoc NewTL
5434 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
5435 NewTL.setNameLoc(TL.getNameLoc());
5440 template<typename Derived>
5441 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
5442 TypeLocBuilder &TLB,
5443 SubstTemplateTypeParmPackTypeLoc TL) {
5444 return TransformTypeSpecType(TLB, TL);
5447 template<typename Derived>
5448 QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
5449 TypeLocBuilder &TLB,
5450 TemplateSpecializationTypeLoc TL) {
5451 const TemplateSpecializationType *T = TL.getTypePtr();
5453 // The nested-name-specifier never matters in a TemplateSpecializationType,
5454 // because we can't have a dependent nested-name-specifier anyway.
5456 TemplateName Template
5457 = getDerived().TransformTemplateName(SS, T->getTemplateName(),
5458 TL.getTemplateNameLoc());
5459 if (Template.isNull())
5462 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template);
5465 template<typename Derived>
5466 QualType TreeTransform<Derived>::TransformAtomicType(TypeLocBuilder &TLB,
5468 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
5469 if (ValueType.isNull())
5472 QualType Result = TL.getType();
5473 if (getDerived().AlwaysRebuild() ||
5474 ValueType != TL.getValueLoc().getType()) {
5475 Result = getDerived().RebuildAtomicType(ValueType, TL.getKWLoc());
5476 if (Result.isNull())
5480 AtomicTypeLoc NewTL = TLB.push<AtomicTypeLoc>(Result);
5481 NewTL.setKWLoc(TL.getKWLoc());
5482 NewTL.setLParenLoc(TL.getLParenLoc());
5483 NewTL.setRParenLoc(TL.getRParenLoc());
5488 template <typename Derived>
5489 QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB,
5491 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
5492 if (ValueType.isNull())
5495 QualType Result = TL.getType();
5496 if (getDerived().AlwaysRebuild() || ValueType != TL.getValueLoc().getType()) {
5497 const PipeType *PT = Result->getAs<PipeType>();
5498 bool isReadPipe = PT->isReadOnly();
5499 Result = getDerived().RebuildPipeType(ValueType, TL.getKWLoc(), isReadPipe);
5500 if (Result.isNull())
5504 PipeTypeLoc NewTL = TLB.push<PipeTypeLoc>(Result);
5505 NewTL.setKWLoc(TL.getKWLoc());
5510 /// \brief Simple iterator that traverses the template arguments in a
5511 /// container that provides a \c getArgLoc() member function.
5513 /// This iterator is intended to be used with the iterator form of
5514 /// \c TreeTransform<Derived>::TransformTemplateArguments().
5515 template<typename ArgLocContainer>
5516 class TemplateArgumentLocContainerIterator {
5517 ArgLocContainer *Container;
5521 typedef TemplateArgumentLoc value_type;
5522 typedef TemplateArgumentLoc reference;
5523 typedef int difference_type;
5524 typedef std::input_iterator_tag iterator_category;
5527 TemplateArgumentLoc Arg;
5530 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }
5532 const TemplateArgumentLoc *operator->() const {
5538 TemplateArgumentLocContainerIterator() {}
5540 TemplateArgumentLocContainerIterator(ArgLocContainer &Container,
5542 : Container(&Container), Index(Index) { }
5544 TemplateArgumentLocContainerIterator &operator++() {
5549 TemplateArgumentLocContainerIterator operator++(int) {
5550 TemplateArgumentLocContainerIterator Old(*this);
5555 TemplateArgumentLoc operator*() const {
5556 return Container->getArgLoc(Index);
5559 pointer operator->() const {
5560 return pointer(Container->getArgLoc(Index));
5563 friend bool operator==(const TemplateArgumentLocContainerIterator &X,
5564 const TemplateArgumentLocContainerIterator &Y) {
5565 return X.Container == Y.Container && X.Index == Y.Index;
5568 friend bool operator!=(const TemplateArgumentLocContainerIterator &X,
5569 const TemplateArgumentLocContainerIterator &Y) {
5575 template <typename Derived>
5576 QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
5577 TypeLocBuilder &TLB,
5578 TemplateSpecializationTypeLoc TL,
5579 TemplateName Template) {
5580 TemplateArgumentListInfo NewTemplateArgs;
5581 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
5582 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
5583 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>
5585 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5586 ArgIterator(TL, TL.getNumArgs()),
5590 // FIXME: maybe don't rebuild if all the template arguments are the same.
5593 getDerived().RebuildTemplateSpecializationType(Template,
5594 TL.getTemplateNameLoc(),
5597 if (!Result.isNull()) {
5598 // Specializations of template template parameters are represented as
5599 // TemplateSpecializationTypes, and substitution of type alias templates
5600 // within a dependent context can transform them into
5601 // DependentTemplateSpecializationTypes.
5602 if (isa<DependentTemplateSpecializationType>(Result)) {
5603 DependentTemplateSpecializationTypeLoc NewTL
5604 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
5605 NewTL.setElaboratedKeywordLoc(SourceLocation());
5606 NewTL.setQualifierLoc(NestedNameSpecifierLoc());
5607 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5608 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5609 NewTL.setLAngleLoc(TL.getLAngleLoc());
5610 NewTL.setRAngleLoc(TL.getRAngleLoc());
5611 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
5612 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
5616 TemplateSpecializationTypeLoc NewTL
5617 = TLB.push<TemplateSpecializationTypeLoc>(Result);
5618 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5619 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5620 NewTL.setLAngleLoc(TL.getLAngleLoc());
5621 NewTL.setRAngleLoc(TL.getRAngleLoc());
5622 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
5623 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
5629 template <typename Derived>
5630 QualType TreeTransform<Derived>::TransformDependentTemplateSpecializationType(
5631 TypeLocBuilder &TLB,
5632 DependentTemplateSpecializationTypeLoc TL,
5633 TemplateName Template,
5635 TemplateArgumentListInfo NewTemplateArgs;
5636 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
5637 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
5638 typedef TemplateArgumentLocContainerIterator<
5639 DependentTemplateSpecializationTypeLoc> ArgIterator;
5640 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5641 ArgIterator(TL, TL.getNumArgs()),
5645 // FIXME: maybe don't rebuild if all the template arguments are the same.
5647 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
5649 = getSema().Context.getDependentTemplateSpecializationType(
5650 TL.getTypePtr()->getKeyword(),
5651 DTN->getQualifier(),
5652 DTN->getIdentifier(),
5655 DependentTemplateSpecializationTypeLoc NewTL
5656 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
5657 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5658 NewTL.setQualifierLoc(SS.getWithLocInContext(SemaRef.Context));
5659 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5660 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5661 NewTL.setLAngleLoc(TL.getLAngleLoc());
5662 NewTL.setRAngleLoc(TL.getRAngleLoc());
5663 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
5664 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
5669 = getDerived().RebuildTemplateSpecializationType(Template,
5670 TL.getTemplateNameLoc(),
5673 if (!Result.isNull()) {
5674 /// FIXME: Wrap this in an elaborated-type-specifier?
5675 TemplateSpecializationTypeLoc NewTL
5676 = TLB.push<TemplateSpecializationTypeLoc>(Result);
5677 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5678 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5679 NewTL.setLAngleLoc(TL.getLAngleLoc());
5680 NewTL.setRAngleLoc(TL.getRAngleLoc());
5681 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
5682 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
5688 template<typename Derived>
5690 TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB,
5691 ElaboratedTypeLoc TL) {
5692 const ElaboratedType *T = TL.getTypePtr();
5694 NestedNameSpecifierLoc QualifierLoc;
5695 // NOTE: the qualifier in an ElaboratedType is optional.
5696 if (TL.getQualifierLoc()) {
5698 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
5703 QualType NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc());
5704 if (NamedT.isNull())
5707 // C++0x [dcl.type.elab]p2:
5708 // If the identifier resolves to a typedef-name or the simple-template-id
5709 // resolves to an alias template specialization, the
5710 // elaborated-type-specifier is ill-formed.
5711 if (T->getKeyword() != ETK_None && T->getKeyword() != ETK_Typename) {
5712 if (const TemplateSpecializationType *TST =
5713 NamedT->getAs<TemplateSpecializationType>()) {
5714 TemplateName Template = TST->getTemplateName();
5715 if (TypeAliasTemplateDecl *TAT = dyn_cast_or_null<TypeAliasTemplateDecl>(
5716 Template.getAsTemplateDecl())) {
5717 SemaRef.Diag(TL.getNamedTypeLoc().getBeginLoc(),
5718 diag::err_tag_reference_non_tag)
5719 << TAT << Sema::NTK_TypeAliasTemplate
5720 << ElaboratedType::getTagTypeKindForKeyword(T->getKeyword());
5721 SemaRef.Diag(TAT->getLocation(), diag::note_declared_at);
5726 QualType Result = TL.getType();
5727 if (getDerived().AlwaysRebuild() ||
5728 QualifierLoc != TL.getQualifierLoc() ||
5729 NamedT != T->getNamedType()) {
5730 Result = getDerived().RebuildElaboratedType(TL.getElaboratedKeywordLoc(),
5732 QualifierLoc, NamedT);
5733 if (Result.isNull())
5737 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
5738 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5739 NewTL.setQualifierLoc(QualifierLoc);
5743 template<typename Derived>
5744 QualType TreeTransform<Derived>::TransformAttributedType(
5745 TypeLocBuilder &TLB,
5746 AttributedTypeLoc TL) {
5747 const AttributedType *oldType = TL.getTypePtr();
5748 QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc());
5749 if (modifiedType.isNull())
5752 QualType result = TL.getType();
5754 // FIXME: dependent operand expressions?
5755 if (getDerived().AlwaysRebuild() ||
5756 modifiedType != oldType->getModifiedType()) {
5757 // TODO: this is really lame; we should really be rebuilding the
5758 // equivalent type from first principles.
5759 QualType equivalentType
5760 = getDerived().TransformType(oldType->getEquivalentType());
5761 if (equivalentType.isNull())
5764 // Check whether we can add nullability; it is only represented as
5765 // type sugar, and therefore cannot be diagnosed in any other way.
5766 if (auto nullability = oldType->getImmediateNullability()) {
5767 if (!modifiedType->canHaveNullability()) {
5768 SemaRef.Diag(TL.getAttrNameLoc(), diag::err_nullability_nonpointer)
5769 << DiagNullabilityKind(*nullability, false) << modifiedType;
5774 result = SemaRef.Context.getAttributedType(oldType->getAttrKind(),
5779 AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result);
5780 newTL.setAttrNameLoc(TL.getAttrNameLoc());
5781 if (TL.hasAttrOperand())
5782 newTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5783 if (TL.hasAttrExprOperand())
5784 newTL.setAttrExprOperand(TL.getAttrExprOperand());
5785 else if (TL.hasAttrEnumOperand())
5786 newTL.setAttrEnumOperandLoc(TL.getAttrEnumOperandLoc());
5791 template<typename Derived>
5793 TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB,
5795 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
5799 QualType Result = TL.getType();
5800 if (getDerived().AlwaysRebuild() ||
5801 Inner != TL.getInnerLoc().getType()) {
5802 Result = getDerived().RebuildParenType(Inner);
5803 if (Result.isNull())
5807 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result);
5808 NewTL.setLParenLoc(TL.getLParenLoc());
5809 NewTL.setRParenLoc(TL.getRParenLoc());
5813 template<typename Derived>
5814 QualType TreeTransform<Derived>::TransformDependentNameType(TypeLocBuilder &TLB,
5815 DependentNameTypeLoc TL) {
5816 const DependentNameType *T = TL.getTypePtr();
5818 NestedNameSpecifierLoc QualifierLoc
5819 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
5824 = getDerived().RebuildDependentNameType(T->getKeyword(),
5825 TL.getElaboratedKeywordLoc(),
5829 if (Result.isNull())
5832 if (const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) {
5833 QualType NamedT = ElabT->getNamedType();
5834 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc());
5836 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
5837 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5838 NewTL.setQualifierLoc(QualifierLoc);
5840 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result);
5841 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5842 NewTL.setQualifierLoc(QualifierLoc);
5843 NewTL.setNameLoc(TL.getNameLoc());
5848 template<typename Derived>
5849 QualType TreeTransform<Derived>::
5850 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
5851 DependentTemplateSpecializationTypeLoc TL) {
5852 NestedNameSpecifierLoc QualifierLoc;
5853 if (TL.getQualifierLoc()) {
5855 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
5861 .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc);
5864 template<typename Derived>
5865 QualType TreeTransform<Derived>::
5866 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
5867 DependentTemplateSpecializationTypeLoc TL,
5868 NestedNameSpecifierLoc QualifierLoc) {
5869 const DependentTemplateSpecializationType *T = TL.getTypePtr();
5871 TemplateArgumentListInfo NewTemplateArgs;
5872 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
5873 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
5875 typedef TemplateArgumentLocContainerIterator<
5876 DependentTemplateSpecializationTypeLoc> ArgIterator;
5877 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
5878 ArgIterator(TL, TL.getNumArgs()),
5883 = getDerived().RebuildDependentTemplateSpecializationType(T->getKeyword(),
5886 TL.getTemplateNameLoc(),
5888 if (Result.isNull())
5891 if (const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) {
5892 QualType NamedT = ElabT->getNamedType();
5894 // Copy information relevant to the template specialization.
5895 TemplateSpecializationTypeLoc NamedTL
5896 = TLB.push<TemplateSpecializationTypeLoc>(NamedT);
5897 NamedTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5898 NamedTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5899 NamedTL.setLAngleLoc(TL.getLAngleLoc());
5900 NamedTL.setRAngleLoc(TL.getRAngleLoc());
5901 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
5902 NamedTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
5904 // Copy information relevant to the elaborated type.
5905 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
5906 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5907 NewTL.setQualifierLoc(QualifierLoc);
5908 } else if (isa<DependentTemplateSpecializationType>(Result)) {
5909 DependentTemplateSpecializationTypeLoc SpecTL
5910 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
5911 SpecTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
5912 SpecTL.setQualifierLoc(QualifierLoc);
5913 SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5914 SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5915 SpecTL.setLAngleLoc(TL.getLAngleLoc());
5916 SpecTL.setRAngleLoc(TL.getRAngleLoc());
5917 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
5918 SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
5920 TemplateSpecializationTypeLoc SpecTL
5921 = TLB.push<TemplateSpecializationTypeLoc>(Result);
5922 SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
5923 SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc());
5924 SpecTL.setLAngleLoc(TL.getLAngleLoc());
5925 SpecTL.setRAngleLoc(TL.getRAngleLoc());
5926 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
5927 SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
5932 template<typename Derived>
5933 QualType TreeTransform<Derived>::TransformPackExpansionType(TypeLocBuilder &TLB,
5934 PackExpansionTypeLoc TL) {
5936 = getDerived().TransformType(TLB, TL.getPatternLoc());
5937 if (Pattern.isNull())
5940 QualType Result = TL.getType();
5941 if (getDerived().AlwaysRebuild() ||
5942 Pattern != TL.getPatternLoc().getType()) {
5943 Result = getDerived().RebuildPackExpansionType(Pattern,
5944 TL.getPatternLoc().getSourceRange(),
5945 TL.getEllipsisLoc(),
5946 TL.getTypePtr()->getNumExpansions());
5947 if (Result.isNull())
5951 PackExpansionTypeLoc NewT = TLB.push<PackExpansionTypeLoc>(Result);
5952 NewT.setEllipsisLoc(TL.getEllipsisLoc());
5956 template<typename Derived>
5958 TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
5959 ObjCInterfaceTypeLoc TL) {
5960 // ObjCInterfaceType is never dependent.
5961 TLB.pushFullCopy(TL);
5962 return TL.getType();
5965 template<typename Derived>
5967 TreeTransform<Derived>::TransformObjCTypeParamType(TypeLocBuilder &TLB,
5968 ObjCTypeParamTypeLoc TL) {
5969 const ObjCTypeParamType *T = TL.getTypePtr();
5970 ObjCTypeParamDecl *OTP = cast_or_null<ObjCTypeParamDecl>(
5971 getDerived().TransformDecl(T->getDecl()->getLocation(), T->getDecl()));
5975 QualType Result = TL.getType();
5976 if (getDerived().AlwaysRebuild() ||
5977 OTP != T->getDecl()) {
5978 Result = getDerived().RebuildObjCTypeParamType(OTP,
5979 TL.getProtocolLAngleLoc(),
5980 llvm::makeArrayRef(TL.getTypePtr()->qual_begin(),
5981 TL.getNumProtocols()),
5982 TL.getProtocolLocs(),
5983 TL.getProtocolRAngleLoc());
5984 if (Result.isNull())
5988 ObjCTypeParamTypeLoc NewTL = TLB.push<ObjCTypeParamTypeLoc>(Result);
5989 if (TL.getNumProtocols()) {
5990 NewTL.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
5991 for (unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
5992 NewTL.setProtocolLoc(i, TL.getProtocolLoc(i));
5993 NewTL.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
5998 template<typename Derived>
6000 TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
6001 ObjCObjectTypeLoc TL) {
6002 // Transform base type.
6003 QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc());
6004 if (BaseType.isNull())
6007 bool AnyChanged = BaseType != TL.getBaseLoc().getType();
6009 // Transform type arguments.
6010 SmallVector<TypeSourceInfo *, 4> NewTypeArgInfos;
6011 for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) {
6012 TypeSourceInfo *TypeArgInfo = TL.getTypeArgTInfo(i);
6013 TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc();
6014 QualType TypeArg = TypeArgInfo->getType();
6015 if (auto PackExpansionLoc = TypeArgLoc.getAs<PackExpansionTypeLoc>()) {
6018 // We have a pack expansion. Instantiate it.
6019 const auto *PackExpansion = PackExpansionLoc.getType()
6020 ->castAs<PackExpansionType>();
6021 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
6022 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
6024 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
6026 // Determine whether the set of unexpanded parameter packs can
6027 // and should be expanded.
6028 TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc();
6029 bool Expand = false;
6030 bool RetainExpansion = false;
6031 Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
6032 if (getDerived().TryExpandParameterPacks(
6033 PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(),
6034 Unexpanded, Expand, RetainExpansion, NumExpansions))
6038 // We can't expand this pack expansion into separate arguments yet;
6039 // just substitute into the pattern and create a new pack expansion
6041 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
6043 TypeLocBuilder TypeArgBuilder;
6044 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
6045 QualType NewPatternType = getDerived().TransformType(TypeArgBuilder,
6047 if (NewPatternType.isNull())
6050 QualType NewExpansionType = SemaRef.Context.getPackExpansionType(
6051 NewPatternType, NumExpansions);
6052 auto NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(NewExpansionType);
6053 NewExpansionLoc.setEllipsisLoc(PackExpansionLoc.getEllipsisLoc());
6054 NewTypeArgInfos.push_back(
6055 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewExpansionType));
6059 // Substitute into the pack expansion pattern for each slice of the
6061 for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
6062 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);
6064 TypeLocBuilder TypeArgBuilder;
6065 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
6067 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder,
6069 if (NewTypeArg.isNull())
6072 NewTypeArgInfos.push_back(
6073 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
6079 TypeLocBuilder TypeArgBuilder;
6080 TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize());
6081 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder, TypeArgLoc);
6082 if (NewTypeArg.isNull())
6085 // If nothing changed, just keep the old TypeSourceInfo.
6086 if (NewTypeArg == TypeArg) {
6087 NewTypeArgInfos.push_back(TypeArgInfo);
6091 NewTypeArgInfos.push_back(
6092 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
6096 QualType Result = TL.getType();
6097 if (getDerived().AlwaysRebuild() || AnyChanged) {
6098 // Rebuild the type.
6099 Result = getDerived().RebuildObjCObjectType(
6102 TL.getTypeArgsLAngleLoc(),
6104 TL.getTypeArgsRAngleLoc(),
6105 TL.getProtocolLAngleLoc(),
6106 llvm::makeArrayRef(TL.getTypePtr()->qual_begin(),
6107 TL.getNumProtocols()),
6108 TL.getProtocolLocs(),
6109 TL.getProtocolRAngleLoc());
6111 if (Result.isNull())
6115 ObjCObjectTypeLoc NewT = TLB.push<ObjCObjectTypeLoc>(Result);
6116 NewT.setHasBaseTypeAsWritten(true);
6117 NewT.setTypeArgsLAngleLoc(TL.getTypeArgsLAngleLoc());
6118 for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)
6119 NewT.setTypeArgTInfo(i, NewTypeArgInfos[i]);
6120 NewT.setTypeArgsRAngleLoc(TL.getTypeArgsRAngleLoc());
6121 NewT.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
6122 for (unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
6123 NewT.setProtocolLoc(i, TL.getProtocolLoc(i));
6124 NewT.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
6128 template<typename Derived>
6130 TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
6131 ObjCObjectPointerTypeLoc TL) {
6132 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
6133 if (PointeeType.isNull())
6136 QualType Result = TL.getType();
6137 if (getDerived().AlwaysRebuild() ||
6138 PointeeType != TL.getPointeeLoc().getType()) {
6139 Result = getDerived().RebuildObjCObjectPointerType(PointeeType,
6141 if (Result.isNull())
6145 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
6146 NewT.setStarLoc(TL.getStarLoc());
6150 //===----------------------------------------------------------------------===//
6151 // Statement transformation
6152 //===----------------------------------------------------------------------===//
6153 template<typename Derived>
6155 TreeTransform<Derived>::TransformNullStmt(NullStmt *S) {
6159 template<typename Derived>
6161 TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) {
6162 return getDerived().TransformCompoundStmt(S, false);
6165 template<typename Derived>
6167 TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S,
6169 Sema::CompoundScopeRAII CompoundScope(getSema());
6171 bool SubStmtInvalid = false;
6172 bool SubStmtChanged = false;
6173 SmallVector<Stmt*, 8> Statements;
6174 for (auto *B : S->body()) {
6175 StmtResult Result = getDerived().TransformStmt(B);
6176 if (Result.isInvalid()) {
6177 // Immediately fail if this was a DeclStmt, since it's very
6178 // likely that this will cause problems for future statements.
6179 if (isa<DeclStmt>(B))
6182 // Otherwise, just keep processing substatements and fail later.
6183 SubStmtInvalid = true;
6187 SubStmtChanged = SubStmtChanged || Result.get() != B;
6188 Statements.push_back(Result.getAs<Stmt>());
6194 if (!getDerived().AlwaysRebuild() &&
6198 return getDerived().RebuildCompoundStmt(S->getLBracLoc(),
6204 template<typename Derived>
6206 TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
6207 ExprResult LHS, RHS;
6209 EnterExpressionEvaluationContext Unevaluated(SemaRef,
6210 Sema::ConstantEvaluated);
6212 // Transform the left-hand case value.
6213 LHS = getDerived().TransformExpr(S->getLHS());
6214 LHS = SemaRef.ActOnConstantExpression(LHS);
6215 if (LHS.isInvalid())
6218 // Transform the right-hand case value (for the GNU case-range extension).
6219 RHS = getDerived().TransformExpr(S->getRHS());
6220 RHS = SemaRef.ActOnConstantExpression(RHS);
6221 if (RHS.isInvalid())
6225 // Build the case statement.
6226 // Case statements are always rebuilt so that they will attached to their
6227 // transformed switch statement.
6228 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
6230 S->getEllipsisLoc(),
6233 if (Case.isInvalid())
6236 // Transform the statement following the case
6237 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6238 if (SubStmt.isInvalid())
6241 // Attach the body to the case statement
6242 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get());
6245 template<typename Derived>
6247 TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
6248 // Transform the statement following the default case
6249 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6250 if (SubStmt.isInvalid())
6253 // Default statements are always rebuilt
6254 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
6258 template<typename Derived>
6260 TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) {
6261 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6262 if (SubStmt.isInvalid())
6265 Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(),
6271 // FIXME: Pass the real colon location in.
6272 return getDerived().RebuildLabelStmt(S->getIdentLoc(),
6273 cast<LabelDecl>(LD), SourceLocation(),
6277 template <typename Derived>
6278 const Attr *TreeTransform<Derived>::TransformAttr(const Attr *R) {
6282 switch (R->getKind()) {
6283 // Transform attributes with a pragma spelling by calling TransformXXXAttr.
6285 #define PRAGMA_SPELLING_ATTR(X) \
6287 return getDerived().Transform##X##Attr(cast<X##Attr>(R));
6288 #include "clang/Basic/AttrList.inc"
6294 template <typename Derived>
6295 StmtResult TreeTransform<Derived>::TransformAttributedStmt(AttributedStmt *S) {
6296 bool AttrsChanged = false;
6297 SmallVector<const Attr *, 1> Attrs;
6299 // Visit attributes and keep track if any are transformed.
6300 for (const auto *I : S->getAttrs()) {
6301 const Attr *R = getDerived().TransformAttr(I);
6302 AttrsChanged |= (I != R);
6306 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
6307 if (SubStmt.isInvalid())
6310 if (SubStmt.get() == S->getSubStmt() && !AttrsChanged)
6313 return getDerived().RebuildAttributedStmt(S->getAttrLoc(), Attrs,
6317 template<typename Derived>
6319 TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
6320 // Transform the initialization statement
6321 StmtResult Init = getDerived().TransformStmt(S->getInit());
6322 if (Init.isInvalid())
6325 // Transform the condition
6326 Sema::ConditionResult Cond = getDerived().TransformCondition(
6327 S->getIfLoc(), S->getConditionVariable(), S->getCond(),
6328 S->isConstexpr() ? Sema::ConditionKind::ConstexprIf
6329 : Sema::ConditionKind::Boolean);
6330 if (Cond.isInvalid())
6333 // If this is a constexpr if, determine which arm we should instantiate.
6334 llvm::Optional<bool> ConstexprConditionValue;
6335 if (S->isConstexpr())
6336 ConstexprConditionValue = Cond.getKnownValue();
6338 // Transform the "then" branch.
6340 if (!ConstexprConditionValue || *ConstexprConditionValue) {
6341 Then = getDerived().TransformStmt(S->getThen());
6342 if (Then.isInvalid())
6345 Then = new (getSema().Context) NullStmt(S->getThen()->getLocStart());
6348 // Transform the "else" branch.
6350 if (!ConstexprConditionValue || !*ConstexprConditionValue) {
6351 Else = getDerived().TransformStmt(S->getElse());
6352 if (Else.isInvalid())
6356 if (!getDerived().AlwaysRebuild() &&
6357 Init.get() == S->getInit() &&
6358 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
6359 Then.get() == S->getThen() &&
6360 Else.get() == S->getElse())
6363 return getDerived().RebuildIfStmt(S->getIfLoc(), S->isConstexpr(), Cond,
6364 Init.get(), Then.get(), S->getElseLoc(),
6368 template<typename Derived>
6370 TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
6371 // Transform the initialization statement
6372 StmtResult Init = getDerived().TransformStmt(S->getInit());
6373 if (Init.isInvalid())
6376 // Transform the condition.
6377 Sema::ConditionResult Cond = getDerived().TransformCondition(
6378 S->getSwitchLoc(), S->getConditionVariable(), S->getCond(),
6379 Sema::ConditionKind::Switch);
6380 if (Cond.isInvalid())
6383 // Rebuild the switch statement.
6385 = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(),
6386 S->getInit(), Cond);
6387 if (Switch.isInvalid())
6390 // Transform the body of the switch statement.
6391 StmtResult Body = getDerived().TransformStmt(S->getBody());
6392 if (Body.isInvalid())
6395 // Complete the switch statement.
6396 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(),
6400 template<typename Derived>
6402 TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
6403 // Transform the condition
6404 Sema::ConditionResult Cond = getDerived().TransformCondition(
6405 S->getWhileLoc(), S->getConditionVariable(), S->getCond(),
6406 Sema::ConditionKind::Boolean);
6407 if (Cond.isInvalid())
6410 // Transform the body
6411 StmtResult Body = getDerived().TransformStmt(S->getBody());
6412 if (Body.isInvalid())
6415 if (!getDerived().AlwaysRebuild() &&
6416 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
6417 Body.get() == S->getBody())
6420 return getDerived().RebuildWhileStmt(S->getWhileLoc(), Cond, Body.get());
6423 template<typename Derived>
6425 TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
6426 // Transform the body
6427 StmtResult Body = getDerived().TransformStmt(S->getBody());
6428 if (Body.isInvalid())
6431 // Transform the condition
6432 ExprResult Cond = getDerived().TransformExpr(S->getCond());
6433 if (Cond.isInvalid())
6436 if (!getDerived().AlwaysRebuild() &&
6437 Cond.get() == S->getCond() &&
6438 Body.get() == S->getBody())
6441 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(),
6442 /*FIXME:*/S->getWhileLoc(), Cond.get(),
6446 template<typename Derived>
6448 TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
6449 // Transform the initialization statement
6450 StmtResult Init = getDerived().TransformStmt(S->getInit());
6451 if (Init.isInvalid())
6454 // In OpenMP loop region loop control variable must be captured and be
6455 // private. Perform analysis of first part (if any).
6456 if (getSema().getLangOpts().OpenMP && Init.isUsable())
6457 getSema().ActOnOpenMPLoopInitialization(S->getForLoc(), Init.get());
6459 // Transform the condition
6460 Sema::ConditionResult Cond = getDerived().TransformCondition(
6461 S->getForLoc(), S->getConditionVariable(), S->getCond(),
6462 Sema::ConditionKind::Boolean);
6463 if (Cond.isInvalid())
6466 // Transform the increment
6467 ExprResult Inc = getDerived().TransformExpr(S->getInc());
6468 if (Inc.isInvalid())
6471 Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(Inc.get()));
6472 if (S->getInc() && !FullInc.get())
6475 // Transform the body
6476 StmtResult Body = getDerived().TransformStmt(S->getBody());
6477 if (Body.isInvalid())
6480 if (!getDerived().AlwaysRebuild() &&
6481 Init.get() == S->getInit() &&
6482 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
6483 Inc.get() == S->getInc() &&
6484 Body.get() == S->getBody())
6487 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
6488 Init.get(), Cond, FullInc,
6489 S->getRParenLoc(), Body.get());
6492 template<typename Derived>
6494 TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
6495 Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(),
6500 // Goto statements must always be rebuilt, to resolve the label.
6501 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
6502 cast<LabelDecl>(LD));
6505 template<typename Derived>
6507 TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
6508 ExprResult Target = getDerived().TransformExpr(S->getTarget());
6509 if (Target.isInvalid())
6511 Target = SemaRef.MaybeCreateExprWithCleanups(Target.get());
6513 if (!getDerived().AlwaysRebuild() &&
6514 Target.get() == S->getTarget())
6517 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
6521 template<typename Derived>
6523 TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
6527 template<typename Derived>
6529 TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
6533 template<typename Derived>
6535 TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
6536 ExprResult Result = getDerived().TransformInitializer(S->getRetValue(),
6537 /*NotCopyInit*/false);
6538 if (Result.isInvalid())
6541 // FIXME: We always rebuild the return statement because there is no way
6542 // to tell whether the return type of the function has changed.
6543 return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get());
6546 template<typename Derived>
6548 TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
6549 bool DeclChanged = false;
6550 SmallVector<Decl *, 4> Decls;
6551 for (auto *D : S->decls()) {
6552 Decl *Transformed = getDerived().TransformDefinition(D->getLocation(), D);
6556 if (Transformed != D)
6559 Decls.push_back(Transformed);
6562 if (!getDerived().AlwaysRebuild() && !DeclChanged)
6565 return getDerived().RebuildDeclStmt(Decls, S->getStartLoc(), S->getEndLoc());
6568 template<typename Derived>
6570 TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) {
6572 SmallVector<Expr*, 8> Constraints;
6573 SmallVector<Expr*, 8> Exprs;
6574 SmallVector<IdentifierInfo *, 4> Names;
6576 ExprResult AsmString;
6577 SmallVector<Expr*, 8> Clobbers;
6579 bool ExprsChanged = false;
6581 // Go through the outputs.
6582 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) {
6583 Names.push_back(S->getOutputIdentifier(I));
6585 // No need to transform the constraint literal.
6586 Constraints.push_back(S->getOutputConstraintLiteral(I));
6588 // Transform the output expr.
6589 Expr *OutputExpr = S->getOutputExpr(I);
6590 ExprResult Result = getDerived().TransformExpr(OutputExpr);
6591 if (Result.isInvalid())
6594 ExprsChanged |= Result.get() != OutputExpr;
6596 Exprs.push_back(Result.get());
6599 // Go through the inputs.
6600 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) {
6601 Names.push_back(S->getInputIdentifier(I));
6603 // No need to transform the constraint literal.
6604 Constraints.push_back(S->getInputConstraintLiteral(I));
6606 // Transform the input expr.
6607 Expr *InputExpr = S->getInputExpr(I);
6608 ExprResult Result = getDerived().TransformExpr(InputExpr);
6609 if (Result.isInvalid())
6612 ExprsChanged |= Result.get() != InputExpr;
6614 Exprs.push_back(Result.get());
6617 if (!getDerived().AlwaysRebuild() && !ExprsChanged)
6620 // Go through the clobbers.
6621 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I)
6622 Clobbers.push_back(S->getClobberStringLiteral(I));
6624 // No need to transform the asm string literal.
6625 AsmString = S->getAsmString();
6626 return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(),
6627 S->isVolatile(), S->getNumOutputs(),
6628 S->getNumInputs(), Names.data(),
6629 Constraints, Exprs, AsmString.get(),
6630 Clobbers, S->getRParenLoc());
6633 template<typename Derived>
6635 TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
6636 ArrayRef<Token> AsmToks =
6637 llvm::makeArrayRef(S->getAsmToks(), S->getNumAsmToks());
6639 bool HadError = false, HadChange = false;
6641 ArrayRef<Expr*> SrcExprs = S->getAllExprs();
6642 SmallVector<Expr*, 8> TransformedExprs;
6643 TransformedExprs.reserve(SrcExprs.size());
6644 for (unsigned i = 0, e = SrcExprs.size(); i != e; ++i) {
6645 ExprResult Result = getDerived().TransformExpr(SrcExprs[i]);
6646 if (!Result.isUsable()) {
6649 HadChange |= (Result.get() != SrcExprs[i]);
6650 TransformedExprs.push_back(Result.get());
6654 if (HadError) return StmtError();
6655 if (!HadChange && !getDerived().AlwaysRebuild())
6658 return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(),
6659 AsmToks, S->getAsmString(),
6660 S->getNumOutputs(), S->getNumInputs(),
6661 S->getAllConstraints(), S->getClobbers(),
6662 TransformedExprs, S->getEndLoc());
6665 // C++ Coroutines TS
6667 template<typename Derived>
6669 TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) {
6670 // The coroutine body should be re-formed by the caller if necessary.
6671 // FIXME: The coroutine body is always rebuilt by ActOnFinishFunctionBody
6672 return getDerived().TransformStmt(S->getBody());
6675 template<typename Derived>
6677 TreeTransform<Derived>::TransformCoreturnStmt(CoreturnStmt *S) {
6678 ExprResult Result = getDerived().TransformInitializer(S->getOperand(),
6679 /*NotCopyInit*/false);
6680 if (Result.isInvalid())
6683 // Always rebuild; we don't know if this needs to be injected into a new
6684 // context or if the promise type has changed.
6685 return getDerived().RebuildCoreturnStmt(S->getKeywordLoc(), Result.get());
6688 template<typename Derived>
6690 TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *E) {
6691 ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
6692 /*NotCopyInit*/false);
6693 if (Result.isInvalid())
6696 // Always rebuild; we don't know if this needs to be injected into a new
6697 // context or if the promise type has changed.
6698 return getDerived().RebuildCoawaitExpr(E->getKeywordLoc(), Result.get());
6701 template<typename Derived>
6703 TreeTransform<Derived>::TransformCoyieldExpr(CoyieldExpr *E) {
6704 ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
6705 /*NotCopyInit*/false);
6706 if (Result.isInvalid())
6709 // Always rebuild; we don't know if this needs to be injected into a new
6710 // context or if the promise type has changed.
6711 return getDerived().RebuildCoyieldExpr(E->getKeywordLoc(), Result.get());
6714 // Objective-C Statements.
6716 template<typename Derived>
6718 TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
6719 // Transform the body of the @try.
6720 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
6721 if (TryBody.isInvalid())
6724 // Transform the @catch statements (if present).
6725 bool AnyCatchChanged = false;
6726 SmallVector<Stmt*, 8> CatchStmts;
6727 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
6728 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I));
6729 if (Catch.isInvalid())
6731 if (Catch.get() != S->getCatchStmt(I))
6732 AnyCatchChanged = true;
6733 CatchStmts.push_back(Catch.get());
6736 // Transform the @finally statement (if present).
6738 if (S->getFinallyStmt()) {
6739 Finally = getDerived().TransformStmt(S->getFinallyStmt());
6740 if (Finally.isInvalid())
6744 // If nothing changed, just retain this statement.
6745 if (!getDerived().AlwaysRebuild() &&
6746 TryBody.get() == S->getTryBody() &&
6748 Finally.get() == S->getFinallyStmt())
6751 // Build a new statement.
6752 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(),
6753 CatchStmts, Finally.get());
6756 template<typename Derived>
6758 TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
6759 // Transform the @catch parameter, if there is one.
6760 VarDecl *Var = nullptr;
6761 if (VarDecl *FromVar = S->getCatchParamDecl()) {
6762 TypeSourceInfo *TSInfo = nullptr;
6763 if (FromVar->getTypeSourceInfo()) {
6764 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
6771 T = TSInfo->getType();
6773 T = getDerived().TransformType(FromVar->getType());
6778 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T);
6783 StmtResult Body = getDerived().TransformStmt(S->getCatchBody());
6784 if (Body.isInvalid())
6787 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
6792 template<typename Derived>
6794 TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
6795 // Transform the body.
6796 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
6797 if (Body.isInvalid())
6800 // If nothing changed, just retain this statement.
6801 if (!getDerived().AlwaysRebuild() &&
6802 Body.get() == S->getFinallyBody())
6805 // Build a new statement.
6806 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
6810 template<typename Derived>
6812 TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
6814 if (S->getThrowExpr()) {
6815 Operand = getDerived().TransformExpr(S->getThrowExpr());
6816 if (Operand.isInvalid())
6820 if (!getDerived().AlwaysRebuild() &&
6821 Operand.get() == S->getThrowExpr())
6824 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get());
6827 template<typename Derived>
6829 TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
6830 ObjCAtSynchronizedStmt *S) {
6831 // Transform the object we are locking.
6832 ExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
6833 if (Object.isInvalid())
6836 getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(),
6838 if (Object.isInvalid())
6841 // Transform the body.
6842 StmtResult Body = getDerived().TransformStmt(S->getSynchBody());
6843 if (Body.isInvalid())
6846 // If nothing change, just retain the current statement.
6847 if (!getDerived().AlwaysRebuild() &&
6848 Object.get() == S->getSynchExpr() &&
6849 Body.get() == S->getSynchBody())
6852 // Build a new statement.
6853 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
6854 Object.get(), Body.get());
6857 template<typename Derived>
6859 TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt(
6860 ObjCAutoreleasePoolStmt *S) {
6861 // Transform the body.
6862 StmtResult Body = getDerived().TransformStmt(S->getSubStmt());
6863 if (Body.isInvalid())
6866 // If nothing changed, just retain this statement.
6867 if (!getDerived().AlwaysRebuild() &&
6868 Body.get() == S->getSubStmt())
6871 // Build a new statement.
6872 return getDerived().RebuildObjCAutoreleasePoolStmt(
6873 S->getAtLoc(), Body.get());
6876 template<typename Derived>
6878 TreeTransform<Derived>::TransformObjCForCollectionStmt(
6879 ObjCForCollectionStmt *S) {
6880 // Transform the element statement.
6881 StmtResult Element = getDerived().TransformStmt(S->getElement());
6882 if (Element.isInvalid())
6885 // Transform the collection expression.
6886 ExprResult Collection = getDerived().TransformExpr(S->getCollection());
6887 if (Collection.isInvalid())
6890 // Transform the body.
6891 StmtResult Body = getDerived().TransformStmt(S->getBody());
6892 if (Body.isInvalid())
6895 // If nothing changed, just retain this statement.
6896 if (!getDerived().AlwaysRebuild() &&
6897 Element.get() == S->getElement() &&
6898 Collection.get() == S->getCollection() &&
6899 Body.get() == S->getBody())
6902 // Build a new statement.
6903 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
6910 template <typename Derived>
6911 StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
6912 // Transform the exception declaration, if any.
6913 VarDecl *Var = nullptr;
6914 if (VarDecl *ExceptionDecl = S->getExceptionDecl()) {
6916 getDerived().TransformType(ExceptionDecl->getTypeSourceInfo());
6920 Var = getDerived().RebuildExceptionDecl(
6921 ExceptionDecl, T, ExceptionDecl->getInnerLocStart(),
6922 ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier());
6923 if (!Var || Var->isInvalidDecl())
6927 // Transform the actual exception handler.
6928 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
6929 if (Handler.isInvalid())
6932 if (!getDerived().AlwaysRebuild() && !Var &&
6933 Handler.get() == S->getHandlerBlock())
6936 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get());
6939 template <typename Derived>
6940 StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
6941 // Transform the try block itself.
6942 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
6943 if (TryBlock.isInvalid())
6946 // Transform the handlers.
6947 bool HandlerChanged = false;
6948 SmallVector<Stmt *, 8> Handlers;
6949 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) {
6950 StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(I));
6951 if (Handler.isInvalid())
6954 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I);
6955 Handlers.push_back(Handler.getAs<Stmt>());
6958 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
6962 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(),
6966 template<typename Derived>
6968 TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) {
6969 StmtResult Range = getDerived().TransformStmt(S->getRangeStmt());
6970 if (Range.isInvalid())
6973 StmtResult Begin = getDerived().TransformStmt(S->getBeginStmt());
6974 if (Begin.isInvalid())
6976 StmtResult End = getDerived().TransformStmt(S->getEndStmt());
6977 if (End.isInvalid())
6980 ExprResult Cond = getDerived().TransformExpr(S->getCond());
6981 if (Cond.isInvalid())
6984 Cond = SemaRef.CheckBooleanCondition(S->getColonLoc(), Cond.get());
6985 if (Cond.isInvalid())
6988 Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.get());
6990 ExprResult Inc = getDerived().TransformExpr(S->getInc());
6991 if (Inc.isInvalid())
6994 Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.get());
6996 StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt());
6997 if (LoopVar.isInvalid())
7000 StmtResult NewStmt = S;
7001 if (getDerived().AlwaysRebuild() ||
7002 Range.get() != S->getRangeStmt() ||
7003 Begin.get() != S->getBeginStmt() ||
7004 End.get() != S->getEndStmt() ||
7005 Cond.get() != S->getCond() ||
7006 Inc.get() != S->getInc() ||
7007 LoopVar.get() != S->getLoopVarStmt()) {
7008 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
7010 S->getColonLoc(), Range.get(),
7011 Begin.get(), End.get(),
7013 Inc.get(), LoopVar.get(),
7015 if (NewStmt.isInvalid())
7019 StmtResult Body = getDerived().TransformStmt(S->getBody());
7020 if (Body.isInvalid())
7023 // Body has changed but we didn't rebuild the for-range statement. Rebuild
7024 // it now so we have a new statement to attach the body to.
7025 if (Body.get() != S->getBody() && NewStmt.get() == S) {
7026 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
7028 S->getColonLoc(), Range.get(),
7029 Begin.get(), End.get(),
7031 Inc.get(), LoopVar.get(),
7033 if (NewStmt.isInvalid())
7037 if (NewStmt.get() == S)
7040 return FinishCXXForRangeStmt(NewStmt.get(), Body.get());
7043 template<typename Derived>
7045 TreeTransform<Derived>::TransformMSDependentExistsStmt(
7046 MSDependentExistsStmt *S) {
7047 // Transform the nested-name-specifier, if any.
7048 NestedNameSpecifierLoc QualifierLoc;
7049 if (S->getQualifierLoc()) {
7051 = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc());
7056 // Transform the declaration name.
7057 DeclarationNameInfo NameInfo = S->getNameInfo();
7058 if (NameInfo.getName()) {
7059 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
7060 if (!NameInfo.getName())
7064 // Check whether anything changed.
7065 if (!getDerived().AlwaysRebuild() &&
7066 QualifierLoc == S->getQualifierLoc() &&
7067 NameInfo.getName() == S->getNameInfo().getName())
7070 // Determine whether this name exists, if we can.
7072 SS.Adopt(QualifierLoc);
7073 bool Dependent = false;
7074 switch (getSema().CheckMicrosoftIfExistsSymbol(/*S=*/nullptr, SS, NameInfo)) {
7075 case Sema::IER_Exists:
7076 if (S->isIfExists())
7079 return new (getSema().Context) NullStmt(S->getKeywordLoc());
7081 case Sema::IER_DoesNotExist:
7082 if (S->isIfNotExists())
7085 return new (getSema().Context) NullStmt(S->getKeywordLoc());
7087 case Sema::IER_Dependent:
7091 case Sema::IER_Error:
7095 // We need to continue with the instantiation, so do so now.
7096 StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt());
7097 if (SubStmt.isInvalid())
7100 // If we have resolved the name, just transform to the substatement.
7104 // The name is still dependent, so build a dependent expression again.
7105 return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(),
7112 template<typename Derived>
7114 TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *E) {
7115 NestedNameSpecifierLoc QualifierLoc;
7116 if (E->getQualifierLoc()) {
7118 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
7123 MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>(
7124 getDerived().TransformDecl(E->getMemberLoc(), E->getPropertyDecl()));
7128 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
7129 if (Base.isInvalid())
7132 return new (SemaRef.getASTContext())
7133 MSPropertyRefExpr(Base.get(), PD, E->isArrow(),
7134 SemaRef.getASTContext().PseudoObjectTy, VK_LValue,
7135 QualifierLoc, E->getMemberLoc());
7138 template <typename Derived>
7139 ExprResult TreeTransform<Derived>::TransformMSPropertySubscriptExpr(
7140 MSPropertySubscriptExpr *E) {
7141 auto BaseRes = getDerived().TransformExpr(E->getBase());
7142 if (BaseRes.isInvalid())
7144 auto IdxRes = getDerived().TransformExpr(E->getIdx());
7145 if (IdxRes.isInvalid())
7148 if (!getDerived().AlwaysRebuild() &&
7149 BaseRes.get() == E->getBase() &&
7150 IdxRes.get() == E->getIdx())
7153 return getDerived().RebuildArraySubscriptExpr(
7154 BaseRes.get(), SourceLocation(), IdxRes.get(), E->getRBracketLoc());
7157 template <typename Derived>
7158 StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) {
7159 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
7160 if (TryBlock.isInvalid())
7163 StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler());
7164 if (Handler.isInvalid())
7167 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
7168 Handler.get() == S->getHandler())
7171 return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(),
7172 TryBlock.get(), Handler.get());
7175 template <typename Derived>
7176 StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) {
7177 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
7178 if (Block.isInvalid())
7181 return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.get());
7184 template <typename Derived>
7185 StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) {
7186 ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr());
7187 if (FilterExpr.isInvalid())
7190 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
7191 if (Block.isInvalid())
7194 return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(),
7198 template <typename Derived>
7199 StmtResult TreeTransform<Derived>::TransformSEHHandler(Stmt *Handler) {
7200 if (isa<SEHFinallyStmt>(Handler))
7201 return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler));
7203 return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler));
7206 template<typename Derived>
7208 TreeTransform<Derived>::TransformSEHLeaveStmt(SEHLeaveStmt *S) {
7212 //===----------------------------------------------------------------------===//
7213 // OpenMP directive transformation
7214 //===----------------------------------------------------------------------===//
7215 template <typename Derived>
7216 StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective(
7217 OMPExecutableDirective *D) {
7219 // Transform the clauses
7220 llvm::SmallVector<OMPClause *, 16> TClauses;
7221 ArrayRef<OMPClause *> Clauses = D->clauses();
7222 TClauses.reserve(Clauses.size());
7223 for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
7226 getDerived().getSema().StartOpenMPClause((*I)->getClauseKind());
7227 OMPClause *Clause = getDerived().TransformOMPClause(*I);
7228 getDerived().getSema().EndOpenMPClause();
7230 TClauses.push_back(Clause);
7232 TClauses.push_back(nullptr);
7235 StmtResult AssociatedStmt;
7236 if (D->hasAssociatedStmt() && D->getAssociatedStmt()) {
7237 getDerived().getSema().ActOnOpenMPRegionStart(D->getDirectiveKind(),
7238 /*CurScope=*/nullptr);
7241 Sema::CompoundScopeRAII CompoundScope(getSema());
7242 Body = getDerived().TransformStmt(
7243 cast<CapturedStmt>(D->getAssociatedStmt())->getCapturedStmt());
7246 getDerived().getSema().ActOnOpenMPRegionEnd(Body, TClauses);
7247 if (AssociatedStmt.isInvalid()) {
7251 if (TClauses.size() != Clauses.size()) {
7255 // Transform directive name for 'omp critical' directive.
7256 DeclarationNameInfo DirName;
7257 if (D->getDirectiveKind() == OMPD_critical) {
7258 DirName = cast<OMPCriticalDirective>(D)->getDirectiveName();
7259 DirName = getDerived().TransformDeclarationNameInfo(DirName);
7261 OpenMPDirectiveKind CancelRegion = OMPD_unknown;
7262 if (D->getDirectiveKind() == OMPD_cancellation_point) {
7263 CancelRegion = cast<OMPCancellationPointDirective>(D)->getCancelRegion();
7264 } else if (D->getDirectiveKind() == OMPD_cancel) {
7265 CancelRegion = cast<OMPCancelDirective>(D)->getCancelRegion();
7268 return getDerived().RebuildOMPExecutableDirective(
7269 D->getDirectiveKind(), DirName, CancelRegion, TClauses,
7270 AssociatedStmt.get(), D->getLocStart(), D->getLocEnd());
7273 template <typename Derived>
7275 TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) {
7276 DeclarationNameInfo DirName;
7277 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel, DirName, nullptr,
7279 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7280 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7284 template <typename Derived>
7286 TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *D) {
7287 DeclarationNameInfo DirName;
7288 getDerived().getSema().StartOpenMPDSABlock(OMPD_simd, DirName, nullptr,
7290 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7291 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7295 template <typename Derived>
7297 TreeTransform<Derived>::TransformOMPForDirective(OMPForDirective *D) {
7298 DeclarationNameInfo DirName;
7299 getDerived().getSema().StartOpenMPDSABlock(OMPD_for, DirName, nullptr,
7301 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7302 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7306 template <typename Derived>
7308 TreeTransform<Derived>::TransformOMPForSimdDirective(OMPForSimdDirective *D) {
7309 DeclarationNameInfo DirName;
7310 getDerived().getSema().StartOpenMPDSABlock(OMPD_for_simd, DirName, nullptr,
7312 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7313 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7317 template <typename Derived>
7319 TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *D) {
7320 DeclarationNameInfo DirName;
7321 getDerived().getSema().StartOpenMPDSABlock(OMPD_sections, DirName, nullptr,
7323 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7324 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7328 template <typename Derived>
7330 TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *D) {
7331 DeclarationNameInfo DirName;
7332 getDerived().getSema().StartOpenMPDSABlock(OMPD_section, DirName, nullptr,
7334 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7335 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7339 template <typename Derived>
7341 TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *D) {
7342 DeclarationNameInfo DirName;
7343 getDerived().getSema().StartOpenMPDSABlock(OMPD_single, DirName, nullptr,
7345 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7346 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7350 template <typename Derived>
7352 TreeTransform<Derived>::TransformOMPMasterDirective(OMPMasterDirective *D) {
7353 DeclarationNameInfo DirName;
7354 getDerived().getSema().StartOpenMPDSABlock(OMPD_master, DirName, nullptr,
7356 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7357 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7361 template <typename Derived>
7363 TreeTransform<Derived>::TransformOMPCriticalDirective(OMPCriticalDirective *D) {
7364 getDerived().getSema().StartOpenMPDSABlock(
7365 OMPD_critical, D->getDirectiveName(), nullptr, D->getLocStart());
7366 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7367 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7371 template <typename Derived>
7372 StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective(
7373 OMPParallelForDirective *D) {
7374 DeclarationNameInfo DirName;
7375 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for, DirName,
7376 nullptr, D->getLocStart());
7377 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7378 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7382 template <typename Derived>
7383 StmtResult TreeTransform<Derived>::TransformOMPParallelForSimdDirective(
7384 OMPParallelForSimdDirective *D) {
7385 DeclarationNameInfo DirName;
7386 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for_simd, DirName,
7387 nullptr, D->getLocStart());
7388 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7389 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7393 template <typename Derived>
7394 StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective(
7395 OMPParallelSectionsDirective *D) {
7396 DeclarationNameInfo DirName;
7397 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_sections, DirName,
7398 nullptr, D->getLocStart());
7399 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7400 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7404 template <typename Derived>
7406 TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *D) {
7407 DeclarationNameInfo DirName;
7408 getDerived().getSema().StartOpenMPDSABlock(OMPD_task, DirName, nullptr,
7410 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7411 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7415 template <typename Derived>
7416 StmtResult TreeTransform<Derived>::TransformOMPTaskyieldDirective(
7417 OMPTaskyieldDirective *D) {
7418 DeclarationNameInfo DirName;
7419 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskyield, DirName, nullptr,
7421 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7422 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7426 template <typename Derived>
7428 TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *D) {
7429 DeclarationNameInfo DirName;
7430 getDerived().getSema().StartOpenMPDSABlock(OMPD_barrier, DirName, nullptr,
7432 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7433 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7437 template <typename Derived>
7439 TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
7440 DeclarationNameInfo DirName;
7441 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskwait, DirName, nullptr,
7443 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7444 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7448 template <typename Derived>
7449 StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective(
7450 OMPTaskgroupDirective *D) {
7451 DeclarationNameInfo DirName;
7452 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskgroup, DirName, nullptr,
7454 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7455 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7459 template <typename Derived>
7461 TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *D) {
7462 DeclarationNameInfo DirName;
7463 getDerived().getSema().StartOpenMPDSABlock(OMPD_flush, DirName, nullptr,
7465 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7466 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7470 template <typename Derived>
7472 TreeTransform<Derived>::TransformOMPOrderedDirective(OMPOrderedDirective *D) {
7473 DeclarationNameInfo DirName;
7474 getDerived().getSema().StartOpenMPDSABlock(OMPD_ordered, DirName, nullptr,
7476 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7477 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7481 template <typename Derived>
7483 TreeTransform<Derived>::TransformOMPAtomicDirective(OMPAtomicDirective *D) {
7484 DeclarationNameInfo DirName;
7485 getDerived().getSema().StartOpenMPDSABlock(OMPD_atomic, DirName, nullptr,
7487 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7488 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7492 template <typename Derived>
7494 TreeTransform<Derived>::TransformOMPTargetDirective(OMPTargetDirective *D) {
7495 DeclarationNameInfo DirName;
7496 getDerived().getSema().StartOpenMPDSABlock(OMPD_target, DirName, nullptr,
7498 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7499 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7503 template <typename Derived>
7504 StmtResult TreeTransform<Derived>::TransformOMPTargetDataDirective(
7505 OMPTargetDataDirective *D) {
7506 DeclarationNameInfo DirName;
7507 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_data, DirName, nullptr,
7509 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7510 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7514 template <typename Derived>
7515 StmtResult TreeTransform<Derived>::TransformOMPTargetEnterDataDirective(
7516 OMPTargetEnterDataDirective *D) {
7517 DeclarationNameInfo DirName;
7518 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_enter_data, DirName,
7519 nullptr, D->getLocStart());
7520 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7521 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7525 template <typename Derived>
7526 StmtResult TreeTransform<Derived>::TransformOMPTargetExitDataDirective(
7527 OMPTargetExitDataDirective *D) {
7528 DeclarationNameInfo DirName;
7529 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_exit_data, DirName,
7530 nullptr, D->getLocStart());
7531 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7532 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7536 template <typename Derived>
7537 StmtResult TreeTransform<Derived>::TransformOMPTargetParallelDirective(
7538 OMPTargetParallelDirective *D) {
7539 DeclarationNameInfo DirName;
7540 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel, DirName,
7541 nullptr, D->getLocStart());
7542 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7543 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7547 template <typename Derived>
7548 StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForDirective(
7549 OMPTargetParallelForDirective *D) {
7550 DeclarationNameInfo DirName;
7551 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel_for, DirName,
7552 nullptr, D->getLocStart());
7553 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7554 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7558 template <typename Derived>
7559 StmtResult TreeTransform<Derived>::TransformOMPTargetUpdateDirective(
7560 OMPTargetUpdateDirective *D) {
7561 DeclarationNameInfo DirName;
7562 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_update, DirName,
7563 nullptr, D->getLocStart());
7564 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7565 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7569 template <typename Derived>
7571 TreeTransform<Derived>::TransformOMPTeamsDirective(OMPTeamsDirective *D) {
7572 DeclarationNameInfo DirName;
7573 getDerived().getSema().StartOpenMPDSABlock(OMPD_teams, DirName, nullptr,
7575 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7576 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7580 template <typename Derived>
7581 StmtResult TreeTransform<Derived>::TransformOMPCancellationPointDirective(
7582 OMPCancellationPointDirective *D) {
7583 DeclarationNameInfo DirName;
7584 getDerived().getSema().StartOpenMPDSABlock(OMPD_cancellation_point, DirName,
7585 nullptr, D->getLocStart());
7586 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7587 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7591 template <typename Derived>
7593 TreeTransform<Derived>::TransformOMPCancelDirective(OMPCancelDirective *D) {
7594 DeclarationNameInfo DirName;
7595 getDerived().getSema().StartOpenMPDSABlock(OMPD_cancel, DirName, nullptr,
7597 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7598 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7602 template <typename Derived>
7604 TreeTransform<Derived>::TransformOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
7605 DeclarationNameInfo DirName;
7606 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop, DirName, nullptr,
7608 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7609 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7613 template <typename Derived>
7614 StmtResult TreeTransform<Derived>::TransformOMPTaskLoopSimdDirective(
7615 OMPTaskLoopSimdDirective *D) {
7616 DeclarationNameInfo DirName;
7617 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop_simd, DirName,
7618 nullptr, D->getLocStart());
7619 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7620 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7624 template <typename Derived>
7625 StmtResult TreeTransform<Derived>::TransformOMPDistributeDirective(
7626 OMPDistributeDirective *D) {
7627 DeclarationNameInfo DirName;
7628 getDerived().getSema().StartOpenMPDSABlock(OMPD_distribute, DirName, nullptr,
7630 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7631 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7635 template <typename Derived>
7636 StmtResult TreeTransform<Derived>::TransformOMPDistributeParallelForDirective(
7637 OMPDistributeParallelForDirective *D) {
7638 DeclarationNameInfo DirName;
7639 getDerived().getSema().StartOpenMPDSABlock(
7640 OMPD_distribute_parallel_for, DirName, nullptr, D->getLocStart());
7641 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7642 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7646 template <typename Derived>
7648 TreeTransform<Derived>::TransformOMPDistributeParallelForSimdDirective(
7649 OMPDistributeParallelForSimdDirective *D) {
7650 DeclarationNameInfo DirName;
7651 getDerived().getSema().StartOpenMPDSABlock(
7652 OMPD_distribute_parallel_for_simd, DirName, nullptr, D->getLocStart());
7653 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7654 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7658 template <typename Derived>
7659 StmtResult TreeTransform<Derived>::TransformOMPDistributeSimdDirective(
7660 OMPDistributeSimdDirective *D) {
7661 DeclarationNameInfo DirName;
7662 getDerived().getSema().StartOpenMPDSABlock(OMPD_distribute_simd, DirName,
7663 nullptr, D->getLocStart());
7664 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7665 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7669 template <typename Derived>
7670 StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForSimdDirective(
7671 OMPTargetParallelForSimdDirective *D) {
7672 DeclarationNameInfo DirName;
7673 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel_for_simd,
7676 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7677 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7681 template <typename Derived>
7682 StmtResult TreeTransform<Derived>::TransformOMPTargetSimdDirective(
7683 OMPTargetSimdDirective *D) {
7684 DeclarationNameInfo DirName;
7685 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_simd, DirName, nullptr,
7687 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7688 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7692 template <typename Derived>
7693 StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeDirective(
7694 OMPTeamsDistributeDirective *D) {
7695 DeclarationNameInfo DirName;
7696 getDerived().getSema().StartOpenMPDSABlock(OMPD_teams_distribute, DirName,
7697 nullptr, D->getLocStart());
7698 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7699 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7703 template <typename Derived>
7704 StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeSimdDirective(
7705 OMPTeamsDistributeSimdDirective *D) {
7706 DeclarationNameInfo DirName;
7707 getDerived().getSema().StartOpenMPDSABlock(
7708 OMPD_teams_distribute_simd, DirName, nullptr, D->getLocStart());
7709 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7710 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7714 template <typename Derived>
7715 StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForSimdDirective(
7716 OMPTeamsDistributeParallelForSimdDirective *D) {
7717 DeclarationNameInfo DirName;
7718 getDerived().getSema().StartOpenMPDSABlock(
7719 OMPD_teams_distribute_parallel_for_simd, DirName, nullptr, D->getLocStart());
7720 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7721 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7725 template <typename Derived>
7726 StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForDirective(
7727 OMPTeamsDistributeParallelForDirective *D) {
7728 DeclarationNameInfo DirName;
7729 getDerived().getSema().StartOpenMPDSABlock(OMPD_teams_distribute_parallel_for,
7730 DirName, nullptr, D->getLocStart());
7731 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
7732 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7736 template <typename Derived>
7737 StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDirective(
7738 OMPTargetTeamsDirective *D) {
7739 DeclarationNameInfo DirName;
7740 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_teams, DirName,
7741 nullptr, D->getLocStart());
7742 auto Res = getDerived().TransformOMPExecutableDirective(D);
7743 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7747 template <typename Derived>
7748 StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDistributeDirective(
7749 OMPTargetTeamsDistributeDirective *D) {
7750 DeclarationNameInfo DirName;
7751 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_teams_distribute,
7752 DirName, nullptr, D->getLocStart());
7753 auto Res = getDerived().TransformOMPExecutableDirective(D);
7754 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7758 template <typename Derived>
7760 TreeTransform<Derived>::TransformOMPTargetTeamsDistributeParallelForDirective(
7761 OMPTargetTeamsDistributeParallelForDirective *D) {
7762 DeclarationNameInfo DirName;
7763 getDerived().getSema().StartOpenMPDSABlock(
7764 OMPD_target_teams_distribute_parallel_for, DirName, nullptr,
7766 auto Res = getDerived().TransformOMPExecutableDirective(D);
7767 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7771 template <typename Derived>
7772 StmtResult TreeTransform<Derived>::
7773 TransformOMPTargetTeamsDistributeParallelForSimdDirective(
7774 OMPTargetTeamsDistributeParallelForSimdDirective *D) {
7775 DeclarationNameInfo DirName;
7776 getDerived().getSema().StartOpenMPDSABlock(
7777 OMPD_target_teams_distribute_parallel_for_simd, DirName, nullptr,
7779 auto Res = getDerived().TransformOMPExecutableDirective(D);
7780 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7784 template <typename Derived>
7786 TreeTransform<Derived>::TransformOMPTargetTeamsDistributeSimdDirective(
7787 OMPTargetTeamsDistributeSimdDirective *D) {
7788 DeclarationNameInfo DirName;
7789 getDerived().getSema().StartOpenMPDSABlock(
7790 OMPD_target_teams_distribute_simd, DirName, nullptr, D->getLocStart());
7791 auto Res = getDerived().TransformOMPExecutableDirective(D);
7792 getDerived().getSema().EndOpenMPDSABlock(Res.get());
7797 //===----------------------------------------------------------------------===//
7798 // OpenMP clause transformation
7799 //===----------------------------------------------------------------------===//
7800 template <typename Derived>
7801 OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *C) {
7802 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
7803 if (Cond.isInvalid())
7805 return getDerived().RebuildOMPIfClause(
7806 C->getNameModifier(), Cond.get(), C->getLocStart(), C->getLParenLoc(),
7807 C->getNameModifierLoc(), C->getColonLoc(), C->getLocEnd());
7810 template <typename Derived>
7811 OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *C) {
7812 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
7813 if (Cond.isInvalid())
7815 return getDerived().RebuildOMPFinalClause(Cond.get(), C->getLocStart(),
7816 C->getLParenLoc(), C->getLocEnd());
7819 template <typename Derived>
7821 TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *C) {
7822 ExprResult NumThreads = getDerived().TransformExpr(C->getNumThreads());
7823 if (NumThreads.isInvalid())
7825 return getDerived().RebuildOMPNumThreadsClause(
7826 NumThreads.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7829 template <typename Derived>
7831 TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *C) {
7832 ExprResult E = getDerived().TransformExpr(C->getSafelen());
7835 return getDerived().RebuildOMPSafelenClause(
7836 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7839 template <typename Derived>
7841 TreeTransform<Derived>::TransformOMPSimdlenClause(OMPSimdlenClause *C) {
7842 ExprResult E = getDerived().TransformExpr(C->getSimdlen());
7845 return getDerived().RebuildOMPSimdlenClause(
7846 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7849 template <typename Derived>
7851 TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) {
7852 ExprResult E = getDerived().TransformExpr(C->getNumForLoops());
7855 return getDerived().RebuildOMPCollapseClause(
7856 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7859 template <typename Derived>
7861 TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *C) {
7862 return getDerived().RebuildOMPDefaultClause(
7863 C->getDefaultKind(), C->getDefaultKindKwLoc(), C->getLocStart(),
7864 C->getLParenLoc(), C->getLocEnd());
7867 template <typename Derived>
7869 TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *C) {
7870 return getDerived().RebuildOMPProcBindClause(
7871 C->getProcBindKind(), C->getProcBindKindKwLoc(), C->getLocStart(),
7872 C->getLParenLoc(), C->getLocEnd());
7875 template <typename Derived>
7877 TreeTransform<Derived>::TransformOMPScheduleClause(OMPScheduleClause *C) {
7878 ExprResult E = getDerived().TransformExpr(C->getChunkSize());
7881 return getDerived().RebuildOMPScheduleClause(
7882 C->getFirstScheduleModifier(), C->getSecondScheduleModifier(),
7883 C->getScheduleKind(), E.get(), C->getLocStart(), C->getLParenLoc(),
7884 C->getFirstScheduleModifierLoc(), C->getSecondScheduleModifierLoc(),
7885 C->getScheduleKindLoc(), C->getCommaLoc(), C->getLocEnd());
7888 template <typename Derived>
7890 TreeTransform<Derived>::TransformOMPOrderedClause(OMPOrderedClause *C) {
7892 if (auto *Num = C->getNumForLoops()) {
7893 E = getDerived().TransformExpr(Num);
7897 return getDerived().RebuildOMPOrderedClause(C->getLocStart(), C->getLocEnd(),
7898 C->getLParenLoc(), E.get());
7901 template <typename Derived>
7903 TreeTransform<Derived>::TransformOMPNowaitClause(OMPNowaitClause *C) {
7904 // No need to rebuild this clause, no template-dependent parameters.
7908 template <typename Derived>
7910 TreeTransform<Derived>::TransformOMPUntiedClause(OMPUntiedClause *C) {
7911 // No need to rebuild this clause, no template-dependent parameters.
7915 template <typename Derived>
7917 TreeTransform<Derived>::TransformOMPMergeableClause(OMPMergeableClause *C) {
7918 // No need to rebuild this clause, no template-dependent parameters.
7922 template <typename Derived>
7923 OMPClause *TreeTransform<Derived>::TransformOMPReadClause(OMPReadClause *C) {
7924 // No need to rebuild this clause, no template-dependent parameters.
7928 template <typename Derived>
7929 OMPClause *TreeTransform<Derived>::TransformOMPWriteClause(OMPWriteClause *C) {
7930 // No need to rebuild this clause, no template-dependent parameters.
7934 template <typename Derived>
7936 TreeTransform<Derived>::TransformOMPUpdateClause(OMPUpdateClause *C) {
7937 // No need to rebuild this clause, no template-dependent parameters.
7941 template <typename Derived>
7943 TreeTransform<Derived>::TransformOMPCaptureClause(OMPCaptureClause *C) {
7944 // No need to rebuild this clause, no template-dependent parameters.
7948 template <typename Derived>
7950 TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *C) {
7951 // No need to rebuild this clause, no template-dependent parameters.
7955 template <typename Derived>
7957 TreeTransform<Derived>::TransformOMPThreadsClause(OMPThreadsClause *C) {
7958 // No need to rebuild this clause, no template-dependent parameters.
7962 template <typename Derived>
7963 OMPClause *TreeTransform<Derived>::TransformOMPSIMDClause(OMPSIMDClause *C) {
7964 // No need to rebuild this clause, no template-dependent parameters.
7968 template <typename Derived>
7970 TreeTransform<Derived>::TransformOMPNogroupClause(OMPNogroupClause *C) {
7971 // No need to rebuild this clause, no template-dependent parameters.
7975 template <typename Derived>
7977 TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) {
7978 llvm::SmallVector<Expr *, 16> Vars;
7979 Vars.reserve(C->varlist_size());
7980 for (auto *VE : C->varlists()) {
7981 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7982 if (EVar.isInvalid())
7984 Vars.push_back(EVar.get());
7986 return getDerived().RebuildOMPPrivateClause(
7987 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
7990 template <typename Derived>
7991 OMPClause *TreeTransform<Derived>::TransformOMPFirstprivateClause(
7992 OMPFirstprivateClause *C) {
7993 llvm::SmallVector<Expr *, 16> Vars;
7994 Vars.reserve(C->varlist_size());
7995 for (auto *VE : C->varlists()) {
7996 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
7997 if (EVar.isInvalid())
7999 Vars.push_back(EVar.get());
8001 return getDerived().RebuildOMPFirstprivateClause(
8002 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8005 template <typename Derived>
8007 TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *C) {
8008 llvm::SmallVector<Expr *, 16> Vars;
8009 Vars.reserve(C->varlist_size());
8010 for (auto *VE : C->varlists()) {
8011 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8012 if (EVar.isInvalid())
8014 Vars.push_back(EVar.get());
8016 return getDerived().RebuildOMPLastprivateClause(
8017 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8020 template <typename Derived>
8022 TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *C) {
8023 llvm::SmallVector<Expr *, 16> Vars;
8024 Vars.reserve(C->varlist_size());
8025 for (auto *VE : C->varlists()) {
8026 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8027 if (EVar.isInvalid())
8029 Vars.push_back(EVar.get());
8031 return getDerived().RebuildOMPSharedClause(Vars, C->getLocStart(),
8032 C->getLParenLoc(), C->getLocEnd());
8035 template <typename Derived>
8037 TreeTransform<Derived>::TransformOMPReductionClause(OMPReductionClause *C) {
8038 llvm::SmallVector<Expr *, 16> Vars;
8039 Vars.reserve(C->varlist_size());
8040 for (auto *VE : C->varlists()) {
8041 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8042 if (EVar.isInvalid())
8044 Vars.push_back(EVar.get());
8046 CXXScopeSpec ReductionIdScopeSpec;
8047 ReductionIdScopeSpec.Adopt(C->getQualifierLoc());
8049 DeclarationNameInfo NameInfo = C->getNameInfo();
8050 if (NameInfo.getName()) {
8051 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
8052 if (!NameInfo.getName())
8055 // Build a list of all UDR decls with the same names ranged by the Scopes.
8056 // The Scope boundary is a duplication of the previous decl.
8057 llvm::SmallVector<Expr *, 16> UnresolvedReductions;
8058 for (auto *E : C->reduction_ops()) {
8059 // Transform all the decls.
8061 auto *ULE = cast<UnresolvedLookupExpr>(E);
8062 UnresolvedSet<8> Decls;
8063 for (auto *D : ULE->decls()) {
8065 cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
8066 Decls.addDecl(InstD, InstD->getAccess());
8068 UnresolvedReductions.push_back(
8069 UnresolvedLookupExpr::Create(
8070 SemaRef.Context, /*NamingClass=*/nullptr,
8071 ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context),
8072 NameInfo, /*ADL=*/true, ULE->isOverloaded(),
8073 Decls.begin(), Decls.end()));
8075 UnresolvedReductions.push_back(nullptr);
8077 return getDerived().RebuildOMPReductionClause(
8078 Vars, C->getLocStart(), C->getLParenLoc(), C->getColonLoc(),
8079 C->getLocEnd(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
8082 template <typename Derived>
8084 TreeTransform<Derived>::TransformOMPLinearClause(OMPLinearClause *C) {
8085 llvm::SmallVector<Expr *, 16> Vars;
8086 Vars.reserve(C->varlist_size());
8087 for (auto *VE : C->varlists()) {
8088 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8089 if (EVar.isInvalid())
8091 Vars.push_back(EVar.get());
8093 ExprResult Step = getDerived().TransformExpr(C->getStep());
8094 if (Step.isInvalid())
8096 return getDerived().RebuildOMPLinearClause(
8097 Vars, Step.get(), C->getLocStart(), C->getLParenLoc(), C->getModifier(),
8098 C->getModifierLoc(), C->getColonLoc(), C->getLocEnd());
8101 template <typename Derived>
8103 TreeTransform<Derived>::TransformOMPAlignedClause(OMPAlignedClause *C) {
8104 llvm::SmallVector<Expr *, 16> Vars;
8105 Vars.reserve(C->varlist_size());
8106 for (auto *VE : C->varlists()) {
8107 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8108 if (EVar.isInvalid())
8110 Vars.push_back(EVar.get());
8112 ExprResult Alignment = getDerived().TransformExpr(C->getAlignment());
8113 if (Alignment.isInvalid())
8115 return getDerived().RebuildOMPAlignedClause(
8116 Vars, Alignment.get(), C->getLocStart(), C->getLParenLoc(),
8117 C->getColonLoc(), C->getLocEnd());
8120 template <typename Derived>
8122 TreeTransform<Derived>::TransformOMPCopyinClause(OMPCopyinClause *C) {
8123 llvm::SmallVector<Expr *, 16> Vars;
8124 Vars.reserve(C->varlist_size());
8125 for (auto *VE : C->varlists()) {
8126 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8127 if (EVar.isInvalid())
8129 Vars.push_back(EVar.get());
8131 return getDerived().RebuildOMPCopyinClause(Vars, C->getLocStart(),
8132 C->getLParenLoc(), C->getLocEnd());
8135 template <typename Derived>
8137 TreeTransform<Derived>::TransformOMPCopyprivateClause(OMPCopyprivateClause *C) {
8138 llvm::SmallVector<Expr *, 16> Vars;
8139 Vars.reserve(C->varlist_size());
8140 for (auto *VE : C->varlists()) {
8141 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8142 if (EVar.isInvalid())
8144 Vars.push_back(EVar.get());
8146 return getDerived().RebuildOMPCopyprivateClause(
8147 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8150 template <typename Derived>
8151 OMPClause *TreeTransform<Derived>::TransformOMPFlushClause(OMPFlushClause *C) {
8152 llvm::SmallVector<Expr *, 16> Vars;
8153 Vars.reserve(C->varlist_size());
8154 for (auto *VE : C->varlists()) {
8155 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8156 if (EVar.isInvalid())
8158 Vars.push_back(EVar.get());
8160 return getDerived().RebuildOMPFlushClause(Vars, C->getLocStart(),
8161 C->getLParenLoc(), C->getLocEnd());
8164 template <typename Derived>
8166 TreeTransform<Derived>::TransformOMPDependClause(OMPDependClause *C) {
8167 llvm::SmallVector<Expr *, 16> Vars;
8168 Vars.reserve(C->varlist_size());
8169 for (auto *VE : C->varlists()) {
8170 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8171 if (EVar.isInvalid())
8173 Vars.push_back(EVar.get());
8175 return getDerived().RebuildOMPDependClause(
8176 C->getDependencyKind(), C->getDependencyLoc(), C->getColonLoc(), Vars,
8177 C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8180 template <typename Derived>
8182 TreeTransform<Derived>::TransformOMPDeviceClause(OMPDeviceClause *C) {
8183 ExprResult E = getDerived().TransformExpr(C->getDevice());
8186 return getDerived().RebuildOMPDeviceClause(
8187 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8190 template <typename Derived>
8191 OMPClause *TreeTransform<Derived>::TransformOMPMapClause(OMPMapClause *C) {
8192 llvm::SmallVector<Expr *, 16> Vars;
8193 Vars.reserve(C->varlist_size());
8194 for (auto *VE : C->varlists()) {
8195 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8196 if (EVar.isInvalid())
8198 Vars.push_back(EVar.get());
8200 return getDerived().RebuildOMPMapClause(
8201 C->getMapTypeModifier(), C->getMapType(), C->isImplicitMapType(),
8202 C->getMapLoc(), C->getColonLoc(), Vars, C->getLocStart(),
8203 C->getLParenLoc(), C->getLocEnd());
8206 template <typename Derived>
8208 TreeTransform<Derived>::TransformOMPNumTeamsClause(OMPNumTeamsClause *C) {
8209 ExprResult E = getDerived().TransformExpr(C->getNumTeams());
8212 return getDerived().RebuildOMPNumTeamsClause(
8213 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8216 template <typename Derived>
8218 TreeTransform<Derived>::TransformOMPThreadLimitClause(OMPThreadLimitClause *C) {
8219 ExprResult E = getDerived().TransformExpr(C->getThreadLimit());
8222 return getDerived().RebuildOMPThreadLimitClause(
8223 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8226 template <typename Derived>
8228 TreeTransform<Derived>::TransformOMPPriorityClause(OMPPriorityClause *C) {
8229 ExprResult E = getDerived().TransformExpr(C->getPriority());
8232 return getDerived().RebuildOMPPriorityClause(
8233 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8236 template <typename Derived>
8238 TreeTransform<Derived>::TransformOMPGrainsizeClause(OMPGrainsizeClause *C) {
8239 ExprResult E = getDerived().TransformExpr(C->getGrainsize());
8242 return getDerived().RebuildOMPGrainsizeClause(
8243 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8246 template <typename Derived>
8248 TreeTransform<Derived>::TransformOMPNumTasksClause(OMPNumTasksClause *C) {
8249 ExprResult E = getDerived().TransformExpr(C->getNumTasks());
8252 return getDerived().RebuildOMPNumTasksClause(
8253 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8256 template <typename Derived>
8257 OMPClause *TreeTransform<Derived>::TransformOMPHintClause(OMPHintClause *C) {
8258 ExprResult E = getDerived().TransformExpr(C->getHint());
8261 return getDerived().RebuildOMPHintClause(E.get(), C->getLocStart(),
8262 C->getLParenLoc(), C->getLocEnd());
8265 template <typename Derived>
8266 OMPClause *TreeTransform<Derived>::TransformOMPDistScheduleClause(
8267 OMPDistScheduleClause *C) {
8268 ExprResult E = getDerived().TransformExpr(C->getChunkSize());
8271 return getDerived().RebuildOMPDistScheduleClause(
8272 C->getDistScheduleKind(), E.get(), C->getLocStart(), C->getLParenLoc(),
8273 C->getDistScheduleKindLoc(), C->getCommaLoc(), C->getLocEnd());
8276 template <typename Derived>
8278 TreeTransform<Derived>::TransformOMPDefaultmapClause(OMPDefaultmapClause *C) {
8282 template <typename Derived>
8283 OMPClause *TreeTransform<Derived>::TransformOMPToClause(OMPToClause *C) {
8284 llvm::SmallVector<Expr *, 16> Vars;
8285 Vars.reserve(C->varlist_size());
8286 for (auto *VE : C->varlists()) {
8287 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8288 if (EVar.isInvalid())
8290 Vars.push_back(EVar.get());
8292 return getDerived().RebuildOMPToClause(Vars, C->getLocStart(),
8293 C->getLParenLoc(), C->getLocEnd());
8296 template <typename Derived>
8297 OMPClause *TreeTransform<Derived>::TransformOMPFromClause(OMPFromClause *C) {
8298 llvm::SmallVector<Expr *, 16> Vars;
8299 Vars.reserve(C->varlist_size());
8300 for (auto *VE : C->varlists()) {
8301 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8302 if (EVar.isInvalid())
8304 Vars.push_back(EVar.get());
8306 return getDerived().RebuildOMPFromClause(Vars, C->getLocStart(),
8307 C->getLParenLoc(), C->getLocEnd());
8310 template <typename Derived>
8311 OMPClause *TreeTransform<Derived>::TransformOMPUseDevicePtrClause(
8312 OMPUseDevicePtrClause *C) {
8313 llvm::SmallVector<Expr *, 16> Vars;
8314 Vars.reserve(C->varlist_size());
8315 for (auto *VE : C->varlists()) {
8316 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8317 if (EVar.isInvalid())
8319 Vars.push_back(EVar.get());
8321 return getDerived().RebuildOMPUseDevicePtrClause(
8322 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8325 template <typename Derived>
8327 TreeTransform<Derived>::TransformOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) {
8328 llvm::SmallVector<Expr *, 16> Vars;
8329 Vars.reserve(C->varlist_size());
8330 for (auto *VE : C->varlists()) {
8331 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
8332 if (EVar.isInvalid())
8334 Vars.push_back(EVar.get());
8336 return getDerived().RebuildOMPIsDevicePtrClause(
8337 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd());
8340 //===----------------------------------------------------------------------===//
8341 // Expression transformation
8342 //===----------------------------------------------------------------------===//
8343 template<typename Derived>
8345 TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) {
8346 if (!E->isTypeDependent())
8349 return getDerived().RebuildPredefinedExpr(E->getLocation(),
8353 template<typename Derived>
8355 TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) {
8356 NestedNameSpecifierLoc QualifierLoc;
8357 if (E->getQualifierLoc()) {
8359 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
8365 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
8370 DeclarationNameInfo NameInfo = E->getNameInfo();
8371 if (NameInfo.getName()) {
8372 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
8373 if (!NameInfo.getName())
8377 if (!getDerived().AlwaysRebuild() &&
8378 QualifierLoc == E->getQualifierLoc() &&
8379 ND == E->getDecl() &&
8380 NameInfo.getName() == E->getDecl()->getDeclName() &&
8381 !E->hasExplicitTemplateArgs()) {
8383 // Mark it referenced in the new context regardless.
8384 // FIXME: this is a bit instantiation-specific.
8385 SemaRef.MarkDeclRefReferenced(E);
8390 TemplateArgumentListInfo TransArgs, *TemplateArgs = nullptr;
8391 if (E->hasExplicitTemplateArgs()) {
8392 TemplateArgs = &TransArgs;
8393 TransArgs.setLAngleLoc(E->getLAngleLoc());
8394 TransArgs.setRAngleLoc(E->getRAngleLoc());
8395 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
8396 E->getNumTemplateArgs(),
8401 return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo,
8405 template<typename Derived>
8407 TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) {
8411 template<typename Derived>
8413 TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) {
8417 template<typename Derived>
8419 TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) {
8423 template<typename Derived>
8425 TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) {
8429 template<typename Derived>
8431 TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) {
8435 template<typename Derived>
8437 TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) {
8438 if (FunctionDecl *FD = E->getDirectCallee())
8439 SemaRef.MarkFunctionReferenced(E->getLocStart(), FD);
8440 return SemaRef.MaybeBindToTemporary(E);
8443 template<typename Derived>
8445 TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) {
8446 ExprResult ControllingExpr =
8447 getDerived().TransformExpr(E->getControllingExpr());
8448 if (ControllingExpr.isInvalid())
8451 SmallVector<Expr *, 4> AssocExprs;
8452 SmallVector<TypeSourceInfo *, 4> AssocTypes;
8453 for (unsigned i = 0; i != E->getNumAssocs(); ++i) {
8454 TypeSourceInfo *TS = E->getAssocTypeSourceInfo(i);
8456 TypeSourceInfo *AssocType = getDerived().TransformType(TS);
8459 AssocTypes.push_back(AssocType);
8461 AssocTypes.push_back(nullptr);
8464 ExprResult AssocExpr = getDerived().TransformExpr(E->getAssocExpr(i));
8465 if (AssocExpr.isInvalid())
8467 AssocExprs.push_back(AssocExpr.get());
8470 return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(),
8473 ControllingExpr.get(),
8478 template<typename Derived>
8480 TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
8481 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
8482 if (SubExpr.isInvalid())
8485 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
8488 return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(),
8492 /// \brief The operand of a unary address-of operator has special rules: it's
8493 /// allowed to refer to a non-static member of a class even if there's no 'this'
8494 /// object available.
8495 template<typename Derived>
8497 TreeTransform<Derived>::TransformAddressOfOperand(Expr *E) {
8498 if (DependentScopeDeclRefExpr *DRE = dyn_cast<DependentScopeDeclRefExpr>(E))
8499 return getDerived().TransformDependentScopeDeclRefExpr(DRE, true, nullptr);
8501 return getDerived().TransformExpr(E);
8504 template<typename Derived>
8506 TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) {
8508 if (E->getOpcode() == UO_AddrOf)
8509 SubExpr = TransformAddressOfOperand(E->getSubExpr());
8511 SubExpr = TransformExpr(E->getSubExpr());
8512 if (SubExpr.isInvalid())
8515 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
8518 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(),
8523 template<typename Derived>
8525 TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) {
8526 // Transform the type.
8527 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
8531 // Transform all of the components into components similar to what the
8533 // FIXME: It would be slightly more efficient in the non-dependent case to
8534 // just map FieldDecls, rather than requiring the rebuilder to look for
8535 // the fields again. However, __builtin_offsetof is rare enough in
8536 // template code that we don't care.
8537 bool ExprChanged = false;
8538 typedef Sema::OffsetOfComponent Component;
8539 SmallVector<Component, 4> Components;
8540 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
8541 const OffsetOfNode &ON = E->getComponent(I);
8543 Comp.isBrackets = true;
8544 Comp.LocStart = ON.getSourceRange().getBegin();
8545 Comp.LocEnd = ON.getSourceRange().getEnd();
8546 switch (ON.getKind()) {
8547 case OffsetOfNode::Array: {
8548 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex());
8549 ExprResult Index = getDerived().TransformExpr(FromIndex);
8550 if (Index.isInvalid())
8553 ExprChanged = ExprChanged || Index.get() != FromIndex;
8554 Comp.isBrackets = true;
8555 Comp.U.E = Index.get();
8559 case OffsetOfNode::Field:
8560 case OffsetOfNode::Identifier:
8561 Comp.isBrackets = false;
8562 Comp.U.IdentInfo = ON.getFieldName();
8563 if (!Comp.U.IdentInfo)
8568 case OffsetOfNode::Base:
8569 // Will be recomputed during the rebuild.
8573 Components.push_back(Comp);
8576 // If nothing changed, retain the existing expression.
8577 if (!getDerived().AlwaysRebuild() &&
8578 Type == E->getTypeSourceInfo() &&
8582 // Build a new offsetof expression.
8583 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type,
8584 Components, E->getRParenLoc());
8587 template<typename Derived>
8589 TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) {
8590 assert((!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) &&
8591 "opaque value expression requires transformation");
8595 template<typename Derived>
8597 TreeTransform<Derived>::TransformTypoExpr(TypoExpr *E) {
8601 template<typename Derived>
8603 TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) {
8604 // Rebuild the syntactic form. The original syntactic form has
8605 // opaque-value expressions in it, so strip those away and rebuild
8606 // the result. This is a really awful way of doing this, but the
8607 // better solution (rebuilding the semantic expressions and
8608 // rebinding OVEs as necessary) doesn't work; we'd need
8609 // TreeTransform to not strip away implicit conversions.
8610 Expr *newSyntacticForm = SemaRef.recreateSyntacticForm(E);
8611 ExprResult result = getDerived().TransformExpr(newSyntacticForm);
8612 if (result.isInvalid()) return ExprError();
8614 // If that gives us a pseudo-object result back, the pseudo-object
8615 // expression must have been an lvalue-to-rvalue conversion which we
8617 if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject))
8618 result = SemaRef.checkPseudoObjectRValue(result.get());
8623 template<typename Derived>
8625 TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr(
8626 UnaryExprOrTypeTraitExpr *E) {
8627 if (E->isArgumentType()) {
8628 TypeSourceInfo *OldT = E->getArgumentTypeInfo();
8630 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
8634 if (!getDerived().AlwaysRebuild() && OldT == NewT)
8637 return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(),
8639 E->getSourceRange());
8642 // C++0x [expr.sizeof]p1:
8643 // The operand is either an expression, which is an unevaluated operand
8645 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated,
8646 Sema::ReuseLambdaContextDecl);
8648 // Try to recover if we have something like sizeof(T::X) where X is a type.
8649 // Notably, there must be *exactly* one set of parens if X is a type.
8650 TypeSourceInfo *RecoveryTSI = nullptr;
8652 auto *PE = dyn_cast<ParenExpr>(E->getArgumentExpr());
8654 PE ? dyn_cast<DependentScopeDeclRefExpr>(PE->getSubExpr()) : nullptr)
8655 SubExpr = getDerived().TransformParenDependentScopeDeclRefExpr(
8656 PE, DRE, false, &RecoveryTSI);
8658 SubExpr = getDerived().TransformExpr(E->getArgumentExpr());
8661 return getDerived().RebuildUnaryExprOrTypeTrait(
8662 RecoveryTSI, E->getOperatorLoc(), E->getKind(), E->getSourceRange());
8663 } else if (SubExpr.isInvalid())
8666 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
8669 return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(),
8670 E->getOperatorLoc(),
8672 E->getSourceRange());
8675 template<typename Derived>
8677 TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
8678 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
8679 if (LHS.isInvalid())
8682 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
8683 if (RHS.isInvalid())
8687 if (!getDerived().AlwaysRebuild() &&
8688 LHS.get() == E->getLHS() &&
8689 RHS.get() == E->getRHS())
8692 return getDerived().RebuildArraySubscriptExpr(LHS.get(),
8693 /*FIXME:*/E->getLHS()->getLocStart(),
8695 E->getRBracketLoc());
8698 template <typename Derived>
8700 TreeTransform<Derived>::TransformOMPArraySectionExpr(OMPArraySectionExpr *E) {
8701 ExprResult Base = getDerived().TransformExpr(E->getBase());
8702 if (Base.isInvalid())
8705 ExprResult LowerBound;
8706 if (E->getLowerBound()) {
8707 LowerBound = getDerived().TransformExpr(E->getLowerBound());
8708 if (LowerBound.isInvalid())
8713 if (E->getLength()) {
8714 Length = getDerived().TransformExpr(E->getLength());
8715 if (Length.isInvalid())
8719 if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
8720 LowerBound.get() == E->getLowerBound() && Length.get() == E->getLength())
8723 return getDerived().RebuildOMPArraySectionExpr(
8724 Base.get(), E->getBase()->getLocEnd(), LowerBound.get(), E->getColonLoc(),
8725 Length.get(), E->getRBracketLoc());
8728 template<typename Derived>
8730 TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
8731 // Transform the callee.
8732 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
8733 if (Callee.isInvalid())
8736 // Transform arguments.
8737 bool ArgChanged = false;
8738 SmallVector<Expr*, 8> Args;
8739 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
8743 if (!getDerived().AlwaysRebuild() &&
8744 Callee.get() == E->getCallee() &&
8746 return SemaRef.MaybeBindToTemporary(E);
8748 // FIXME: Wrong source location information for the '('.
8749 SourceLocation FakeLParenLoc
8750 = ((Expr *)Callee.get())->getSourceRange().getBegin();
8751 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
8756 template<typename Derived>
8758 TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
8759 ExprResult Base = getDerived().TransformExpr(E->getBase());
8760 if (Base.isInvalid())
8763 NestedNameSpecifierLoc QualifierLoc;
8764 if (E->hasQualifier()) {
8766 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
8771 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
8774 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
8775 E->getMemberDecl()));
8779 NamedDecl *FoundDecl = E->getFoundDecl();
8780 if (FoundDecl == E->getMemberDecl()) {
8783 FoundDecl = cast_or_null<NamedDecl>(
8784 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl));
8789 if (!getDerived().AlwaysRebuild() &&
8790 Base.get() == E->getBase() &&
8791 QualifierLoc == E->getQualifierLoc() &&
8792 Member == E->getMemberDecl() &&
8793 FoundDecl == E->getFoundDecl() &&
8794 !E->hasExplicitTemplateArgs()) {
8796 // Mark it referenced in the new context regardless.
8797 // FIXME: this is a bit instantiation-specific.
8798 SemaRef.MarkMemberReferenced(E);
8803 TemplateArgumentListInfo TransArgs;
8804 if (E->hasExplicitTemplateArgs()) {
8805 TransArgs.setLAngleLoc(E->getLAngleLoc());
8806 TransArgs.setRAngleLoc(E->getRAngleLoc());
8807 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
8808 E->getNumTemplateArgs(),
8813 // FIXME: Bogus source location for the operator
8814 SourceLocation FakeOperatorLoc =
8815 SemaRef.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd());
8817 // FIXME: to do this check properly, we will need to preserve the
8818 // first-qualifier-in-scope here, just in case we had a dependent
8819 // base (and therefore couldn't do the check) and a
8820 // nested-name-qualifier (and therefore could do the lookup).
8821 NamedDecl *FirstQualifierInScope = nullptr;
8822 DeclarationNameInfo MemberNameInfo = E->getMemberNameInfo();
8823 if (MemberNameInfo.getName()) {
8824 MemberNameInfo = getDerived().TransformDeclarationNameInfo(MemberNameInfo);
8825 if (!MemberNameInfo.getName())
8829 return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc,
8836 (E->hasExplicitTemplateArgs()
8837 ? &TransArgs : nullptr),
8838 FirstQualifierInScope);
8841 template<typename Derived>
8843 TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
8844 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
8845 if (LHS.isInvalid())
8848 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
8849 if (RHS.isInvalid())
8852 if (!getDerived().AlwaysRebuild() &&
8853 LHS.get() == E->getLHS() &&
8854 RHS.get() == E->getRHS())
8857 Sema::FPContractStateRAII FPContractState(getSema());
8858 getSema().FPFeatures.fp_contract = E->isFPContractable();
8860 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
8861 LHS.get(), RHS.get());
8864 template<typename Derived>
8866 TreeTransform<Derived>::TransformCompoundAssignOperator(
8867 CompoundAssignOperator *E) {
8868 return getDerived().TransformBinaryOperator(E);
8871 template<typename Derived>
8872 ExprResult TreeTransform<Derived>::
8873 TransformBinaryConditionalOperator(BinaryConditionalOperator *e) {
8874 // Just rebuild the common and RHS expressions and see whether we
8877 ExprResult commonExpr = getDerived().TransformExpr(e->getCommon());
8878 if (commonExpr.isInvalid())
8881 ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr());
8882 if (rhs.isInvalid())
8885 if (!getDerived().AlwaysRebuild() &&
8886 commonExpr.get() == e->getCommon() &&
8887 rhs.get() == e->getFalseExpr())
8890 return getDerived().RebuildConditionalOperator(commonExpr.get(),
8891 e->getQuestionLoc(),
8897 template<typename Derived>
8899 TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) {
8900 ExprResult Cond = getDerived().TransformExpr(E->getCond());
8901 if (Cond.isInvalid())
8904 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
8905 if (LHS.isInvalid())
8908 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
8909 if (RHS.isInvalid())
8912 if (!getDerived().AlwaysRebuild() &&
8913 Cond.get() == E->getCond() &&
8914 LHS.get() == E->getLHS() &&
8915 RHS.get() == E->getRHS())
8918 return getDerived().RebuildConditionalOperator(Cond.get(),
8919 E->getQuestionLoc(),
8925 template<typename Derived>
8927 TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) {
8928 // Implicit casts are eliminated during transformation, since they
8929 // will be recomputed by semantic analysis after transformation.
8930 return getDerived().TransformExpr(E->getSubExprAsWritten());
8933 template<typename Derived>
8935 TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
8936 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
8941 = getDerived().TransformExpr(E->getSubExprAsWritten());
8942 if (SubExpr.isInvalid())
8945 if (!getDerived().AlwaysRebuild() &&
8946 Type == E->getTypeInfoAsWritten() &&
8947 SubExpr.get() == E->getSubExpr())
8950 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
8956 template<typename Derived>
8958 TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) {
8959 TypeSourceInfo *OldT = E->getTypeSourceInfo();
8960 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
8964 ExprResult Init = getDerived().TransformExpr(E->getInitializer());
8965 if (Init.isInvalid())
8968 if (!getDerived().AlwaysRebuild() &&
8970 Init.get() == E->getInitializer())
8971 return SemaRef.MaybeBindToTemporary(E);
8973 // Note: the expression type doesn't necessarily match the
8974 // type-as-written, but that's okay, because it should always be
8975 // derivable from the initializer.
8977 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT,
8978 /*FIXME:*/E->getInitializer()->getLocEnd(),
8982 template<typename Derived>
8984 TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) {
8985 ExprResult Base = getDerived().TransformExpr(E->getBase());
8986 if (Base.isInvalid())
8989 if (!getDerived().AlwaysRebuild() &&
8990 Base.get() == E->getBase())
8993 // FIXME: Bad source location
8994 SourceLocation FakeOperatorLoc =
8995 SemaRef.getLocForEndOfToken(E->getBase()->getLocEnd());
8996 return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc,
8997 E->getAccessorLoc(),
9001 template<typename Derived>
9003 TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) {
9004 if (InitListExpr *Syntactic = E->getSyntacticForm())
9007 bool InitChanged = false;
9009 SmallVector<Expr*, 4> Inits;
9010 if (getDerived().TransformExprs(E->getInits(), E->getNumInits(), false,
9011 Inits, &InitChanged))
9014 if (!getDerived().AlwaysRebuild() && !InitChanged) {
9015 // FIXME: Attempt to reuse the existing syntactic form of the InitListExpr
9016 // in some cases. We can't reuse it in general, because the syntactic and
9017 // semantic forms are linked, and we can't know that semantic form will
9018 // match even if the syntactic form does.
9021 return getDerived().RebuildInitList(E->getLBraceLoc(), Inits,
9022 E->getRBraceLoc(), E->getType());
9025 template<typename Derived>
9027 TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) {
9030 // transform the initializer value
9031 ExprResult Init = getDerived().TransformExpr(E->getInit());
9032 if (Init.isInvalid())
9035 // transform the designators.
9036 SmallVector<Expr*, 4> ArrayExprs;
9037 bool ExprChanged = false;
9038 for (const DesignatedInitExpr::Designator &D : E->designators()) {
9039 if (D.isFieldDesignator()) {
9040 Desig.AddDesignator(Designator::getField(D.getFieldName(),
9044 FieldDecl *Field = cast_or_null<FieldDecl>(
9045 getDerived().TransformDecl(D.getFieldLoc(), D.getField()));
9046 if (Field != D.getField())
9047 // Rebuild the expression when the transformed FieldDecl is
9048 // different to the already assigned FieldDecl.
9051 // Ensure that the designator expression is rebuilt when there isn't
9052 // a resolved FieldDecl in the designator as we don't want to assign
9053 // a FieldDecl to a pattern designator that will be instantiated again.
9059 if (D.isArrayDesignator()) {
9060 ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(D));
9061 if (Index.isInvalid())
9064 Desig.AddDesignator(
9065 Designator::getArray(Index.get(), D.getLBracketLoc()));
9067 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(D);
9068 ArrayExprs.push_back(Index.get());
9072 assert(D.isArrayRangeDesignator() && "New kind of designator?");
9074 = getDerived().TransformExpr(E->getArrayRangeStart(D));
9075 if (Start.isInvalid())
9078 ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(D));
9079 if (End.isInvalid())
9082 Desig.AddDesignator(Designator::getArrayRange(Start.get(),
9085 D.getEllipsisLoc()));
9087 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(D) ||
9088 End.get() != E->getArrayRangeEnd(D);
9090 ArrayExprs.push_back(Start.get());
9091 ArrayExprs.push_back(End.get());
9094 if (!getDerived().AlwaysRebuild() &&
9095 Init.get() == E->getInit() &&
9099 return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs,
9100 E->getEqualOrColonLoc(),
9101 E->usesGNUSyntax(), Init.get());
9104 // Seems that if TransformInitListExpr() only works on the syntactic form of an
9105 // InitListExpr, then a DesignatedInitUpdateExpr is not encountered.
9106 template<typename Derived>
9108 TreeTransform<Derived>::TransformDesignatedInitUpdateExpr(
9109 DesignatedInitUpdateExpr *E) {
9110 llvm_unreachable("Unexpected DesignatedInitUpdateExpr in syntactic form of "
9115 template<typename Derived>
9117 TreeTransform<Derived>::TransformNoInitExpr(
9119 llvm_unreachable("Unexpected NoInitExpr in syntactic form of initializer");
9123 template<typename Derived>
9125 TreeTransform<Derived>::TransformArrayInitLoopExpr(ArrayInitLoopExpr *E) {
9126 llvm_unreachable("Unexpected ArrayInitLoopExpr outside of initializer");
9130 template<typename Derived>
9132 TreeTransform<Derived>::TransformArrayInitIndexExpr(ArrayInitIndexExpr *E) {
9133 llvm_unreachable("Unexpected ArrayInitIndexExpr outside of initializer");
9137 template<typename Derived>
9139 TreeTransform<Derived>::TransformImplicitValueInitExpr(
9140 ImplicitValueInitExpr *E) {
9141 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName());
9143 // FIXME: Will we ever have proper type location here? Will we actually
9144 // need to transform the type?
9145 QualType T = getDerived().TransformType(E->getType());
9149 if (!getDerived().AlwaysRebuild() &&
9153 return getDerived().RebuildImplicitValueInitExpr(T);
9156 template<typename Derived>
9158 TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) {
9159 TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo());
9163 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
9164 if (SubExpr.isInvalid())
9167 if (!getDerived().AlwaysRebuild() &&
9168 TInfo == E->getWrittenTypeInfo() &&
9169 SubExpr.get() == E->getSubExpr())
9172 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(),
9173 TInfo, E->getRParenLoc());
9176 template<typename Derived>
9178 TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) {
9179 bool ArgumentChanged = false;
9180 SmallVector<Expr*, 4> Inits;
9181 if (TransformExprs(E->getExprs(), E->getNumExprs(), true, Inits,
9185 return getDerived().RebuildParenListExpr(E->getLParenLoc(),
9190 /// \brief Transform an address-of-label expression.
9192 /// By default, the transformation of an address-of-label expression always
9193 /// rebuilds the expression, so that the label identifier can be resolved to
9194 /// the corresponding label statement by semantic analysis.
9195 template<typename Derived>
9197 TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) {
9198 Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(),
9203 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
9204 cast<LabelDecl>(LD));
9207 template<typename Derived>
9209 TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) {
9210 SemaRef.ActOnStartStmtExpr();
9212 = getDerived().TransformCompoundStmt(E->getSubStmt(), true);
9213 if (SubStmt.isInvalid()) {
9214 SemaRef.ActOnStmtExprError();
9218 if (!getDerived().AlwaysRebuild() &&
9219 SubStmt.get() == E->getSubStmt()) {
9220 // Calling this an 'error' is unintuitive, but it does the right thing.
9221 SemaRef.ActOnStmtExprError();
9222 return SemaRef.MaybeBindToTemporary(E);
9225 return getDerived().RebuildStmtExpr(E->getLParenLoc(),
9230 template<typename Derived>
9232 TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) {
9233 ExprResult Cond = getDerived().TransformExpr(E->getCond());
9234 if (Cond.isInvalid())
9237 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
9238 if (LHS.isInvalid())
9241 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
9242 if (RHS.isInvalid())
9245 if (!getDerived().AlwaysRebuild() &&
9246 Cond.get() == E->getCond() &&
9247 LHS.get() == E->getLHS() &&
9248 RHS.get() == E->getRHS())
9251 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(),
9252 Cond.get(), LHS.get(), RHS.get(),
9256 template<typename Derived>
9258 TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) {
9262 template<typename Derived>
9264 TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
9265 switch (E->getOperator()) {
9269 case OO_Array_Delete:
9270 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr");
9273 // This is a call to an object's operator().
9274 assert(E->getNumArgs() >= 1 && "Object call is missing arguments");
9276 // Transform the object itself.
9277 ExprResult Object = getDerived().TransformExpr(E->getArg(0));
9278 if (Object.isInvalid())
9281 // FIXME: Poor location information
9282 SourceLocation FakeLParenLoc = SemaRef.getLocForEndOfToken(
9283 static_cast<Expr *>(Object.get())->getLocEnd());
9285 // Transform the call arguments.
9286 SmallVector<Expr*, 8> Args;
9287 if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1, true,
9291 return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc,
9296 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
9298 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
9299 #include "clang/Basic/OperatorKinds.def"
9304 case OO_Conditional:
9305 llvm_unreachable("conditional operator is not actually overloadable");
9308 case NUM_OVERLOADED_OPERATORS:
9309 llvm_unreachable("not an overloaded operator?");
9312 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
9313 if (Callee.isInvalid())
9317 if (E->getOperator() == OO_Amp)
9318 First = getDerived().TransformAddressOfOperand(E->getArg(0));
9320 First = getDerived().TransformExpr(E->getArg(0));
9321 if (First.isInvalid())
9325 if (E->getNumArgs() == 2) {
9326 Second = getDerived().TransformExpr(E->getArg(1));
9327 if (Second.isInvalid())
9331 if (!getDerived().AlwaysRebuild() &&
9332 Callee.get() == E->getCallee() &&
9333 First.get() == E->getArg(0) &&
9334 (E->getNumArgs() != 2 || Second.get() == E->getArg(1)))
9335 return SemaRef.MaybeBindToTemporary(E);
9337 Sema::FPContractStateRAII FPContractState(getSema());
9338 getSema().FPFeatures.fp_contract = E->isFPContractable();
9340 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(),
9341 E->getOperatorLoc(),
9347 template<typename Derived>
9349 TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) {
9350 return getDerived().TransformCallExpr(E);
9353 template<typename Derived>
9355 TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
9356 // Transform the callee.
9357 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
9358 if (Callee.isInvalid())
9361 // Transform exec config.
9362 ExprResult EC = getDerived().TransformCallExpr(E->getConfig());
9366 // Transform arguments.
9367 bool ArgChanged = false;
9368 SmallVector<Expr*, 8> Args;
9369 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
9373 if (!getDerived().AlwaysRebuild() &&
9374 Callee.get() == E->getCallee() &&
9376 return SemaRef.MaybeBindToTemporary(E);
9378 // FIXME: Wrong source location information for the '('.
9379 SourceLocation FakeLParenLoc
9380 = ((Expr *)Callee.get())->getSourceRange().getBegin();
9381 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
9383 E->getRParenLoc(), EC.get());
9386 template<typename Derived>
9388 TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) {
9389 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
9394 = getDerived().TransformExpr(E->getSubExprAsWritten());
9395 if (SubExpr.isInvalid())
9398 if (!getDerived().AlwaysRebuild() &&
9399 Type == E->getTypeInfoAsWritten() &&
9400 SubExpr.get() == E->getSubExpr())
9402 return getDerived().RebuildCXXNamedCastExpr(
9403 E->getOperatorLoc(), E->getStmtClass(), E->getAngleBrackets().getBegin(),
9404 Type, E->getAngleBrackets().getEnd(),
9405 // FIXME. this should be '(' location
9406 E->getAngleBrackets().getEnd(), SubExpr.get(), E->getRParenLoc());
9409 template<typename Derived>
9411 TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) {
9412 return getDerived().TransformCXXNamedCastExpr(E);
9415 template<typename Derived>
9417 TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
9418 return getDerived().TransformCXXNamedCastExpr(E);
9421 template<typename Derived>
9423 TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
9424 CXXReinterpretCastExpr *E) {
9425 return getDerived().TransformCXXNamedCastExpr(E);
9428 template<typename Derived>
9430 TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) {
9431 return getDerived().TransformCXXNamedCastExpr(E);
9434 template<typename Derived>
9436 TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
9437 CXXFunctionalCastExpr *E) {
9438 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
9443 = getDerived().TransformExpr(E->getSubExprAsWritten());
9444 if (SubExpr.isInvalid())
9447 if (!getDerived().AlwaysRebuild() &&
9448 Type == E->getTypeInfoAsWritten() &&
9449 SubExpr.get() == E->getSubExpr())
9452 return getDerived().RebuildCXXFunctionalCastExpr(Type,
9458 template<typename Derived>
9460 TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) {
9461 if (E->isTypeOperand()) {
9462 TypeSourceInfo *TInfo
9463 = getDerived().TransformType(E->getTypeOperandSourceInfo());
9467 if (!getDerived().AlwaysRebuild() &&
9468 TInfo == E->getTypeOperandSourceInfo())
9471 return getDerived().RebuildCXXTypeidExpr(E->getType(),
9477 // We don't know whether the subexpression is potentially evaluated until
9478 // after we perform semantic analysis. We speculatively assume it is
9479 // unevaluated; it will get fixed later if the subexpression is in fact
9480 // potentially evaluated.
9481 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated,
9482 Sema::ReuseLambdaContextDecl);
9484 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
9485 if (SubExpr.isInvalid())
9488 if (!getDerived().AlwaysRebuild() &&
9489 SubExpr.get() == E->getExprOperand())
9492 return getDerived().RebuildCXXTypeidExpr(E->getType(),
9498 template<typename Derived>
9500 TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) {
9501 if (E->isTypeOperand()) {
9502 TypeSourceInfo *TInfo
9503 = getDerived().TransformType(E->getTypeOperandSourceInfo());
9507 if (!getDerived().AlwaysRebuild() &&
9508 TInfo == E->getTypeOperandSourceInfo())
9511 return getDerived().RebuildCXXUuidofExpr(E->getType(),
9517 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
9519 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
9520 if (SubExpr.isInvalid())
9523 if (!getDerived().AlwaysRebuild() &&
9524 SubExpr.get() == E->getExprOperand())
9527 return getDerived().RebuildCXXUuidofExpr(E->getType(),
9533 template<typename Derived>
9535 TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
9539 template<typename Derived>
9541 TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
9542 CXXNullPtrLiteralExpr *E) {
9546 template<typename Derived>
9548 TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) {
9549 QualType T = getSema().getCurrentThisType();
9551 if (!getDerived().AlwaysRebuild() && T == E->getType()) {
9552 // Make sure that we capture 'this'.
9553 getSema().CheckCXXThisCapture(E->getLocStart());
9557 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit());
9560 template<typename Derived>
9562 TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) {
9563 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
9564 if (SubExpr.isInvalid())
9567 if (!getDerived().AlwaysRebuild() &&
9568 SubExpr.get() == E->getSubExpr())
9571 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(),
9572 E->isThrownVariableInScope());
9575 template<typename Derived>
9577 TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
9579 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(),
9584 if (!getDerived().AlwaysRebuild() &&
9585 Param == E->getParam())
9588 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param);
9591 template<typename Derived>
9593 TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
9595 = cast_or_null<FieldDecl>(getDerived().TransformDecl(E->getLocStart(),
9600 if (!getDerived().AlwaysRebuild() && Field == E->getField())
9603 return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field);
9606 template<typename Derived>
9608 TreeTransform<Derived>::TransformCXXScalarValueInitExpr(
9609 CXXScalarValueInitExpr *E) {
9610 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
9614 if (!getDerived().AlwaysRebuild() &&
9615 T == E->getTypeSourceInfo())
9618 return getDerived().RebuildCXXScalarValueInitExpr(T,
9619 /*FIXME:*/T->getTypeLoc().getEndLoc(),
9623 template<typename Derived>
9625 TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) {
9626 // Transform the type that we're allocating
9627 TypeSourceInfo *AllocTypeInfo
9628 = getDerived().TransformType(E->getAllocatedTypeSourceInfo());
9632 // Transform the size of the array we're allocating (if any).
9633 ExprResult ArraySize = getDerived().TransformExpr(E->getArraySize());
9634 if (ArraySize.isInvalid())
9637 // Transform the placement arguments (if any).
9638 bool ArgumentChanged = false;
9639 SmallVector<Expr*, 8> PlacementArgs;
9640 if (getDerived().TransformExprs(E->getPlacementArgs(),
9641 E->getNumPlacementArgs(), true,
9642 PlacementArgs, &ArgumentChanged))
9645 // Transform the initializer (if any).
9646 Expr *OldInit = E->getInitializer();
9649 NewInit = getDerived().TransformInitializer(OldInit, true);
9650 if (NewInit.isInvalid())
9653 // Transform new operator and delete operator.
9654 FunctionDecl *OperatorNew = nullptr;
9655 if (E->getOperatorNew()) {
9656 OperatorNew = cast_or_null<FunctionDecl>(
9657 getDerived().TransformDecl(E->getLocStart(),
9658 E->getOperatorNew()));
9663 FunctionDecl *OperatorDelete = nullptr;
9664 if (E->getOperatorDelete()) {
9665 OperatorDelete = cast_or_null<FunctionDecl>(
9666 getDerived().TransformDecl(E->getLocStart(),
9667 E->getOperatorDelete()));
9668 if (!OperatorDelete)
9672 if (!getDerived().AlwaysRebuild() &&
9673 AllocTypeInfo == E->getAllocatedTypeSourceInfo() &&
9674 ArraySize.get() == E->getArraySize() &&
9675 NewInit.get() == OldInit &&
9676 OperatorNew == E->getOperatorNew() &&
9677 OperatorDelete == E->getOperatorDelete() &&
9679 // Mark any declarations we need as referenced.
9680 // FIXME: instantiation-specific.
9682 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorNew);
9684 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete);
9686 if (E->isArray() && !E->getAllocatedType()->isDependentType()) {
9687 QualType ElementType
9688 = SemaRef.Context.getBaseElementType(E->getAllocatedType());
9689 if (const RecordType *RecordT = ElementType->getAs<RecordType>()) {
9690 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordT->getDecl());
9691 if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(Record)) {
9692 SemaRef.MarkFunctionReferenced(E->getLocStart(), Destructor);
9700 QualType AllocType = AllocTypeInfo->getType();
9701 if (!ArraySize.get()) {
9702 // If no array size was specified, but the new expression was
9703 // instantiated with an array type (e.g., "new T" where T is
9704 // instantiated with "int[4]"), extract the outer bound from the
9705 // array type as our array size. We do this with constant and
9706 // dependently-sized array types.
9707 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType);
9710 } else if (const ConstantArrayType *ConsArrayT
9711 = dyn_cast<ConstantArrayType>(ArrayT)) {
9712 ArraySize = IntegerLiteral::Create(SemaRef.Context, ConsArrayT->getSize(),
9713 SemaRef.Context.getSizeType(),
9714 /*FIXME:*/ E->getLocStart());
9715 AllocType = ConsArrayT->getElementType();
9716 } else if (const DependentSizedArrayType *DepArrayT
9717 = dyn_cast<DependentSizedArrayType>(ArrayT)) {
9718 if (DepArrayT->getSizeExpr()) {
9719 ArraySize = DepArrayT->getSizeExpr();
9720 AllocType = DepArrayT->getElementType();
9725 return getDerived().RebuildCXXNewExpr(E->getLocStart(),
9727 /*FIXME:*/E->getLocStart(),
9729 /*FIXME:*/E->getLocStart(),
9730 E->getTypeIdParens(),
9734 E->getDirectInitRange(),
9738 template<typename Derived>
9740 TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) {
9741 ExprResult Operand = getDerived().TransformExpr(E->getArgument());
9742 if (Operand.isInvalid())
9745 // Transform the delete operator, if known.
9746 FunctionDecl *OperatorDelete = nullptr;
9747 if (E->getOperatorDelete()) {
9748 OperatorDelete = cast_or_null<FunctionDecl>(
9749 getDerived().TransformDecl(E->getLocStart(),
9750 E->getOperatorDelete()));
9751 if (!OperatorDelete)
9755 if (!getDerived().AlwaysRebuild() &&
9756 Operand.get() == E->getArgument() &&
9757 OperatorDelete == E->getOperatorDelete()) {
9758 // Mark any declarations we need as referenced.
9759 // FIXME: instantiation-specific.
9761 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete);
9763 if (!E->getArgument()->isTypeDependent()) {
9764 QualType Destroyed = SemaRef.Context.getBaseElementType(
9765 E->getDestroyedType());
9766 if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
9767 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
9768 SemaRef.MarkFunctionReferenced(E->getLocStart(),
9769 SemaRef.LookupDestructor(Record));
9776 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(),
9777 E->isGlobalDelete(),
9782 template<typename Derived>
9784 TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
9785 CXXPseudoDestructorExpr *E) {
9786 ExprResult Base = getDerived().TransformExpr(E->getBase());
9787 if (Base.isInvalid())
9790 ParsedType ObjectTypePtr;
9791 bool MayBePseudoDestructor = false;
9792 Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(),
9793 E->getOperatorLoc(),
9794 E->isArrow()? tok::arrow : tok::period,
9796 MayBePseudoDestructor);
9797 if (Base.isInvalid())
9800 QualType ObjectType = ObjectTypePtr.get();
9801 NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc();
9804 = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType);
9809 SS.Adopt(QualifierLoc);
9811 PseudoDestructorTypeStorage Destroyed;
9812 if (E->getDestroyedTypeInfo()) {
9813 TypeSourceInfo *DestroyedTypeInfo
9814 = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(),
9815 ObjectType, nullptr, SS);
9816 if (!DestroyedTypeInfo)
9818 Destroyed = DestroyedTypeInfo;
9819 } else if (!ObjectType.isNull() && ObjectType->isDependentType()) {
9820 // We aren't likely to be able to resolve the identifier down to a type
9821 // now anyway, so just retain the identifier.
9822 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(),
9823 E->getDestroyedTypeLoc());
9825 // Look for a destructor known with the given name.
9826 ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(),
9827 *E->getDestroyedTypeIdentifier(),
9828 E->getDestroyedTypeLoc(),
9836 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T),
9837 E->getDestroyedTypeLoc());
9840 TypeSourceInfo *ScopeTypeInfo = nullptr;
9841 if (E->getScopeTypeInfo()) {
9842 CXXScopeSpec EmptySS;
9843 ScopeTypeInfo = getDerived().TransformTypeInObjectScope(
9844 E->getScopeTypeInfo(), ObjectType, nullptr, EmptySS);
9849 return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(),
9850 E->getOperatorLoc(),
9854 E->getColonColonLoc(),
9859 template <typename Derived>
9860 bool TreeTransform<Derived>::TransformOverloadExprDecls(OverloadExpr *Old,
9863 // Transform all the decls.
9864 bool AllEmptyPacks = true;
9865 for (auto *OldD : Old->decls()) {
9866 Decl *InstD = getDerived().TransformDecl(Old->getNameLoc(), OldD);
9868 // Silently ignore these if a UsingShadowDecl instantiated to nothing.
9869 // This can happen because of dependent hiding.
9870 if (isa<UsingShadowDecl>(OldD))
9878 // Expand using pack declarations.
9879 NamedDecl *SingleDecl = cast<NamedDecl>(InstD);
9880 ArrayRef<NamedDecl*> Decls = SingleDecl;
9881 if (auto *UPD = dyn_cast<UsingPackDecl>(InstD))
9882 Decls = UPD->expansions();
9884 // Expand using declarations.
9885 for (auto *D : Decls) {
9886 if (auto *UD = dyn_cast<UsingDecl>(D)) {
9887 for (auto *SD : UD->shadows())
9894 AllEmptyPacks &= Decls.empty();
9897 // C++ [temp.res]/8.4.2:
9898 // The program is ill-formed, no diagnostic required, if [...] lookup for
9899 // a name in the template definition found a using-declaration, but the
9900 // lookup in the corresponding scope in the instantiation odoes not find
9901 // any declarations because the using-declaration was a pack expansion and
9902 // the corresponding pack is empty
9903 if (AllEmptyPacks && !RequiresADL) {
9904 getSema().Diag(Old->getNameLoc(), diag::err_using_pack_expansion_empty)
9905 << isa<UnresolvedMemberExpr>(Old) << Old->getNameInfo().getName();
9909 // Resolve a kind, but don't do any further analysis. If it's
9910 // ambiguous, the callee needs to deal with it.
9915 template<typename Derived>
9917 TreeTransform<Derived>::TransformUnresolvedLookupExpr(
9918 UnresolvedLookupExpr *Old) {
9919 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(),
9920 Sema::LookupOrdinaryName);
9922 // Transform the declaration set.
9923 if (TransformOverloadExprDecls(Old, Old->requiresADL(), R))
9926 // Rebuild the nested-name qualifier, if present.
9928 if (Old->getQualifierLoc()) {
9929 NestedNameSpecifierLoc QualifierLoc
9930 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
9934 SS.Adopt(QualifierLoc);
9937 if (Old->getNamingClass()) {
9938 CXXRecordDecl *NamingClass
9939 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
9941 Old->getNamingClass()));
9947 R.setNamingClass(NamingClass);
9950 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
9952 // If we have neither explicit template arguments, nor the template keyword,
9953 // it's a normal declaration name or member reference.
9954 if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid()) {
9955 NamedDecl *D = R.getAsSingle<NamedDecl>();
9956 // In a C++11 unevaluated context, an UnresolvedLookupExpr might refer to an
9957 // instance member. In other contexts, BuildPossibleImplicitMemberExpr will
9958 // give a good diagnostic.
9959 if (D && D->isCXXInstanceMember()) {
9960 return SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, R,
9961 /*TemplateArgs=*/nullptr,
9965 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL());
9968 // If we have template arguments, rebuild them, then rebuild the
9969 // templateid expression.
9970 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc());
9971 if (Old->hasExplicitTemplateArgs() &&
9972 getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
9973 Old->getNumTemplateArgs(),
9979 return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R,
9980 Old->requiresADL(), &TransArgs);
9983 template<typename Derived>
9985 TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) {
9986 bool ArgChanged = false;
9987 SmallVector<TypeSourceInfo *, 4> Args;
9988 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
9989 TypeSourceInfo *From = E->getArg(I);
9990 TypeLoc FromTL = From->getTypeLoc();
9991 if (!FromTL.getAs<PackExpansionTypeLoc>()) {
9993 TLB.reserve(FromTL.getFullDataSize());
9994 QualType To = getDerived().TransformType(TLB, FromTL);
9998 if (To == From->getType())
9999 Args.push_back(From);
10001 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
10009 // We have a pack expansion. Instantiate it.
10010 PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>();
10011 TypeLoc PatternTL = ExpansionTL.getPatternLoc();
10012 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
10013 SemaRef.collectUnexpandedParameterPacks(PatternTL, Unexpanded);
10015 // Determine whether the set of unexpanded parameter packs can and should
10017 bool Expand = true;
10018 bool RetainExpansion = false;
10019 Optional<unsigned> OrigNumExpansions =
10020 ExpansionTL.getTypePtr()->getNumExpansions();
10021 Optional<unsigned> NumExpansions = OrigNumExpansions;
10022 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
10023 PatternTL.getSourceRange(),
10025 Expand, RetainExpansion,
10027 return ExprError();
10030 // The transform has determined that we should perform a simple
10031 // transformation on the pack expansion, producing another pack
10033 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
10035 TypeLocBuilder TLB;
10036 TLB.reserve(From->getTypeLoc().getFullDataSize());
10038 QualType To = getDerived().TransformType(TLB, PatternTL);
10040 return ExprError();
10042 To = getDerived().RebuildPackExpansionType(To,
10043 PatternTL.getSourceRange(),
10044 ExpansionTL.getEllipsisLoc(),
10047 return ExprError();
10049 PackExpansionTypeLoc ToExpansionTL
10050 = TLB.push<PackExpansionTypeLoc>(To);
10051 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
10052 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
10056 // Expand the pack expansion by substituting for each argument in the
10058 for (unsigned I = 0; I != *NumExpansions; ++I) {
10059 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
10060 TypeLocBuilder TLB;
10061 TLB.reserve(PatternTL.getFullDataSize());
10062 QualType To = getDerived().TransformType(TLB, PatternTL);
10064 return ExprError();
10066 if (To->containsUnexpandedParameterPack()) {
10067 To = getDerived().RebuildPackExpansionType(To,
10068 PatternTL.getSourceRange(),
10069 ExpansionTL.getEllipsisLoc(),
10072 return ExprError();
10074 PackExpansionTypeLoc ToExpansionTL
10075 = TLB.push<PackExpansionTypeLoc>(To);
10076 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
10079 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
10082 if (!RetainExpansion)
10085 // If we're supposed to retain a pack expansion, do so by temporarily
10086 // forgetting the partially-substituted parameter pack.
10087 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
10089 TypeLocBuilder TLB;
10090 TLB.reserve(From->getTypeLoc().getFullDataSize());
10092 QualType To = getDerived().TransformType(TLB, PatternTL);
10094 return ExprError();
10096 To = getDerived().RebuildPackExpansionType(To,
10097 PatternTL.getSourceRange(),
10098 ExpansionTL.getEllipsisLoc(),
10101 return ExprError();
10103 PackExpansionTypeLoc ToExpansionTL
10104 = TLB.push<PackExpansionTypeLoc>(To);
10105 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
10106 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
10109 if (!getDerived().AlwaysRebuild() && !ArgChanged)
10112 return getDerived().RebuildTypeTrait(E->getTrait(),
10118 template<typename Derived>
10120 TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
10121 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo());
10123 return ExprError();
10125 if (!getDerived().AlwaysRebuild() &&
10126 T == E->getQueriedTypeSourceInfo())
10129 ExprResult SubExpr;
10131 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
10132 SubExpr = getDerived().TransformExpr(E->getDimensionExpression());
10133 if (SubExpr.isInvalid())
10134 return ExprError();
10136 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getDimensionExpression())
10140 return getDerived().RebuildArrayTypeTrait(E->getTrait(),
10147 template<typename Derived>
10149 TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) {
10150 ExprResult SubExpr;
10152 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
10153 SubExpr = getDerived().TransformExpr(E->getQueriedExpression());
10154 if (SubExpr.isInvalid())
10155 return ExprError();
10157 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression())
10161 return getDerived().RebuildExpressionTrait(
10162 E->getTrait(), E->getLocStart(), SubExpr.get(), E->getLocEnd());
10165 template <typename Derived>
10166 ExprResult TreeTransform<Derived>::TransformParenDependentScopeDeclRefExpr(
10167 ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool AddrTaken,
10168 TypeSourceInfo **RecoveryTSI) {
10169 ExprResult NewDRE = getDerived().TransformDependentScopeDeclRefExpr(
10170 DRE, AddrTaken, RecoveryTSI);
10172 // Propagate both errors and recovered types, which return ExprEmpty.
10173 if (!NewDRE.isUsable())
10176 // We got an expr, wrap it up in parens.
10177 if (!getDerived().AlwaysRebuild() && NewDRE.get() == DRE)
10179 return getDerived().RebuildParenExpr(NewDRE.get(), PE->getLParen(),
10183 template <typename Derived>
10184 ExprResult TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
10185 DependentScopeDeclRefExpr *E) {
10186 return TransformDependentScopeDeclRefExpr(E, /*IsAddressOfOperand=*/false,
10190 template<typename Derived>
10192 TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
10193 DependentScopeDeclRefExpr *E,
10194 bool IsAddressOfOperand,
10195 TypeSourceInfo **RecoveryTSI) {
10196 assert(E->getQualifierLoc());
10197 NestedNameSpecifierLoc QualifierLoc
10198 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
10200 return ExprError();
10201 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
10203 // TODO: If this is a conversion-function-id, verify that the
10204 // destination type name (if present) resolves the same way after
10205 // instantiation as it did in the local scope.
10207 DeclarationNameInfo NameInfo
10208 = getDerived().TransformDeclarationNameInfo(E->getNameInfo());
10209 if (!NameInfo.getName())
10210 return ExprError();
10212 if (!E->hasExplicitTemplateArgs()) {
10213 if (!getDerived().AlwaysRebuild() &&
10214 QualifierLoc == E->getQualifierLoc() &&
10215 // Note: it is sufficient to compare the Name component of NameInfo:
10216 // if name has not changed, DNLoc has not changed either.
10217 NameInfo.getName() == E->getDeclName())
10220 return getDerived().RebuildDependentScopeDeclRefExpr(
10221 QualifierLoc, TemplateKWLoc, NameInfo, /*TemplateArgs=*/nullptr,
10222 IsAddressOfOperand, RecoveryTSI);
10225 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
10226 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
10227 E->getNumTemplateArgs(),
10229 return ExprError();
10231 return getDerived().RebuildDependentScopeDeclRefExpr(
10232 QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand,
10236 template<typename Derived>
10238 TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) {
10239 // CXXConstructExprs other than for list-initialization and
10240 // CXXTemporaryObjectExpr are always implicit, so when we have
10241 // a 1-argument construction we just transform that argument.
10242 if ((E->getNumArgs() == 1 ||
10243 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) &&
10244 (!getDerived().DropCallArgument(E->getArg(0))) &&
10245 !E->isListInitialization())
10246 return getDerived().TransformExpr(E->getArg(0));
10248 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName());
10250 QualType T = getDerived().TransformType(E->getType());
10252 return ExprError();
10254 CXXConstructorDecl *Constructor
10255 = cast_or_null<CXXConstructorDecl>(
10256 getDerived().TransformDecl(E->getLocStart(),
10257 E->getConstructor()));
10259 return ExprError();
10261 bool ArgumentChanged = false;
10262 SmallVector<Expr*, 8> Args;
10263 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
10265 return ExprError();
10267 if (!getDerived().AlwaysRebuild() &&
10268 T == E->getType() &&
10269 Constructor == E->getConstructor() &&
10270 !ArgumentChanged) {
10271 // Mark the constructor as referenced.
10272 // FIXME: Instantiation-specific
10273 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor);
10277 return getDerived().RebuildCXXConstructExpr(T, /*FIXME:*/E->getLocStart(),
10279 E->isElidable(), Args,
10280 E->hadMultipleCandidates(),
10281 E->isListInitialization(),
10282 E->isStdInitListInitialization(),
10283 E->requiresZeroInitialization(),
10284 E->getConstructionKind(),
10285 E->getParenOrBraceRange());
10288 template<typename Derived>
10289 ExprResult TreeTransform<Derived>::TransformCXXInheritedCtorInitExpr(
10290 CXXInheritedCtorInitExpr *E) {
10291 QualType T = getDerived().TransformType(E->getType());
10293 return ExprError();
10295 CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
10296 getDerived().TransformDecl(E->getLocStart(), E->getConstructor()));
10298 return ExprError();
10300 if (!getDerived().AlwaysRebuild() &&
10301 T == E->getType() &&
10302 Constructor == E->getConstructor()) {
10303 // Mark the constructor as referenced.
10304 // FIXME: Instantiation-specific
10305 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor);
10309 return getDerived().RebuildCXXInheritedCtorInitExpr(
10310 T, E->getLocation(), Constructor,
10311 E->constructsVBase(), E->inheritedFromVBase());
10314 /// \brief Transform a C++ temporary-binding expression.
10316 /// Since CXXBindTemporaryExpr nodes are implicitly generated, we just
10317 /// transform the subexpression and return that.
10318 template<typename Derived>
10320 TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
10321 return getDerived().TransformExpr(E->getSubExpr());
10324 /// \brief Transform a C++ expression that contains cleanups that should
10325 /// be run after the expression is evaluated.
10327 /// Since ExprWithCleanups nodes are implicitly generated, we
10328 /// just transform the subexpression and return that.
10329 template<typename Derived>
10331 TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) {
10332 return getDerived().TransformExpr(E->getSubExpr());
10335 template<typename Derived>
10337 TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
10338 CXXTemporaryObjectExpr *E) {
10339 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
10341 return ExprError();
10343 CXXConstructorDecl *Constructor
10344 = cast_or_null<CXXConstructorDecl>(
10345 getDerived().TransformDecl(E->getLocStart(),
10346 E->getConstructor()));
10348 return ExprError();
10350 bool ArgumentChanged = false;
10351 SmallVector<Expr*, 8> Args;
10352 Args.reserve(E->getNumArgs());
10353 if (TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
10355 return ExprError();
10357 if (!getDerived().AlwaysRebuild() &&
10358 T == E->getTypeSourceInfo() &&
10359 Constructor == E->getConstructor() &&
10360 !ArgumentChanged) {
10361 // FIXME: Instantiation-specific
10362 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor);
10363 return SemaRef.MaybeBindToTemporary(E);
10366 // FIXME: Pass in E->isListInitialization().
10367 return getDerived().RebuildCXXTemporaryObjectExpr(T,
10368 /*FIXME:*/T->getTypeLoc().getEndLoc(),
10373 template<typename Derived>
10375 TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
10376 // Transform any init-capture expressions before entering the scope of the
10377 // lambda body, because they are not semantically within that scope.
10378 typedef std::pair<ExprResult, QualType> InitCaptureInfoTy;
10379 SmallVector<InitCaptureInfoTy, 8> InitCaptureExprsAndTypes;
10380 InitCaptureExprsAndTypes.resize(E->explicit_capture_end() -
10381 E->explicit_capture_begin());
10382 for (LambdaExpr::capture_iterator C = E->capture_begin(),
10383 CEnd = E->capture_end();
10385 if (!E->isInitCapture(C))
10387 EnterExpressionEvaluationContext EEEC(getSema(),
10388 Sema::PotentiallyEvaluated);
10389 ExprResult NewExprInitResult = getDerived().TransformInitializer(
10390 C->getCapturedVar()->getInit(),
10391 C->getCapturedVar()->getInitStyle() == VarDecl::CallInit);
10393 if (NewExprInitResult.isInvalid())
10394 return ExprError();
10395 Expr *NewExprInit = NewExprInitResult.get();
10397 VarDecl *OldVD = C->getCapturedVar();
10398 QualType NewInitCaptureType =
10399 getSema().buildLambdaInitCaptureInitialization(
10400 C->getLocation(), OldVD->getType()->isReferenceType(),
10401 OldVD->getIdentifier(),
10402 C->getCapturedVar()->getInitStyle() != VarDecl::CInit, NewExprInit);
10403 NewExprInitResult = NewExprInit;
10404 InitCaptureExprsAndTypes[C - E->capture_begin()] =
10405 std::make_pair(NewExprInitResult, NewInitCaptureType);
10408 // Transform the template parameters, and add them to the current
10409 // instantiation scope. The null case is handled correctly.
10410 auto TPL = getDerived().TransformTemplateParameterList(
10411 E->getTemplateParameterList());
10413 // Transform the type of the original lambda's call operator.
10414 // The transformation MUST be done in the CurrentInstantiationScope since
10415 // it introduces a mapping of the original to the newly created
10416 // transformed parameters.
10417 TypeSourceInfo *NewCallOpTSI = nullptr;
10419 TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo();
10420 FunctionProtoTypeLoc OldCallOpFPTL =
10421 OldCallOpTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>();
10423 TypeLocBuilder NewCallOpTLBuilder;
10424 SmallVector<QualType, 4> ExceptionStorage;
10425 TreeTransform *This = this; // Work around gcc.gnu.org/PR56135.
10426 QualType NewCallOpType = TransformFunctionProtoType(
10427 NewCallOpTLBuilder, OldCallOpFPTL, nullptr, 0,
10428 [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) {
10429 return This->TransformExceptionSpec(OldCallOpFPTL.getBeginLoc(), ESI,
10430 ExceptionStorage, Changed);
10432 if (NewCallOpType.isNull())
10433 return ExprError();
10434 NewCallOpTSI = NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context,
10438 LambdaScopeInfo *LSI = getSema().PushLambdaScope();
10439 Sema::FunctionScopeRAII FuncScopeCleanup(getSema());
10440 LSI->GLTemplateParameterList = TPL;
10442 // Create the local class that will describe the lambda.
10443 CXXRecordDecl *Class
10444 = getSema().createLambdaClosureType(E->getIntroducerRange(),
10446 /*KnownDependent=*/false,
10447 E->getCaptureDefault());
10448 getDerived().transformedLocalDecl(E->getLambdaClass(), Class);
10450 // Build the call operator.
10451 CXXMethodDecl *NewCallOperator = getSema().startLambdaDefinition(
10452 Class, E->getIntroducerRange(), NewCallOpTSI,
10453 E->getCallOperator()->getLocEnd(),
10454 NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams(),
10455 E->getCallOperator()->isConstexpr());
10457 LSI->CallOperator = NewCallOperator;
10459 for (unsigned I = 0, NumParams = NewCallOperator->getNumParams();
10460 I != NumParams; ++I) {
10461 auto *P = NewCallOperator->getParamDecl(I);
10462 if (P->hasUninstantiatedDefaultArg()) {
10463 EnterExpressionEvaluationContext Eval(
10464 getSema(), Sema::PotentiallyEvaluatedIfUsed, P);
10465 ExprResult R = getDerived().TransformExpr(
10466 E->getCallOperator()->getParamDecl(I)->getDefaultArg());
10467 P->setDefaultArg(R.get());
10471 getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
10472 getDerived().transformedLocalDecl(E->getCallOperator(), NewCallOperator);
10474 // Introduce the context of the call operator.
10475 Sema::ContextRAII SavedContext(getSema(), NewCallOperator,
10476 /*NewThisContext*/false);
10478 // Enter the scope of the lambda.
10479 getSema().buildLambdaScope(LSI, NewCallOperator,
10480 E->getIntroducerRange(),
10481 E->getCaptureDefault(),
10482 E->getCaptureDefaultLoc(),
10483 E->hasExplicitParameters(),
10484 E->hasExplicitResultType(),
10487 bool Invalid = false;
10489 // Transform captures.
10490 bool FinishedExplicitCaptures = false;
10491 for (LambdaExpr::capture_iterator C = E->capture_begin(),
10492 CEnd = E->capture_end();
10494 // When we hit the first implicit capture, tell Sema that we've finished
10495 // the list of explicit captures.
10496 if (!FinishedExplicitCaptures && C->isImplicit()) {
10497 getSema().finishLambdaExplicitCaptures(LSI);
10498 FinishedExplicitCaptures = true;
10501 // Capturing 'this' is trivial.
10502 if (C->capturesThis()) {
10503 getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(),
10504 /*BuildAndDiagnose*/ true, nullptr,
10505 C->getCaptureKind() == LCK_StarThis);
10508 // Captured expression will be recaptured during captured variables
10510 if (C->capturesVLAType())
10513 // Rebuild init-captures, including the implied field declaration.
10514 if (E->isInitCapture(C)) {
10515 InitCaptureInfoTy InitExprTypePair =
10516 InitCaptureExprsAndTypes[C - E->capture_begin()];
10517 ExprResult Init = InitExprTypePair.first;
10518 QualType InitQualType = InitExprTypePair.second;
10519 if (Init.isInvalid() || InitQualType.isNull()) {
10523 VarDecl *OldVD = C->getCapturedVar();
10524 VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl(
10525 OldVD->getLocation(), InitExprTypePair.second, OldVD->getIdentifier(),
10526 OldVD->getInitStyle(), Init.get());
10530 getDerived().transformedLocalDecl(OldVD, NewVD);
10532 getSema().buildInitCaptureField(LSI, NewVD);
10536 assert(C->capturesVariable() && "unexpected kind of lambda capture");
10538 // Determine the capture kind for Sema.
10539 Sema::TryCaptureKind Kind
10540 = C->isImplicit()? Sema::TryCapture_Implicit
10541 : C->getCaptureKind() == LCK_ByCopy
10542 ? Sema::TryCapture_ExplicitByVal
10543 : Sema::TryCapture_ExplicitByRef;
10544 SourceLocation EllipsisLoc;
10545 if (C->isPackExpansion()) {
10546 UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation());
10547 bool ShouldExpand = false;
10548 bool RetainExpansion = false;
10549 Optional<unsigned> NumExpansions;
10550 if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(),
10553 ShouldExpand, RetainExpansion,
10559 if (ShouldExpand) {
10560 // The transform has determined that we should perform an expansion;
10561 // transform and capture each of the arguments.
10562 // expansion of the pattern. Do so.
10563 VarDecl *Pack = C->getCapturedVar();
10564 for (unsigned I = 0; I != *NumExpansions; ++I) {
10565 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
10566 VarDecl *CapturedVar
10567 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
10569 if (!CapturedVar) {
10574 // Capture the transformed variable.
10575 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind);
10578 // FIXME: Retain a pack expansion if RetainExpansion is true.
10583 EllipsisLoc = C->getEllipsisLoc();
10586 // Transform the captured variable.
10587 VarDecl *CapturedVar
10588 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
10589 C->getCapturedVar()));
10590 if (!CapturedVar || CapturedVar->isInvalidDecl()) {
10595 // Capture the transformed variable.
10596 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind,
10599 if (!FinishedExplicitCaptures)
10600 getSema().finishLambdaExplicitCaptures(LSI);
10602 // Enter a new evaluation context to insulate the lambda from any
10603 // cleanups from the enclosing full-expression.
10604 getSema().PushExpressionEvaluationContext(Sema::PotentiallyEvaluated);
10606 // Instantiate the body of the lambda expression.
10608 Invalid ? StmtError() : getDerived().TransformStmt(E->getBody());
10610 // ActOnLambda* will pop the function scope for us.
10611 FuncScopeCleanup.disable();
10613 if (Body.isInvalid()) {
10614 SavedContext.pop();
10615 getSema().ActOnLambdaError(E->getLocStart(), /*CurScope=*/nullptr,
10616 /*IsInstantiation=*/true);
10617 return ExprError();
10620 // Copy the LSI before ActOnFinishFunctionBody removes it.
10621 // FIXME: This is dumb. Store the lambda information somewhere that outlives
10622 // the call operator.
10623 auto LSICopy = *LSI;
10624 getSema().ActOnFinishFunctionBody(NewCallOperator, Body.get(),
10625 /*IsInstantiation*/ true);
10626 SavedContext.pop();
10628 return getSema().BuildLambdaExpr(E->getLocStart(), Body.get()->getLocEnd(),
10632 template<typename Derived>
10634 TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
10635 CXXUnresolvedConstructExpr *E) {
10636 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
10638 return ExprError();
10640 bool ArgumentChanged = false;
10641 SmallVector<Expr*, 8> Args;
10642 Args.reserve(E->arg_size());
10643 if (getDerived().TransformExprs(E->arg_begin(), E->arg_size(), true, Args,
10645 return ExprError();
10647 if (!getDerived().AlwaysRebuild() &&
10648 T == E->getTypeSourceInfo() &&
10652 // FIXME: we're faking the locations of the commas
10653 return getDerived().RebuildCXXUnresolvedConstructExpr(T,
10656 E->getRParenLoc());
10659 template<typename Derived>
10661 TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
10662 CXXDependentScopeMemberExpr *E) {
10663 // Transform the base of the expression.
10664 ExprResult Base((Expr*) nullptr);
10667 QualType ObjectType;
10668 if (!E->isImplicitAccess()) {
10669 OldBase = E->getBase();
10670 Base = getDerived().TransformExpr(OldBase);
10671 if (Base.isInvalid())
10672 return ExprError();
10674 // Start the member reference and compute the object's type.
10675 ParsedType ObjectTy;
10676 bool MayBePseudoDestructor = false;
10677 Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(),
10678 E->getOperatorLoc(),
10679 E->isArrow()? tok::arrow : tok::period,
10681 MayBePseudoDestructor);
10682 if (Base.isInvalid())
10683 return ExprError();
10685 ObjectType = ObjectTy.get();
10686 BaseType = ((Expr*) Base.get())->getType();
10689 BaseType = getDerived().TransformType(E->getBaseType());
10690 ObjectType = BaseType->getAs<PointerType>()->getPointeeType();
10693 // Transform the first part of the nested-name-specifier that qualifies
10694 // the member name.
10695 NamedDecl *FirstQualifierInScope
10696 = getDerived().TransformFirstQualifierInScope(
10697 E->getFirstQualifierFoundInScope(),
10698 E->getQualifierLoc().getBeginLoc());
10700 NestedNameSpecifierLoc QualifierLoc;
10701 if (E->getQualifier()) {
10703 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(),
10705 FirstQualifierInScope);
10707 return ExprError();
10710 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
10712 // TODO: If this is a conversion-function-id, verify that the
10713 // destination type name (if present) resolves the same way after
10714 // instantiation as it did in the local scope.
10716 DeclarationNameInfo NameInfo
10717 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo());
10718 if (!NameInfo.getName())
10719 return ExprError();
10721 if (!E->hasExplicitTemplateArgs()) {
10722 // This is a reference to a member without an explicitly-specified
10723 // template argument list. Optimize for this common case.
10724 if (!getDerived().AlwaysRebuild() &&
10725 Base.get() == OldBase &&
10726 BaseType == E->getBaseType() &&
10727 QualifierLoc == E->getQualifierLoc() &&
10728 NameInfo.getName() == E->getMember() &&
10729 FirstQualifierInScope == E->getFirstQualifierFoundInScope())
10732 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
10735 E->getOperatorLoc(),
10738 FirstQualifierInScope,
10740 /*TemplateArgs*/nullptr);
10743 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
10744 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
10745 E->getNumTemplateArgs(),
10747 return ExprError();
10749 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
10752 E->getOperatorLoc(),
10755 FirstQualifierInScope,
10760 template<typename Derived>
10762 TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) {
10763 // Transform the base of the expression.
10764 ExprResult Base((Expr*) nullptr);
10766 if (!Old->isImplicitAccess()) {
10767 Base = getDerived().TransformExpr(Old->getBase());
10768 if (Base.isInvalid())
10769 return ExprError();
10770 Base = getSema().PerformMemberExprBaseConversion(Base.get(),
10772 if (Base.isInvalid())
10773 return ExprError();
10774 BaseType = Base.get()->getType();
10776 BaseType = getDerived().TransformType(Old->getBaseType());
10779 NestedNameSpecifierLoc QualifierLoc;
10780 if (Old->getQualifierLoc()) {
10782 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
10784 return ExprError();
10787 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
10789 LookupResult R(SemaRef, Old->getMemberNameInfo(),
10790 Sema::LookupOrdinaryName);
10792 // Transform the declaration set.
10793 if (TransformOverloadExprDecls(Old, /*RequiresADL*/false, R))
10794 return ExprError();
10796 // Determine the naming class.
10797 if (Old->getNamingClass()) {
10798 CXXRecordDecl *NamingClass
10799 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
10800 Old->getMemberLoc(),
10801 Old->getNamingClass()));
10803 return ExprError();
10805 R.setNamingClass(NamingClass);
10808 TemplateArgumentListInfo TransArgs;
10809 if (Old->hasExplicitTemplateArgs()) {
10810 TransArgs.setLAngleLoc(Old->getLAngleLoc());
10811 TransArgs.setRAngleLoc(Old->getRAngleLoc());
10812 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
10813 Old->getNumTemplateArgs(),
10815 return ExprError();
10818 // FIXME: to do this check properly, we will need to preserve the
10819 // first-qualifier-in-scope here, just in case we had a dependent
10820 // base (and therefore couldn't do the check) and a
10821 // nested-name-qualifier (and therefore could do the lookup).
10822 NamedDecl *FirstQualifierInScope = nullptr;
10824 return getDerived().RebuildUnresolvedMemberExpr(Base.get(),
10826 Old->getOperatorLoc(),
10830 FirstQualifierInScope,
10832 (Old->hasExplicitTemplateArgs()
10833 ? &TransArgs : nullptr));
10836 template<typename Derived>
10838 TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) {
10839 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
10840 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand());
10841 if (SubExpr.isInvalid())
10842 return ExprError();
10844 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand())
10847 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get());
10850 template<typename Derived>
10852 TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) {
10853 ExprResult Pattern = getDerived().TransformExpr(E->getPattern());
10854 if (Pattern.isInvalid())
10855 return ExprError();
10857 if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern())
10860 return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(),
10861 E->getNumExpansions());
10864 template<typename Derived>
10866 TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) {
10867 // If E is not value-dependent, then nothing will change when we transform it.
10868 // Note: This is an instantiation-centric view.
10869 if (!E->isValueDependent())
10872 EnterExpressionEvaluationContext Unevaluated(getSema(), Sema::Unevaluated);
10874 ArrayRef<TemplateArgument> PackArgs;
10875 TemplateArgument ArgStorage;
10877 // Find the argument list to transform.
10878 if (E->isPartiallySubstituted()) {
10879 PackArgs = E->getPartialArguments();
10880 } else if (E->isValueDependent()) {
10881 UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc());
10882 bool ShouldExpand = false;
10883 bool RetainExpansion = false;
10884 Optional<unsigned> NumExpansions;
10885 if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(),
10887 ShouldExpand, RetainExpansion,
10889 return ExprError();
10891 // If we need to expand the pack, build a template argument from it and
10893 if (ShouldExpand) {
10894 auto *Pack = E->getPack();
10895 if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Pack)) {
10896 ArgStorage = getSema().Context.getPackExpansionType(
10897 getSema().Context.getTypeDeclType(TTPD), None);
10898 } else if (auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Pack)) {
10899 ArgStorage = TemplateArgument(TemplateName(TTPD), None);
10901 auto *VD = cast<ValueDecl>(Pack);
10902 ExprResult DRE = getSema().BuildDeclRefExpr(VD, VD->getType(),
10903 VK_RValue, E->getPackLoc());
10904 if (DRE.isInvalid())
10905 return ExprError();
10906 ArgStorage = new (getSema().Context) PackExpansionExpr(
10907 getSema().Context.DependentTy, DRE.get(), E->getPackLoc(), None);
10909 PackArgs = ArgStorage;
10913 // If we're not expanding the pack, just transform the decl.
10914 if (!PackArgs.size()) {
10915 auto *Pack = cast_or_null<NamedDecl>(
10916 getDerived().TransformDecl(E->getPackLoc(), E->getPack()));
10918 return ExprError();
10919 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), Pack,
10921 E->getRParenLoc(), None, None);
10924 // Try to compute the result without performing a partial substitution.
10925 Optional<unsigned> Result = 0;
10926 for (const TemplateArgument &Arg : PackArgs) {
10927 if (!Arg.isPackExpansion()) {
10928 Result = *Result + 1;
10932 TemplateArgumentLoc ArgLoc;
10933 InventTemplateArgumentLoc(Arg, ArgLoc);
10935 // Find the pattern of the pack expansion.
10936 SourceLocation Ellipsis;
10937 Optional<unsigned> OrigNumExpansions;
10938 TemplateArgumentLoc Pattern =
10939 getSema().getTemplateArgumentPackExpansionPattern(ArgLoc, Ellipsis,
10940 OrigNumExpansions);
10942 // Substitute under the pack expansion. Do not expand the pack (yet).
10943 TemplateArgumentLoc OutPattern;
10944 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
10945 if (getDerived().TransformTemplateArgument(Pattern, OutPattern,
10949 // See if we can determine the number of arguments from the result.
10950 Optional<unsigned> NumExpansions =
10951 getSema().getFullyPackExpandedSize(OutPattern.getArgument());
10952 if (!NumExpansions) {
10953 // No: we must be in an alias template expansion, and we're going to need
10954 // to actually expand the packs.
10959 Result = *Result + *NumExpansions;
10962 // Common case: we could determine the number of expansions without
10965 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
10967 E->getRParenLoc(), *Result, None);
10969 TemplateArgumentListInfo TransformedPackArgs(E->getPackLoc(),
10972 TemporaryBase Rebase(*this, E->getPackLoc(), getBaseEntity());
10973 typedef TemplateArgumentLocInventIterator<
10974 Derived, const TemplateArgument*> PackLocIterator;
10975 if (TransformTemplateArguments(PackLocIterator(*this, PackArgs.begin()),
10976 PackLocIterator(*this, PackArgs.end()),
10977 TransformedPackArgs, /*Uneval*/true))
10978 return ExprError();
10981 // Check whether we managed to fully-expand the pack.
10982 // FIXME: Is it possible for us to do so and not hit the early exit path?
10983 SmallVector<TemplateArgument, 8> Args;
10984 bool PartialSubstitution = false;
10985 for (auto &Loc : TransformedPackArgs.arguments()) {
10986 Args.push_back(Loc.getArgument());
10987 if (Loc.getArgument().isPackExpansion())
10988 PartialSubstitution = true;
10991 if (PartialSubstitution)
10992 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
10994 E->getRParenLoc(), None, Args);
10996 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
10997 E->getPackLoc(), E->getRParenLoc(),
10998 Args.size(), None);
11001 template<typename Derived>
11003 TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr(
11004 SubstNonTypeTemplateParmPackExpr *E) {
11005 // Default behavior is to do nothing with this transformation.
11009 template<typename Derived>
11011 TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr(
11012 SubstNonTypeTemplateParmExpr *E) {
11013 // Default behavior is to do nothing with this transformation.
11017 template<typename Derived>
11019 TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
11020 // Default behavior is to do nothing with this transformation.
11024 template<typename Derived>
11026 TreeTransform<Derived>::TransformMaterializeTemporaryExpr(
11027 MaterializeTemporaryExpr *E) {
11028 return getDerived().TransformExpr(E->GetTemporaryExpr());
11031 template<typename Derived>
11033 TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) {
11034 Expr *Pattern = E->getPattern();
11036 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
11037 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
11038 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
11040 // Determine whether the set of unexpanded parameter packs can and should
11042 bool Expand = true;
11043 bool RetainExpansion = false;
11044 Optional<unsigned> NumExpansions;
11045 if (getDerived().TryExpandParameterPacks(E->getEllipsisLoc(),
11046 Pattern->getSourceRange(),
11048 Expand, RetainExpansion,
11053 // Do not expand any packs here, just transform and rebuild a fold
11055 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
11058 E->getLHS() ? getDerived().TransformExpr(E->getLHS()) : ExprResult();
11059 if (LHS.isInvalid())
11063 E->getRHS() ? getDerived().TransformExpr(E->getRHS()) : ExprResult();
11064 if (RHS.isInvalid())
11067 if (!getDerived().AlwaysRebuild() &&
11068 LHS.get() == E->getLHS() && RHS.get() == E->getRHS())
11071 return getDerived().RebuildCXXFoldExpr(
11072 E->getLocStart(), LHS.get(), E->getOperator(), E->getEllipsisLoc(),
11073 RHS.get(), E->getLocEnd());
11076 // The transform has determined that we should perform an elementwise
11077 // expansion of the pattern. Do so.
11078 ExprResult Result = getDerived().TransformExpr(E->getInit());
11079 if (Result.isInvalid())
11081 bool LeftFold = E->isLeftFold();
11083 // If we're retaining an expansion for a right fold, it is the innermost
11084 // component and takes the init (if any).
11085 if (!LeftFold && RetainExpansion) {
11086 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
11088 ExprResult Out = getDerived().TransformExpr(Pattern);
11089 if (Out.isInvalid())
11092 Result = getDerived().RebuildCXXFoldExpr(
11093 E->getLocStart(), Out.get(), E->getOperator(), E->getEllipsisLoc(),
11094 Result.get(), E->getLocEnd());
11095 if (Result.isInvalid())
11099 for (unsigned I = 0; I != *NumExpansions; ++I) {
11100 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(
11101 getSema(), LeftFold ? I : *NumExpansions - I - 1);
11102 ExprResult Out = getDerived().TransformExpr(Pattern);
11103 if (Out.isInvalid())
11106 if (Out.get()->containsUnexpandedParameterPack()) {
11107 // We still have a pack; retain a pack expansion for this slice.
11108 Result = getDerived().RebuildCXXFoldExpr(
11110 LeftFold ? Result.get() : Out.get(),
11111 E->getOperator(), E->getEllipsisLoc(),
11112 LeftFold ? Out.get() : Result.get(),
11114 } else if (Result.isUsable()) {
11115 // We've got down to a single element; build a binary operator.
11116 Result = getDerived().RebuildBinaryOperator(
11117 E->getEllipsisLoc(), E->getOperator(),
11118 LeftFold ? Result.get() : Out.get(),
11119 LeftFold ? Out.get() : Result.get());
11123 if (Result.isInvalid())
11127 // If we're retaining an expansion for a left fold, it is the outermost
11128 // component and takes the complete expansion so far as its init (if any).
11129 if (LeftFold && RetainExpansion) {
11130 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
11132 ExprResult Out = getDerived().TransformExpr(Pattern);
11133 if (Out.isInvalid())
11136 Result = getDerived().RebuildCXXFoldExpr(
11137 E->getLocStart(), Result.get(),
11138 E->getOperator(), E->getEllipsisLoc(),
11139 Out.get(), E->getLocEnd());
11140 if (Result.isInvalid())
11144 // If we had no init and an empty pack, and we're not retaining an expansion,
11145 // then produce a fallback value or error.
11146 if (Result.isUnset())
11147 return getDerived().RebuildEmptyCXXFoldExpr(E->getEllipsisLoc(),
11153 template<typename Derived>
11155 TreeTransform<Derived>::TransformCXXStdInitializerListExpr(
11156 CXXStdInitializerListExpr *E) {
11157 return getDerived().TransformExpr(E->getSubExpr());
11160 template<typename Derived>
11162 TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) {
11163 return SemaRef.MaybeBindToTemporary(E);
11166 template<typename Derived>
11168 TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
11172 template<typename Derived>
11174 TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) {
11175 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
11176 if (SubExpr.isInvalid())
11177 return ExprError();
11179 if (!getDerived().AlwaysRebuild() &&
11180 SubExpr.get() == E->getSubExpr())
11183 return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get());
11186 template<typename Derived>
11188 TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *E) {
11189 // Transform each of the elements.
11190 SmallVector<Expr *, 8> Elements;
11191 bool ArgChanged = false;
11192 if (getDerived().TransformExprs(E->getElements(), E->getNumElements(),
11193 /*IsCall=*/false, Elements, &ArgChanged))
11194 return ExprError();
11196 if (!getDerived().AlwaysRebuild() && !ArgChanged)
11197 return SemaRef.MaybeBindToTemporary(E);
11199 return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(),
11204 template<typename Derived>
11206 TreeTransform<Derived>::TransformObjCDictionaryLiteral(
11207 ObjCDictionaryLiteral *E) {
11208 // Transform each of the elements.
11209 SmallVector<ObjCDictionaryElement, 8> Elements;
11210 bool ArgChanged = false;
11211 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
11212 ObjCDictionaryElement OrigElement = E->getKeyValueElement(I);
11214 if (OrigElement.isPackExpansion()) {
11215 // This key/value element is a pack expansion.
11216 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
11217 getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded);
11218 getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded);
11219 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
11221 // Determine whether the set of unexpanded parameter packs can
11222 // and should be expanded.
11223 bool Expand = true;
11224 bool RetainExpansion = false;
11225 Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions;
11226 Optional<unsigned> NumExpansions = OrigNumExpansions;
11227 SourceRange PatternRange(OrigElement.Key->getLocStart(),
11228 OrigElement.Value->getLocEnd());
11229 if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc,
11232 Expand, RetainExpansion,
11234 return ExprError();
11237 // The transform has determined that we should perform a simple
11238 // transformation on the pack expansion, producing another pack
11240 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
11241 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
11242 if (Key.isInvalid())
11243 return ExprError();
11245 if (Key.get() != OrigElement.Key)
11248 ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
11249 if (Value.isInvalid())
11250 return ExprError();
11252 if (Value.get() != OrigElement.Value)
11255 ObjCDictionaryElement Expansion = {
11256 Key.get(), Value.get(), OrigElement.EllipsisLoc, NumExpansions
11258 Elements.push_back(Expansion);
11262 // Record right away that the argument was changed. This needs
11263 // to happen even if the array expands to nothing.
11266 // The transform has determined that we should perform an elementwise
11267 // expansion of the pattern. Do so.
11268 for (unsigned I = 0; I != *NumExpansions; ++I) {
11269 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
11270 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
11271 if (Key.isInvalid())
11272 return ExprError();
11274 ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
11275 if (Value.isInvalid())
11276 return ExprError();
11278 ObjCDictionaryElement Element = {
11279 Key.get(), Value.get(), SourceLocation(), NumExpansions
11282 // If any unexpanded parameter packs remain, we still have a
11284 // FIXME: Can this really happen?
11285 if (Key.get()->containsUnexpandedParameterPack() ||
11286 Value.get()->containsUnexpandedParameterPack())
11287 Element.EllipsisLoc = OrigElement.EllipsisLoc;
11289 Elements.push_back(Element);
11292 // FIXME: Retain a pack expansion if RetainExpansion is true.
11294 // We've finished with this pack expansion.
11298 // Transform and check key.
11299 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
11300 if (Key.isInvalid())
11301 return ExprError();
11303 if (Key.get() != OrigElement.Key)
11306 // Transform and check value.
11308 = getDerived().TransformExpr(OrigElement.Value);
11309 if (Value.isInvalid())
11310 return ExprError();
11312 if (Value.get() != OrigElement.Value)
11315 ObjCDictionaryElement Element = {
11316 Key.get(), Value.get(), SourceLocation(), None
11318 Elements.push_back(Element);
11321 if (!getDerived().AlwaysRebuild() && !ArgChanged)
11322 return SemaRef.MaybeBindToTemporary(E);
11324 return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(),
11328 template<typename Derived>
11330 TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) {
11331 TypeSourceInfo *EncodedTypeInfo
11332 = getDerived().TransformType(E->getEncodedTypeSourceInfo());
11333 if (!EncodedTypeInfo)
11334 return ExprError();
11336 if (!getDerived().AlwaysRebuild() &&
11337 EncodedTypeInfo == E->getEncodedTypeSourceInfo())
11340 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(),
11342 E->getRParenLoc());
11345 template<typename Derived>
11346 ExprResult TreeTransform<Derived>::
11347 TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
11348 // This is a kind of implicit conversion, and it needs to get dropped
11349 // and recomputed for the same general reasons that ImplicitCastExprs
11350 // do, as well a more specific one: this expression is only valid when
11351 // it appears *immediately* as an argument expression.
11352 return getDerived().TransformExpr(E->getSubExpr());
11355 template<typename Derived>
11356 ExprResult TreeTransform<Derived>::
11357 TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
11358 TypeSourceInfo *TSInfo
11359 = getDerived().TransformType(E->getTypeInfoAsWritten());
11361 return ExprError();
11363 ExprResult Result = getDerived().TransformExpr(E->getSubExpr());
11364 if (Result.isInvalid())
11365 return ExprError();
11367 if (!getDerived().AlwaysRebuild() &&
11368 TSInfo == E->getTypeInfoAsWritten() &&
11369 Result.get() == E->getSubExpr())
11372 return SemaRef.BuildObjCBridgedCast(E->getLParenLoc(), E->getBridgeKind(),
11373 E->getBridgeKeywordLoc(), TSInfo,
11377 template <typename Derived>
11378 ExprResult TreeTransform<Derived>::TransformObjCAvailabilityCheckExpr(
11379 ObjCAvailabilityCheckExpr *E) {
11383 template<typename Derived>
11385 TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) {
11386 // Transform arguments.
11387 bool ArgChanged = false;
11388 SmallVector<Expr*, 8> Args;
11389 Args.reserve(E->getNumArgs());
11390 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args,
11392 return ExprError();
11394 if (E->getReceiverKind() == ObjCMessageExpr::Class) {
11395 // Class message: transform the receiver type.
11396 TypeSourceInfo *ReceiverTypeInfo
11397 = getDerived().TransformType(E->getClassReceiverTypeInfo());
11398 if (!ReceiverTypeInfo)
11399 return ExprError();
11401 // If nothing changed, just retain the existing message send.
11402 if (!getDerived().AlwaysRebuild() &&
11403 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged)
11404 return SemaRef.MaybeBindToTemporary(E);
11406 // Build a new class message send.
11407 SmallVector<SourceLocation, 16> SelLocs;
11408 E->getSelectorLocs(SelLocs);
11409 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo,
11412 E->getMethodDecl(),
11417 else if (E->getReceiverKind() == ObjCMessageExpr::SuperClass ||
11418 E->getReceiverKind() == ObjCMessageExpr::SuperInstance) {
11419 if (!E->getMethodDecl())
11420 return ExprError();
11422 // Build a new class message send to 'super'.
11423 SmallVector<SourceLocation, 16> SelLocs;
11424 E->getSelectorLocs(SelLocs);
11425 return getDerived().RebuildObjCMessageExpr(E->getSuperLoc(),
11428 E->getReceiverType(),
11429 E->getMethodDecl(),
11435 // Instance message: transform the receiver
11436 assert(E->getReceiverKind() == ObjCMessageExpr::Instance &&
11437 "Only class and instance messages may be instantiated");
11438 ExprResult Receiver
11439 = getDerived().TransformExpr(E->getInstanceReceiver());
11440 if (Receiver.isInvalid())
11441 return ExprError();
11443 // If nothing changed, just retain the existing message send.
11444 if (!getDerived().AlwaysRebuild() &&
11445 Receiver.get() == E->getInstanceReceiver() && !ArgChanged)
11446 return SemaRef.MaybeBindToTemporary(E);
11448 // Build a new instance message send.
11449 SmallVector<SourceLocation, 16> SelLocs;
11450 E->getSelectorLocs(SelLocs);
11451 return getDerived().RebuildObjCMessageExpr(Receiver.get(),
11454 E->getMethodDecl(),
11460 template<typename Derived>
11462 TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) {
11466 template<typename Derived>
11468 TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) {
11472 template<typename Derived>
11474 TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) {
11475 // Transform the base expression.
11476 ExprResult Base = getDerived().TransformExpr(E->getBase());
11477 if (Base.isInvalid())
11478 return ExprError();
11480 // We don't need to transform the ivar; it will never change.
11482 // If nothing changed, just retain the existing expression.
11483 if (!getDerived().AlwaysRebuild() &&
11484 Base.get() == E->getBase())
11487 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(),
11489 E->isArrow(), E->isFreeIvar());
11492 template<typename Derived>
11494 TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
11495 // 'super' and types never change. Property never changes. Just
11496 // retain the existing expression.
11497 if (!E->isObjectReceiver())
11500 // Transform the base expression.
11501 ExprResult Base = getDerived().TransformExpr(E->getBase());
11502 if (Base.isInvalid())
11503 return ExprError();
11505 // We don't need to transform the property; it will never change.
11507 // If nothing changed, just retain the existing expression.
11508 if (!getDerived().AlwaysRebuild() &&
11509 Base.get() == E->getBase())
11512 if (E->isExplicitProperty())
11513 return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
11514 E->getExplicitProperty(),
11517 return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
11518 SemaRef.Context.PseudoObjectTy,
11519 E->getImplicitPropertyGetter(),
11520 E->getImplicitPropertySetter(),
11524 template<typename Derived>
11526 TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
11527 // Transform the base expression.
11528 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
11529 if (Base.isInvalid())
11530 return ExprError();
11532 // Transform the key expression.
11533 ExprResult Key = getDerived().TransformExpr(E->getKeyExpr());
11534 if (Key.isInvalid())
11535 return ExprError();
11537 // If nothing changed, just retain the existing expression.
11538 if (!getDerived().AlwaysRebuild() &&
11539 Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr())
11542 return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(),
11543 Base.get(), Key.get(),
11544 E->getAtIndexMethodDecl(),
11545 E->setAtIndexMethodDecl());
11548 template<typename Derived>
11550 TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) {
11551 // Transform the base expression.
11552 ExprResult Base = getDerived().TransformExpr(E->getBase());
11553 if (Base.isInvalid())
11554 return ExprError();
11556 // If nothing changed, just retain the existing expression.
11557 if (!getDerived().AlwaysRebuild() &&
11558 Base.get() == E->getBase())
11561 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(),
11566 template<typename Derived>
11568 TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) {
11569 bool ArgumentChanged = false;
11570 SmallVector<Expr*, 8> SubExprs;
11571 SubExprs.reserve(E->getNumSubExprs());
11572 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false,
11573 SubExprs, &ArgumentChanged))
11574 return ExprError();
11576 if (!getDerived().AlwaysRebuild() &&
11580 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(),
11582 E->getRParenLoc());
11585 template<typename Derived>
11587 TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *E) {
11588 ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr());
11589 if (SrcExpr.isInvalid())
11590 return ExprError();
11592 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
11594 return ExprError();
11596 if (!getDerived().AlwaysRebuild() &&
11597 Type == E->getTypeSourceInfo() &&
11598 SrcExpr.get() == E->getSrcExpr())
11601 return getDerived().RebuildConvertVectorExpr(E->getBuiltinLoc(),
11602 SrcExpr.get(), Type,
11603 E->getRParenLoc());
11606 template<typename Derived>
11608 TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) {
11609 BlockDecl *oldBlock = E->getBlockDecl();
11611 SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/nullptr);
11612 BlockScopeInfo *blockScope = SemaRef.getCurBlock();
11614 blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic());
11615 blockScope->TheDecl->setBlockMissingReturnType(
11616 oldBlock->blockMissingReturnType());
11618 SmallVector<ParmVarDecl*, 4> params;
11619 SmallVector<QualType, 4> paramTypes;
11621 const FunctionProtoType *exprFunctionType = E->getFunctionType();
11623 // Parameter substitution.
11624 Sema::ExtParameterInfoBuilder extParamInfos;
11625 if (getDerived().TransformFunctionTypeParams(
11626 E->getCaretLocation(), oldBlock->parameters(), nullptr,
11627 exprFunctionType->getExtParameterInfosOrNull(), paramTypes, ¶ms,
11629 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
11630 return ExprError();
11633 QualType exprResultType =
11634 getDerived().TransformType(exprFunctionType->getReturnType());
11636 auto epi = exprFunctionType->getExtProtoInfo();
11637 epi.ExtParameterInfos = extParamInfos.getPointerOrNull(paramTypes.size());
11639 QualType functionType =
11640 getDerived().RebuildFunctionProtoType(exprResultType, paramTypes, epi);
11641 blockScope->FunctionType = functionType;
11643 // Set the parameters on the block decl.
11644 if (!params.empty())
11645 blockScope->TheDecl->setParams(params);
11647 if (!oldBlock->blockMissingReturnType()) {
11648 blockScope->HasImplicitReturnType = false;
11649 blockScope->ReturnType = exprResultType;
11652 // Transform the body
11653 StmtResult body = getDerived().TransformStmt(E->getBody());
11654 if (body.isInvalid()) {
11655 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
11656 return ExprError();
11660 // In builds with assertions, make sure that we captured everything we
11661 // captured before.
11662 if (!SemaRef.getDiagnostics().hasErrorOccurred()) {
11663 for (const auto &I : oldBlock->captures()) {
11664 VarDecl *oldCapture = I.getVariable();
11666 // Ignore parameter packs.
11667 if (isa<ParmVarDecl>(oldCapture) &&
11668 cast<ParmVarDecl>(oldCapture)->isParameterPack())
11671 VarDecl *newCapture =
11672 cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(),
11674 assert(blockScope->CaptureMap.count(newCapture));
11676 assert(oldBlock->capturesCXXThis() == blockScope->isCXXThisCaptured());
11680 return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(),
11681 /*Scope=*/nullptr);
11684 template<typename Derived>
11686 TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) {
11687 llvm_unreachable("Cannot transform asType expressions yet");
11690 template<typename Derived>
11692 TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) {
11693 QualType RetTy = getDerived().TransformType(E->getType());
11694 bool ArgumentChanged = false;
11695 SmallVector<Expr*, 8> SubExprs;
11696 SubExprs.reserve(E->getNumSubExprs());
11697 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false,
11698 SubExprs, &ArgumentChanged))
11699 return ExprError();
11701 if (!getDerived().AlwaysRebuild() &&
11705 return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs,
11706 RetTy, E->getOp(), E->getRParenLoc());
11709 //===----------------------------------------------------------------------===//
11710 // Type reconstruction
11711 //===----------------------------------------------------------------------===//
11713 template<typename Derived>
11714 QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType,
11715 SourceLocation Star) {
11716 return SemaRef.BuildPointerType(PointeeType, Star,
11717 getDerived().getBaseEntity());
11720 template<typename Derived>
11721 QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType,
11722 SourceLocation Star) {
11723 return SemaRef.BuildBlockPointerType(PointeeType, Star,
11724 getDerived().getBaseEntity());
11727 template<typename Derived>
11729 TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType,
11730 bool WrittenAsLValue,
11731 SourceLocation Sigil) {
11732 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue,
11733 Sigil, getDerived().getBaseEntity());
11736 template<typename Derived>
11738 TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType,
11739 QualType ClassType,
11740 SourceLocation Sigil) {
11741 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Sigil,
11742 getDerived().getBaseEntity());
11745 template<typename Derived>
11746 QualType TreeTransform<Derived>::RebuildObjCTypeParamType(
11747 const ObjCTypeParamDecl *Decl,
11748 SourceLocation ProtocolLAngleLoc,
11749 ArrayRef<ObjCProtocolDecl *> Protocols,
11750 ArrayRef<SourceLocation> ProtocolLocs,
11751 SourceLocation ProtocolRAngleLoc) {
11752 return SemaRef.BuildObjCTypeParamType(Decl,
11753 ProtocolLAngleLoc, Protocols,
11754 ProtocolLocs, ProtocolRAngleLoc,
11755 /*FailOnError=*/true);
11758 template<typename Derived>
11759 QualType TreeTransform<Derived>::RebuildObjCObjectType(
11761 SourceLocation Loc,
11762 SourceLocation TypeArgsLAngleLoc,
11763 ArrayRef<TypeSourceInfo *> TypeArgs,
11764 SourceLocation TypeArgsRAngleLoc,
11765 SourceLocation ProtocolLAngleLoc,
11766 ArrayRef<ObjCProtocolDecl *> Protocols,
11767 ArrayRef<SourceLocation> ProtocolLocs,
11768 SourceLocation ProtocolRAngleLoc) {
11769 return SemaRef.BuildObjCObjectType(BaseType, Loc, TypeArgsLAngleLoc,
11770 TypeArgs, TypeArgsRAngleLoc,
11771 ProtocolLAngleLoc, Protocols, ProtocolLocs,
11773 /*FailOnError=*/true);
11776 template<typename Derived>
11777 QualType TreeTransform<Derived>::RebuildObjCObjectPointerType(
11778 QualType PointeeType,
11779 SourceLocation Star) {
11780 return SemaRef.Context.getObjCObjectPointerType(PointeeType);
11783 template<typename Derived>
11785 TreeTransform<Derived>::RebuildArrayType(QualType ElementType,
11786 ArrayType::ArraySizeModifier SizeMod,
11787 const llvm::APInt *Size,
11789 unsigned IndexTypeQuals,
11790 SourceRange BracketsRange) {
11791 if (SizeExpr || !Size)
11792 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr,
11793 IndexTypeQuals, BracketsRange,
11794 getDerived().getBaseEntity());
11796 QualType Types[] = {
11797 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy,
11798 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy,
11799 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty
11801 const unsigned NumTypes = llvm::array_lengthof(Types);
11803 for (unsigned I = 0; I != NumTypes; ++I)
11804 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) {
11805 SizeType = Types[I];
11809 // Note that we can return a VariableArrayType here in the case where
11810 // the element type was a dependent VariableArrayType.
11811 IntegerLiteral *ArraySize
11812 = IntegerLiteral::Create(SemaRef.Context, *Size, SizeType,
11813 /*FIXME*/BracketsRange.getBegin());
11814 return SemaRef.BuildArrayType(ElementType, SizeMod, ArraySize,
11815 IndexTypeQuals, BracketsRange,
11816 getDerived().getBaseEntity());
11819 template<typename Derived>
11821 TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType,
11822 ArrayType::ArraySizeModifier SizeMod,
11823 const llvm::APInt &Size,
11824 unsigned IndexTypeQuals,
11825 SourceRange BracketsRange) {
11826 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, nullptr,
11827 IndexTypeQuals, BracketsRange);
11830 template<typename Derived>
11832 TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType,
11833 ArrayType::ArraySizeModifier SizeMod,
11834 unsigned IndexTypeQuals,
11835 SourceRange BracketsRange) {
11836 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, nullptr,
11837 IndexTypeQuals, BracketsRange);
11840 template<typename Derived>
11842 TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType,
11843 ArrayType::ArraySizeModifier SizeMod,
11845 unsigned IndexTypeQuals,
11846 SourceRange BracketsRange) {
11847 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr,
11849 IndexTypeQuals, BracketsRange);
11852 template<typename Derived>
11854 TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType,
11855 ArrayType::ArraySizeModifier SizeMod,
11857 unsigned IndexTypeQuals,
11858 SourceRange BracketsRange) {
11859 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr,
11861 IndexTypeQuals, BracketsRange);
11864 template<typename Derived>
11865 QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType,
11866 unsigned NumElements,
11867 VectorType::VectorKind VecKind) {
11868 // FIXME: semantic checking!
11869 return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind);
11872 template<typename Derived>
11873 QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType,
11874 unsigned NumElements,
11875 SourceLocation AttributeLoc) {
11876 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
11877 NumElements, true);
11878 IntegerLiteral *VectorSize
11879 = IntegerLiteral::Create(SemaRef.Context, numElements, SemaRef.Context.IntTy,
11881 return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc);
11884 template<typename Derived>
11886 TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType,
11888 SourceLocation AttributeLoc) {
11889 return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc);
11892 template<typename Derived>
11893 QualType TreeTransform<Derived>::RebuildFunctionProtoType(
11895 MutableArrayRef<QualType> ParamTypes,
11896 const FunctionProtoType::ExtProtoInfo &EPI) {
11897 return SemaRef.BuildFunctionType(T, ParamTypes,
11898 getDerived().getBaseLocation(),
11899 getDerived().getBaseEntity(),
11903 template<typename Derived>
11904 QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) {
11905 return SemaRef.Context.getFunctionNoProtoType(T);
11908 template<typename Derived>
11909 QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(SourceLocation Loc,
11911 assert(D && "no decl found");
11912 if (D->isInvalidDecl()) return QualType();
11914 // FIXME: Doesn't account for ObjCInterfaceDecl!
11916 if (auto *UPD = dyn_cast<UsingPackDecl>(D)) {
11917 // A valid resolved using typename pack expansion decl can have multiple
11918 // UsingDecls, but they must each have exactly one type, and it must be
11919 // the same type in every case. But we must have at least one expansion!
11920 if (UPD->expansions().empty()) {
11921 getSema().Diag(Loc, diag::err_using_pack_expansion_empty)
11922 << UPD->isCXXClassMember() << UPD;
11926 // We might still have some unresolved types. Try to pick a resolved type
11927 // if we can. The final instantiation will check that the remaining
11928 // unresolved types instantiate to the type we pick.
11929 QualType FallbackT;
11931 for (auto *E : UPD->expansions()) {
11932 QualType ThisT = RebuildUnresolvedUsingType(Loc, E);
11933 if (ThisT.isNull())
11935 else if (ThisT->getAs<UnresolvedUsingType>())
11937 else if (T.isNull())
11940 assert(getSema().Context.hasSameType(ThisT, T) &&
11941 "mismatched resolved types in using pack expansion");
11943 return T.isNull() ? FallbackT : T;
11944 } else if (auto *Using = dyn_cast<UsingDecl>(D)) {
11945 assert(Using->hasTypename() &&
11946 "UnresolvedUsingTypenameDecl transformed to non-typename using");
11948 // A valid resolved using typename decl points to exactly one type decl.
11949 assert(++Using->shadow_begin() == Using->shadow_end());
11950 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl());
11952 assert(isa<UnresolvedUsingTypenameDecl>(D) &&
11953 "UnresolvedUsingTypenameDecl transformed to non-using decl");
11954 Ty = cast<UnresolvedUsingTypenameDecl>(D);
11957 return SemaRef.Context.getTypeDeclType(Ty);
11960 template<typename Derived>
11961 QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E,
11962 SourceLocation Loc) {
11963 return SemaRef.BuildTypeofExprType(E, Loc);
11966 template<typename Derived>
11967 QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) {
11968 return SemaRef.Context.getTypeOfType(Underlying);
11971 template<typename Derived>
11972 QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E,
11973 SourceLocation Loc) {
11974 return SemaRef.BuildDecltypeType(E, Loc);
11977 template<typename Derived>
11978 QualType TreeTransform<Derived>::RebuildUnaryTransformType(QualType BaseType,
11979 UnaryTransformType::UTTKind UKind,
11980 SourceLocation Loc) {
11981 return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc);
11984 template<typename Derived>
11985 QualType TreeTransform<Derived>::RebuildTemplateSpecializationType(
11986 TemplateName Template,
11987 SourceLocation TemplateNameLoc,
11988 TemplateArgumentListInfo &TemplateArgs) {
11989 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
11992 template<typename Derived>
11993 QualType TreeTransform<Derived>::RebuildAtomicType(QualType ValueType,
11994 SourceLocation KWLoc) {
11995 return SemaRef.BuildAtomicType(ValueType, KWLoc);
11998 template<typename Derived>
11999 QualType TreeTransform<Derived>::RebuildPipeType(QualType ValueType,
12000 SourceLocation KWLoc,
12002 return isReadPipe ? SemaRef.BuildReadPipeType(ValueType, KWLoc)
12003 : SemaRef.BuildWritePipeType(ValueType, KWLoc);
12006 template<typename Derived>
12008 TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
12010 TemplateDecl *Template) {
12011 return SemaRef.Context.getQualifiedTemplateName(SS.getScopeRep(), TemplateKW,
12015 template<typename Derived>
12017 TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
12018 const IdentifierInfo &Name,
12019 SourceLocation NameLoc,
12020 QualType ObjectType,
12021 NamedDecl *FirstQualifierInScope) {
12022 UnqualifiedId TemplateName;
12023 TemplateName.setIdentifier(&Name, NameLoc);
12024 Sema::TemplateTy Template;
12025 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller.
12026 getSema().ActOnDependentTemplateName(/*Scope=*/nullptr,
12027 SS, TemplateKWLoc, TemplateName,
12028 ParsedType::make(ObjectType),
12029 /*EnteringContext=*/false,
12031 return Template.get();
12034 template<typename Derived>
12036 TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
12037 OverloadedOperatorKind Operator,
12038 SourceLocation NameLoc,
12039 QualType ObjectType) {
12040 UnqualifiedId Name;
12041 // FIXME: Bogus location information.
12042 SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc };
12043 Name.setOperatorFunctionId(NameLoc, Operator, SymbolLocations);
12044 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller.
12045 Sema::TemplateTy Template;
12046 getSema().ActOnDependentTemplateName(/*Scope=*/nullptr,
12047 SS, TemplateKWLoc, Name,
12048 ParsedType::make(ObjectType),
12049 /*EnteringContext=*/false,
12051 return Template.get();
12054 template<typename Derived>
12056 TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
12057 SourceLocation OpLoc,
12061 Expr *Callee = OrigCallee->IgnoreParenCasts();
12062 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus);
12064 if (First->getObjectKind() == OK_ObjCProperty) {
12065 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
12066 if (BinaryOperator::isAssignmentOp(Opc))
12067 return SemaRef.checkPseudoObjectAssignment(/*Scope=*/nullptr, OpLoc, Opc,
12069 ExprResult Result = SemaRef.CheckPlaceholderExpr(First);
12070 if (Result.isInvalid())
12071 return ExprError();
12072 First = Result.get();
12075 if (Second && Second->getObjectKind() == OK_ObjCProperty) {
12076 ExprResult Result = SemaRef.CheckPlaceholderExpr(Second);
12077 if (Result.isInvalid())
12078 return ExprError();
12079 Second = Result.get();
12082 // Determine whether this should be a builtin operation.
12083 if (Op == OO_Subscript) {
12084 if (!First->getType()->isOverloadableType() &&
12085 !Second->getType()->isOverloadableType())
12086 return getSema().CreateBuiltinArraySubscriptExpr(First,
12087 Callee->getLocStart(),
12089 } else if (Op == OO_Arrow) {
12090 // -> is never a builtin operation.
12091 return SemaRef.BuildOverloadedArrowExpr(nullptr, First, OpLoc);
12092 } else if (Second == nullptr || isPostIncDec) {
12093 if (!First->getType()->isOverloadableType()) {
12094 // The argument is not of overloadable type, so try to create a
12095 // built-in unary operation.
12096 UnaryOperatorKind Opc
12097 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
12099 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First);
12102 if (!First->getType()->isOverloadableType() &&
12103 !Second->getType()->isOverloadableType()) {
12104 // Neither of the arguments is an overloadable type, so try to
12105 // create a built-in binary operation.
12106 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
12108 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second);
12109 if (Result.isInvalid())
12110 return ExprError();
12116 // Compute the transformed set of functions (and function templates) to be
12117 // used during overload resolution.
12118 UnresolvedSet<16> Functions;
12120 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) {
12121 assert(ULE->requiresADL());
12122 Functions.append(ULE->decls_begin(), ULE->decls_end());
12124 // If we've resolved this to a particular non-member function, just call
12125 // that function. If we resolved it to a member function,
12126 // CreateOverloaded* will find that function for us.
12127 NamedDecl *ND = cast<DeclRefExpr>(Callee)->getDecl();
12128 if (!isa<CXXMethodDecl>(ND))
12129 Functions.addDecl(ND);
12132 // Add any functions found via argument-dependent lookup.
12133 Expr *Args[2] = { First, Second };
12134 unsigned NumArgs = 1 + (Second != nullptr);
12136 // Create the overloaded operator invocation for unary operators.
12137 if (NumArgs == 1 || isPostIncDec) {
12138 UnaryOperatorKind Opc
12139 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
12140 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First);
12143 if (Op == OO_Subscript) {
12144 SourceLocation LBrace;
12145 SourceLocation RBrace;
12147 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) {
12148 DeclarationNameLoc NameLoc = DRE->getNameInfo().getInfo();
12149 LBrace = SourceLocation::getFromRawEncoding(
12150 NameLoc.CXXOperatorName.BeginOpNameLoc);
12151 RBrace = SourceLocation::getFromRawEncoding(
12152 NameLoc.CXXOperatorName.EndOpNameLoc);
12154 LBrace = Callee->getLocStart();
12158 return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace,
12162 // Create the overloaded operator invocation for binary operators.
12163 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
12165 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]);
12166 if (Result.isInvalid())
12167 return ExprError();
12172 template<typename Derived>
12174 TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base,
12175 SourceLocation OperatorLoc,
12178 TypeSourceInfo *ScopeType,
12179 SourceLocation CCLoc,
12180 SourceLocation TildeLoc,
12181 PseudoDestructorTypeStorage Destroyed) {
12182 QualType BaseType = Base->getType();
12183 if (Base->isTypeDependent() || Destroyed.getIdentifier() ||
12184 (!isArrow && !BaseType->getAs<RecordType>()) ||
12185 (isArrow && BaseType->getAs<PointerType>() &&
12186 !BaseType->getAs<PointerType>()->getPointeeType()
12187 ->template getAs<RecordType>())){
12188 // This pseudo-destructor expression is still a pseudo-destructor.
12189 return SemaRef.BuildPseudoDestructorExpr(
12190 Base, OperatorLoc, isArrow ? tok::arrow : tok::period, SS, ScopeType,
12191 CCLoc, TildeLoc, Destroyed);
12194 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo();
12195 DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName(
12196 SemaRef.Context.getCanonicalType(DestroyedType->getType())));
12197 DeclarationNameInfo NameInfo(Name, Destroyed.getLocation());
12198 NameInfo.setNamedTypeInfo(DestroyedType);
12200 // The scope type is now known to be a valid nested name specifier
12201 // component. Tack it on to the end of the nested name specifier.
12203 if (!ScopeType->getType()->getAs<TagType>()) {
12204 getSema().Diag(ScopeType->getTypeLoc().getBeginLoc(),
12205 diag::err_expected_class_or_namespace)
12206 << ScopeType->getType() << getSema().getLangOpts().CPlusPlus;
12207 return ExprError();
12209 SS.Extend(SemaRef.Context, SourceLocation(), ScopeType->getTypeLoc(),
12213 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller.
12214 return getSema().BuildMemberReferenceExpr(Base, BaseType,
12215 OperatorLoc, isArrow,
12217 /*FIXME: FirstQualifier*/ nullptr,
12219 /*TemplateArgs*/ nullptr,
12223 template<typename Derived>
12225 TreeTransform<Derived>::TransformCapturedStmt(CapturedStmt *S) {
12226 SourceLocation Loc = S->getLocStart();
12227 CapturedDecl *CD = S->getCapturedDecl();
12228 unsigned NumParams = CD->getNumParams();
12229 unsigned ContextParamPos = CD->getContextParamPosition();
12230 SmallVector<Sema::CapturedParamNameType, 4> Params;
12231 for (unsigned I = 0; I < NumParams; ++I) {
12232 if (I != ContextParamPos) {
12235 CD->getParam(I)->getName(),
12236 getDerived().TransformType(CD->getParam(I)->getType())));
12238 Params.push_back(std::make_pair(StringRef(), QualType()));
12241 getSema().ActOnCapturedRegionStart(Loc, /*CurScope*/nullptr,
12242 S->getCapturedRegionKind(), Params);
12245 Sema::CompoundScopeRAII CompoundScope(getSema());
12246 Body = getDerived().TransformStmt(S->getCapturedStmt());
12249 if (Body.isInvalid()) {
12250 getSema().ActOnCapturedRegionError();
12251 return StmtError();
12254 return getSema().ActOnCapturedRegionEnd(Body.get());
12257 } // end namespace clang
12259 #endif // LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H