| //===------- TreeTransform.h - Semantic Tree Transformation -----*- C++ -*-===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // This file implements a semantic tree transformation that takes a given | |
| // AST and rebuilds it, possibly transforming some nodes in the process. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H | |
| #define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H | |
| #include "CoroutineStmtBuilder.h" | |
| #include "TypeLocBuilder.h" | |
| #include "clang/AST/Decl.h" | |
| #include "clang/AST/DeclObjC.h" | |
| #include "clang/AST/DeclTemplate.h" | |
| #include "clang/AST/Expr.h" | |
| #include "clang/AST/ExprCXX.h" | |
| #include "clang/AST/ExprConcepts.h" | |
| #include "clang/AST/ExprObjC.h" | |
| #include "clang/AST/ExprOpenMP.h" | |
| #include "clang/AST/OpenMPClause.h" | |
| #include "clang/AST/Stmt.h" | |
| #include "clang/AST/StmtCXX.h" | |
| #include "clang/AST/StmtObjC.h" | |
| #include "clang/AST/StmtOpenACC.h" | |
| #include "clang/AST/StmtOpenMP.h" | |
| #include "clang/AST/StmtSYCL.h" | |
| #include "clang/Basic/DiagnosticParse.h" | |
| #include "clang/Basic/OpenMPKinds.h" | |
| #include "clang/Sema/Designator.h" | |
| #include "clang/Sema/EnterExpressionEvaluationContext.h" | |
| #include "clang/Sema/Lookup.h" | |
| #include "clang/Sema/Ownership.h" | |
| #include "clang/Sema/ParsedTemplate.h" | |
| #include "clang/Sema/ScopeInfo.h" | |
| #include "clang/Sema/SemaDiagnostic.h" | |
| #include "clang/Sema/SemaHLSL.h" | |
| #include "clang/Sema/SemaInternal.h" | |
| #include "clang/Sema/SemaObjC.h" | |
| #include "clang/Sema/SemaOpenACC.h" | |
| #include "clang/Sema/SemaOpenMP.h" | |
| #include "clang/Sema/SemaPseudoObject.h" | |
| #include "clang/Sema/SemaSYCL.h" | |
| #include "clang/Sema/Template.h" | |
| #include "llvm/ADT/ArrayRef.h" | |
| #include "llvm/Support/ErrorHandling.h" | |
| #include <algorithm> | |
| #include <optional> | |
| using namespace llvm::omp; | |
| namespace clang { | |
| using namespace sema; | |
| // This helper class is used to facilitate pack expansion during tree transform. | |
| struct UnexpandedInfo { | |
| SourceLocation Ellipsis; | |
| UnsignedOrNone OrigNumExpansions = std::nullopt; | |
| bool Expand = false; | |
| bool RetainExpansion = false; | |
| UnsignedOrNone NumExpansions = std::nullopt; | |
| bool ExpandUnderForgetSubstitions = false; | |
| }; | |
| /// A semantic tree transformation that allows one to transform one | |
| /// abstract syntax tree into another. | |
| /// | |
| /// A new tree transformation is defined by creating a new subclass \c X of | |
| /// \c TreeTransform<X> and then overriding certain operations to provide | |
| /// behavior specific to that transformation. For example, template | |
| /// instantiation is implemented as a tree transformation where the | |
| /// transformation of TemplateTypeParmType nodes involves substituting the | |
| /// template arguments for their corresponding template parameters; a similar | |
| /// transformation is performed for non-type template parameters and | |
| /// template template parameters. | |
| /// | |
| /// This tree-transformation template uses static polymorphism to allow | |
| /// subclasses to customize any of its operations. Thus, a subclass can | |
| /// override any of the transformation or rebuild operators by providing an | |
| /// operation with the same signature as the default implementation. The | |
| /// overriding function should not be virtual. | |
| /// | |
| /// Semantic tree transformations are split into two stages, either of which | |
| /// can be replaced by a subclass. The "transform" step transforms an AST node | |
| /// or the parts of an AST node using the various transformation functions, | |
| /// then passes the pieces on to the "rebuild" step, which constructs a new AST | |
| /// node of the appropriate kind from the pieces. The default transformation | |
| /// routines recursively transform the operands to composite AST nodes (e.g., | |
| /// the pointee type of a PointerType node) and, if any of those operand nodes | |
| /// were changed by the transformation, invokes the rebuild operation to create | |
| /// a new AST node. | |
| /// | |
| /// Subclasses can customize the transformation at various levels. The | |
| /// most coarse-grained transformations involve replacing TransformType(), | |
| /// TransformExpr(), TransformDecl(), TransformNestedNameSpecifierLoc(), | |
| /// TransformTemplateName(), or TransformTemplateArgument() with entirely | |
| /// new implementations. | |
| /// | |
| /// For more fine-grained transformations, subclasses can replace any of the | |
| /// \c TransformXXX functions (where XXX is the name of an AST node, e.g., | |
| /// PointerType, StmtExpr) to alter the transformation. As mentioned previously, | |
| /// replacing TransformTemplateTypeParmType() allows template instantiation | |
| /// to substitute template arguments for their corresponding template | |
| /// parameters. Additionally, subclasses can override the \c RebuildXXX | |
| /// functions to control how AST nodes are rebuilt when their operands change. | |
| /// By default, \c TreeTransform will invoke semantic analysis to rebuild | |
| /// AST nodes. However, certain other tree transformations (e.g, cloning) may | |
| /// be able to use more efficient rebuild steps. | |
| /// | |
| /// There are a handful of other functions that can be overridden, allowing one | |
| /// to avoid traversing nodes that don't need any transformation | |
| /// (\c AlreadyTransformed()), force rebuilding AST nodes even when their | |
| /// operands have not changed (\c AlwaysRebuild()), and customize the | |
| /// default locations and entity names used for type-checking | |
| /// (\c getBaseLocation(), \c getBaseEntity()). | |
| template<typename Derived> | |
| class TreeTransform { | |
| /// Private RAII object that helps us forget and then re-remember | |
| /// the template argument corresponding to a partially-substituted parameter | |
| /// pack. | |
| class ForgetPartiallySubstitutedPackRAII { | |
| Derived &Self; | |
| TemplateArgument Old; | |
| // Set the pack expansion index to -1 to avoid pack substitution and | |
| // indicate that parameter packs should be instantiated as themselves. | |
| Sema::ArgPackSubstIndexRAII ResetPackSubstIndex; | |
| public: | |
| ForgetPartiallySubstitutedPackRAII(Derived &Self) | |
| : Self(Self), ResetPackSubstIndex(Self.getSema(), std::nullopt) { | |
| Old = Self.ForgetPartiallySubstitutedPack(); | |
| } | |
| ~ForgetPartiallySubstitutedPackRAII() { | |
| Self.RememberPartiallySubstitutedPack(Old); | |
| } | |
| ForgetPartiallySubstitutedPackRAII( | |
| const ForgetPartiallySubstitutedPackRAII &) = delete; | |
| ForgetPartiallySubstitutedPackRAII & | |
| operator=(const ForgetPartiallySubstitutedPackRAII &) = delete; | |
| }; | |
| protected: | |
| Sema &SemaRef; | |
| /// The set of local declarations that have been transformed, for | |
| /// cases where we are forced to build new declarations within the transformer | |
| /// rather than in the subclass (e.g., lambda closure types). | |
| llvm::DenseMap<Decl *, Decl *> TransformedLocalDecls; | |
| public: | |
| /// Initializes a new tree transformer. | |
| TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { } | |
| /// Retrieves a reference to the derived class. | |
| Derived &getDerived() { return static_cast<Derived&>(*this); } | |
| /// Retrieves a reference to the derived class. | |
| const Derived &getDerived() const { | |
| return static_cast<const Derived&>(*this); | |
| } | |
| static inline ExprResult Owned(Expr *E) { return E; } | |
| static inline StmtResult Owned(Stmt *S) { return S; } | |
| /// Retrieves a reference to the semantic analysis object used for | |
| /// this tree transform. | |
| Sema &getSema() const { return SemaRef; } | |
| /// Whether the transformation should always rebuild AST nodes, even | |
| /// if none of the children have changed. | |
| /// | |
| /// Subclasses may override this function to specify when the transformation | |
| /// should rebuild all AST nodes. | |
| /// | |
| /// We must always rebuild all AST nodes when performing variadic template | |
| /// pack expansion, in order to avoid violating the AST invariant that each | |
| /// statement node appears at most once in its containing declaration. | |
| bool AlwaysRebuild() { return static_cast<bool>(SemaRef.ArgPackSubstIndex); } | |
| /// Whether the transformation is forming an expression or statement that | |
| /// replaces the original. In this case, we'll reuse mangling numbers from | |
| /// existing lambdas. | |
| bool ReplacingOriginal() { return false; } | |
| /// Wether CXXConstructExpr can be skipped when they are implicit. | |
| /// They will be reconstructed when used if needed. | |
| /// This is useful when the user that cause rebuilding of the | |
| /// CXXConstructExpr is outside of the expression at which the TreeTransform | |
| /// started. | |
| bool AllowSkippingCXXConstructExpr() { return true; } | |
| /// Returns the location of the entity being transformed, if that | |
| /// information was not available elsewhere in the AST. | |
| /// | |
| /// By default, returns no source-location information. Subclasses can | |
| /// provide an alternative implementation that provides better location | |
| /// information. | |
| SourceLocation getBaseLocation() { return SourceLocation(); } | |
| /// Returns the name of the entity being transformed, if that | |
| /// information was not available elsewhere in the AST. | |
| /// | |
| /// By default, returns an empty name. Subclasses can provide an alternative | |
| /// implementation with a more precise name. | |
| DeclarationName getBaseEntity() { return DeclarationName(); } | |
| /// Sets the "base" location and entity when that | |
| /// information is known based on another transformation. | |
| /// | |
| /// By default, the source location and entity are ignored. Subclasses can | |
| /// override this function to provide a customized implementation. | |
| void setBase(SourceLocation Loc, DeclarationName Entity) { } | |
| /// RAII object that temporarily sets the base location and entity | |
| /// used for reporting diagnostics in types. | |
| class TemporaryBase { | |
| TreeTransform &Self; | |
| SourceLocation OldLocation; | |
| DeclarationName OldEntity; | |
| public: | |
| TemporaryBase(TreeTransform &Self, SourceLocation Location, | |
| DeclarationName Entity) : Self(Self) { | |
| OldLocation = Self.getDerived().getBaseLocation(); | |
| OldEntity = Self.getDerived().getBaseEntity(); | |
| if (Location.isValid()) | |
| Self.getDerived().setBase(Location, Entity); | |
| } | |
| ~TemporaryBase() { | |
| Self.getDerived().setBase(OldLocation, OldEntity); | |
| } | |
| TemporaryBase(const TemporaryBase &) = delete; | |
| TemporaryBase &operator=(const TemporaryBase &) = delete; | |
| }; | |
| /// Determine whether the given type \p T has already been | |
| /// transformed. | |
| /// | |
| /// Subclasses can provide an alternative implementation of this routine | |
| /// to short-circuit evaluation when it is known that a given type will | |
| /// not change. For example, template instantiation need not traverse | |
| /// non-dependent types. | |
| bool AlreadyTransformed(QualType T) { | |
| return T.isNull(); | |
| } | |
| /// Transform a template parameter depth level. | |
| /// | |
| /// During a transformation that transforms template parameters, this maps | |
| /// an old template parameter depth to a new depth. | |
| unsigned TransformTemplateDepth(unsigned Depth) { | |
| return Depth; | |
| } | |
| /// Determine whether the given call argument should be dropped, e.g., | |
| /// because it is a default argument. | |
| /// | |
| /// Subclasses can provide an alternative implementation of this routine to | |
| /// determine which kinds of call arguments get dropped. By default, | |
| /// CXXDefaultArgument nodes are dropped (prior to transformation). | |
| bool DropCallArgument(Expr *E) { | |
| return E->isDefaultArgument(); | |
| } | |
| /// Determine whether we should expand a pack expansion with the | |
| /// given set of parameter packs into separate arguments by repeatedly | |
| /// transforming the pattern. | |
| /// | |
| /// By default, the transformer never tries to expand pack expansions. | |
| /// Subclasses can override this routine to provide different behavior. | |
| /// | |
| /// \param EllipsisLoc The location of the ellipsis that identifies the | |
| /// pack expansion. | |
| /// | |
| /// \param PatternRange The source range that covers the entire pattern of | |
| /// the pack expansion. | |
| /// | |
| /// \param Unexpanded The set of unexpanded parameter packs within the | |
| /// pattern. | |
| /// | |
| /// \param ShouldExpand Will be set to \c true if the transformer should | |
| /// expand the corresponding pack expansions into separate arguments. When | |
| /// set, \c NumExpansions must also be set. | |
| /// | |
| /// \param RetainExpansion Whether the caller should add an unexpanded | |
| /// pack expansion after all of the expanded arguments. This is used | |
| /// when extending explicitly-specified template argument packs per | |
| /// C++0x [temp.arg.explicit]p9. | |
| /// | |
| /// \param NumExpansions The number of separate arguments that will be in | |
| /// the expanded form of the corresponding pack expansion. This is both an | |
| /// input and an output parameter, which can be set by the caller if the | |
| /// number of expansions is known a priori (e.g., due to a prior substitution) | |
| /// and will be set by the callee when the number of expansions is known. | |
| /// The callee must set this value when \c ShouldExpand is \c true; it may | |
| /// set this value in other cases. | |
| /// | |
| /// \returns true if an error occurred (e.g., because the parameter packs | |
| /// are to be instantiated with arguments of different lengths), false | |
| /// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions) | |
| /// must be set. | |
| bool TryExpandParameterPacks(SourceLocation EllipsisLoc, | |
| SourceRange PatternRange, | |
| ArrayRef<UnexpandedParameterPack> Unexpanded, | |
| bool FailOnPackProducingTemplates, | |
| bool &ShouldExpand, bool &RetainExpansion, | |
| UnsignedOrNone &NumExpansions) { | |
| ShouldExpand = false; | |
| return false; | |
| } | |
| /// "Forget" about the partially-substituted pack template argument, | |
| /// when performing an instantiation that must preserve the parameter pack | |
| /// use. | |
| /// | |
| /// This routine is meant to be overridden by the template instantiator. | |
| TemplateArgument ForgetPartiallySubstitutedPack() { | |
| return TemplateArgument(); | |
| } | |
| /// "Remember" the partially-substituted pack template argument | |
| /// after performing an instantiation that must preserve the parameter pack | |
| /// use. | |
| /// | |
| /// This routine is meant to be overridden by the template instantiator. | |
| void RememberPartiallySubstitutedPack(TemplateArgument Arg) { } | |
| /// "Forget" the template substitution to allow transforming the AST without | |
| /// any template instantiations. This is used to expand template packs when | |
| /// their size is not known in advance (e.g. for builtins that produce type | |
| /// packs). | |
| MultiLevelTemplateArgumentList ForgetSubstitution() { return {}; } | |
| void RememberSubstitution(MultiLevelTemplateArgumentList) {} | |
| private: | |
| struct ForgetSubstitutionRAII { | |
| Derived &Self; | |
| MultiLevelTemplateArgumentList Old; | |
| public: | |
| ForgetSubstitutionRAII(Derived &Self) : Self(Self) { | |
| Old = Self.ForgetSubstitution(); | |
| } | |
| ~ForgetSubstitutionRAII() { Self.RememberSubstitution(std::move(Old)); } | |
| }; | |
| public: | |
| /// Note to the derived class when a function parameter pack is | |
| /// being expanded. | |
| void ExpandingFunctionParameterPack(ParmVarDecl *Pack) { } | |
| /// Transforms the given type into another type. | |
| /// | |
| /// By default, this routine transforms a type by creating a | |
| /// TypeSourceInfo for it and delegating to the appropriate | |
| /// function. This is expensive, but we don't mind, because | |
| /// this method is deprecated anyway; all users should be | |
| /// switched to storing TypeSourceInfos. | |
| /// | |
| /// \returns the transformed type. | |
| QualType TransformType(QualType T); | |
| /// Transforms the given type-with-location into a new | |
| /// type-with-location. | |
| /// | |
| /// By default, this routine transforms a type by delegating to the | |
| /// appropriate TransformXXXType to build a new type. Subclasses | |
| /// may override this function (to take over all type | |
| /// transformations) or some set of the TransformXXXType functions | |
| /// to alter the transformation. | |
| TypeSourceInfo *TransformType(TypeSourceInfo *TSI); | |
| /// Transform the given type-with-location into a new | |
| /// type, collecting location information in the given builder | |
| /// as necessary. | |
| /// | |
| QualType TransformType(TypeLocBuilder &TLB, TypeLoc TL); | |
| /// Transform a type that is permitted to produce a | |
| /// DeducedTemplateSpecializationType. | |
| /// | |
| /// This is used in the (relatively rare) contexts where it is acceptable | |
| /// for transformation to produce a class template type with deduced | |
| /// template arguments. | |
| /// @{ | |
| QualType TransformTypeWithDeducedTST(QualType T); | |
| TypeSourceInfo *TransformTypeWithDeducedTST(TypeSourceInfo *TSI); | |
| /// @} | |
| /// The reason why the value of a statement is not discarded, if any. | |
| enum class StmtDiscardKind { | |
| Discarded, | |
| NotDiscarded, | |
| StmtExprResult, | |
| }; | |
| /// Transform the given statement. | |
| /// | |
| /// By default, this routine transforms a statement by delegating to the | |
| /// appropriate TransformXXXStmt function to transform a specific kind of | |
| /// statement or the TransformExpr() function to transform an expression. | |
| /// Subclasses may override this function to transform statements using some | |
| /// other mechanism. | |
| /// | |
| /// \returns the transformed statement. | |
| StmtResult TransformStmt(Stmt *S, | |
| StmtDiscardKind SDK = StmtDiscardKind::Discarded); | |
| /// Transform the given statement. | |
| /// | |
| /// By default, this routine transforms a statement by delegating to the | |
| /// appropriate TransformOMPXXXClause function to transform a specific kind | |
| /// of clause. Subclasses may override this function to transform statements | |
| /// using some other mechanism. | |
| /// | |
| /// \returns the transformed OpenMP clause. | |
| OMPClause *TransformOMPClause(OMPClause *S); | |
| /// Transform the given attribute. | |
| /// | |
| /// By default, this routine transforms a statement by delegating to the | |
| /// appropriate TransformXXXAttr function to transform a specific kind | |
| /// of attribute. Subclasses may override this function to transform | |
| /// attributed statements/types using some other mechanism. | |
| /// | |
| /// \returns the transformed attribute | |
| const Attr *TransformAttr(const Attr *S); | |
| // Transform the given statement attribute. | |
| // | |
| // Delegates to the appropriate TransformXXXAttr function to transform a | |
| // specific kind of statement attribute. Unlike the non-statement taking | |
| // version of this, this implements all attributes, not just pragmas. | |
| const Attr *TransformStmtAttr(const Stmt *OrigS, const Stmt *InstS, | |
| const Attr *A); | |
| // Transform the specified attribute. | |
| // | |
| // Subclasses should override the transformation of attributes with a pragma | |
| // spelling to transform expressions stored within the attribute. | |
| // | |
| // \returns the transformed attribute. | |
| #define ATTR(X) \ | |
| const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; } | |
| #include "clang/Basic/AttrList.inc" | |
| // Transform the specified attribute. | |
| // | |
| // Subclasses should override the transformation of attributes to do | |
| // transformation and checking of statement attributes. By default, this | |
| // delegates to the non-statement taking version. | |
| // | |
| // \returns the transformed attribute. | |
| #define ATTR(X) \ | |
| const X##Attr *TransformStmt##X##Attr(const Stmt *, const Stmt *, \ | |
| const X##Attr *A) { \ | |
| return getDerived().Transform##X##Attr(A); \ | |
| } | |
| #include "clang/Basic/AttrList.inc" | |
| /// Transform the given expression. | |
| /// | |
| /// By default, this routine transforms an expression by delegating to the | |
| /// appropriate TransformXXXExpr function to build a new expression. | |
| /// Subclasses may override this function to transform expressions using some | |
| /// other mechanism. | |
| /// | |
| /// \returns the transformed expression. | |
| ExprResult TransformExpr(Expr *E); | |
| /// Transform the given initializer. | |
| /// | |
| /// By default, this routine transforms an initializer by stripping off the | |
| /// semantic nodes added by initialization, then passing the result to | |
| /// TransformExpr or TransformExprs. | |
| /// | |
| /// \returns the transformed initializer. | |
| ExprResult TransformInitializer(Expr *Init, bool NotCopyInit); | |
| /// Transform the given list of expressions. | |
| /// | |
| /// This routine transforms a list of expressions by invoking | |
| /// \c TransformExpr() for each subexpression. However, it also provides | |
| /// support for variadic templates by expanding any pack expansions (if the | |
| /// derived class permits such expansion) along the way. When pack expansions | |
| /// are present, the number of outputs may not equal the number of inputs. | |
| /// | |
| /// \param Inputs The set of expressions to be transformed. | |
| /// | |
| /// \param NumInputs The number of expressions in \c Inputs. | |
| /// | |
| /// \param IsCall If \c true, then this transform is being performed on | |
| /// function-call arguments, and any arguments that should be dropped, will | |
| /// be. | |
| /// | |
| /// \param Outputs The transformed input expressions will be added to this | |
| /// vector. | |
| /// | |
| /// \param ArgChanged If non-NULL, will be set \c true if any argument changed | |
| /// due to transformation. | |
| /// | |
| /// \returns true if an error occurred, false otherwise. | |
| bool TransformExprs(Expr *const *Inputs, unsigned NumInputs, bool IsCall, | |
| SmallVectorImpl<Expr *> &Outputs, | |
| bool *ArgChanged = nullptr); | |
| /// Transform the given declaration, which is referenced from a type | |
| /// or expression. | |
| /// | |
| /// By default, acts as the identity function on declarations, unless the | |
| /// transformer has had to transform the declaration itself. Subclasses | |
| /// may override this function to provide alternate behavior. | |
| Decl *TransformDecl(SourceLocation Loc, Decl *D) { | |
| llvm::DenseMap<Decl *, Decl *>::iterator Known | |
| = TransformedLocalDecls.find(D); | |
| if (Known != TransformedLocalDecls.end()) | |
| return Known->second; | |
| return D; | |
| } | |
| /// Transform the specified condition. | |
| /// | |
| /// By default, this transforms the variable and expression and rebuilds | |
| /// the condition. | |
| Sema::ConditionResult TransformCondition(SourceLocation Loc, VarDecl *Var, | |
| Expr *Expr, | |
| Sema::ConditionKind Kind); | |
| /// Transform the attributes associated with the given declaration and | |
| /// place them on the new declaration. | |
| /// | |
| /// By default, this operation does nothing. Subclasses may override this | |
| /// behavior to transform attributes. | |
| void transformAttrs(Decl *Old, Decl *New) { } | |
| /// Note that a local declaration has been transformed by this | |
| /// transformer. | |
| /// | |
| /// Local declarations are typically transformed via a call to | |
| /// TransformDefinition. However, in some cases (e.g., lambda expressions), | |
| /// the transformer itself has to transform the declarations. This routine | |
| /// can be overridden by a subclass that keeps track of such mappings. | |
| void transformedLocalDecl(Decl *Old, ArrayRef<Decl *> New) { | |
| assert(New.size() == 1 && | |
| "must override transformedLocalDecl if performing pack expansion"); | |
| TransformedLocalDecls[Old] = New.front(); | |
| } | |
| /// Transform the definition of the given declaration. | |
| /// | |
| /// By default, invokes TransformDecl() to transform the declaration. | |
| /// Subclasses may override this function to provide alternate behavior. | |
| Decl *TransformDefinition(SourceLocation Loc, Decl *D) { | |
| return getDerived().TransformDecl(Loc, D); | |
| } | |
| /// Transform the given declaration, which was the first part of a | |
| /// nested-name-specifier in a member access expression. | |
| /// | |
| /// This specific declaration transformation only applies to the first | |
| /// identifier in a nested-name-specifier of a member access expression, e.g., | |
| /// the \c T in \c x->T::member | |
| /// | |
| /// By default, invokes TransformDecl() to transform the declaration. | |
| /// Subclasses may override this function to provide alternate behavior. | |
| NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc) { | |
| return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D)); | |
| } | |
| /// Transform the set of declarations in an OverloadExpr. | |
| bool TransformOverloadExprDecls(OverloadExpr *Old, bool RequiresADL, | |
| LookupResult &R); | |
| /// Transform the given nested-name-specifier with source-location | |
| /// information. | |
| /// | |
| /// By default, transforms all of the types and declarations within the | |
| /// nested-name-specifier. Subclasses may override this function to provide | |
| /// alternate behavior. | |
| NestedNameSpecifierLoc | |
| TransformNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, | |
| QualType ObjectType = QualType(), | |
| NamedDecl *FirstQualifierInScope = nullptr); | |
| /// Transform the given declaration name. | |
| /// | |
| /// By default, transforms the types of conversion function, constructor, | |
| /// and destructor names and then (if needed) rebuilds the declaration name. | |
| /// Identifiers and selectors are returned unmodified. Subclasses may | |
| /// override this function to provide alternate behavior. | |
| DeclarationNameInfo | |
| TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo); | |
| bool TransformRequiresExprRequirements( | |
| ArrayRef<concepts::Requirement *> Reqs, | |
| llvm::SmallVectorImpl<concepts::Requirement *> &Transformed); | |
| concepts::TypeRequirement * | |
| TransformTypeRequirement(concepts::TypeRequirement *Req); | |
| concepts::ExprRequirement * | |
| TransformExprRequirement(concepts::ExprRequirement *Req); | |
| concepts::NestedRequirement * | |
| TransformNestedRequirement(concepts::NestedRequirement *Req); | |
| /// Transform the given template name. | |
| /// | |
| /// \param SS The nested-name-specifier that qualifies the template | |
| /// name. This nested-name-specifier must already have been transformed. | |
| /// | |
| /// \param Name The template name to transform. | |
| /// | |
| /// \param NameLoc The source location of the template name. | |
| /// | |
| /// \param ObjectType If we're translating a template name within a member | |
| /// access expression, this is the type of the object whose member template | |
| /// is being referenced. | |
| /// | |
| /// \param FirstQualifierInScope If the first part of a nested-name-specifier | |
| /// also refers to a name within the current (lexical) scope, this is the | |
| /// declaration it refers to. | |
| /// | |
| /// By default, transforms the template name by transforming the declarations | |
| /// and nested-name-specifiers that occur within the template name. | |
| /// Subclasses may override this function to provide alternate behavior. | |
| TemplateName TransformTemplateName(NestedNameSpecifierLoc &QualifierLoc, | |
| SourceLocation TemplateKWLoc, | |
| TemplateName Name, SourceLocation NameLoc, | |
| QualType ObjectType = QualType(), | |
| NamedDecl *FirstQualifierInScope = nullptr, | |
| bool AllowInjectedClassName = false); | |
| TemplateName TransformConceptTemplateName(TemplateName Name, | |
| SourceLocation NameLoc); | |
| /// Transform the given template argument. | |
| /// | |
| /// By default, this operation transforms the type, expression, or | |
| /// declaration stored within the template argument and constructs a | |
| /// new template argument from the transformed result. Subclasses may | |
| /// override this function to provide alternate behavior. | |
| /// | |
| /// Returns true if there was an error. | |
| bool TransformTemplateArgument(const TemplateArgumentLoc &Input, | |
| TemplateArgumentLoc &Output, | |
| bool Uneval = false); | |
| TemplateArgument TransformNamedTemplateTemplateArgument( | |
| NestedNameSpecifierLoc &QualifierLoc, SourceLocation TemplateKeywordLoc, | |
| TemplateName Name, SourceLocation NameLoc); | |
| /// Transform the given set of template arguments. | |
| /// | |
| /// By default, this operation transforms all of the template arguments | |
| /// in the input set using \c TransformTemplateArgument(), and appends | |
| /// the transformed arguments to the output list. | |
| /// | |
| /// Note that this overload of \c TransformTemplateArguments() is merely | |
| /// a convenience function. Subclasses that wish to override this behavior | |
| /// should override the iterator-based member template version. | |
| /// | |
| /// \param Inputs The set of template arguments to be transformed. | |
| /// | |
| /// \param NumInputs The number of template arguments in \p Inputs. | |
| /// | |
| /// \param Outputs The set of transformed template arguments output by this | |
| /// routine. | |
| /// | |
| /// Returns true if an error occurred. | |
| bool TransformTemplateArguments(const TemplateArgumentLoc *Inputs, | |
| unsigned NumInputs, | |
| TemplateArgumentListInfo &Outputs, | |
| bool Uneval = false) { | |
| return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs, | |
| Uneval); | |
| } | |
| /// Transform the given set of template arguments. | |
| /// | |
| /// By default, this operation transforms all of the template arguments | |
| /// in the input set using \c TransformTemplateArgument(), and appends | |
| /// the transformed arguments to the output list. | |
| /// | |
| /// \param First An iterator to the first template argument. | |
| /// | |
| /// \param Last An iterator one step past the last template argument. | |
| /// | |
| /// \param Outputs The set of transformed template arguments output by this | |
| /// routine. | |
| /// | |
| /// Returns true if an error occurred. | |
| template<typename InputIterator> | |
| bool TransformTemplateArguments(InputIterator First, | |
| InputIterator Last, | |
| TemplateArgumentListInfo &Outputs, | |
| bool Uneval = false); | |
| template <typename InputIterator> | |
| bool TransformConceptTemplateArguments(InputIterator First, | |
| InputIterator Last, | |
| TemplateArgumentListInfo &Outputs, | |
| bool Uneval = false); | |
| /// Checks if the argument pack from \p In will need to be expanded and does | |
| /// the necessary prework. | |
| /// Whether the expansion is needed is captured in Info.Expand. | |
| /// | |
| /// - When the expansion is required, \p Out will be a template pattern that | |
| /// would need to be expanded. | |
| /// - When the expansion must not happen, \p Out will be a pack that must be | |
| /// returned to the outputs directly. | |
| /// | |
| /// \return true iff the error occurred | |
| bool PreparePackForExpansion(TemplateArgumentLoc In, bool Uneval, | |
| TemplateArgumentLoc &Out, UnexpandedInfo &Info); | |
| /// Fakes up a TemplateArgumentLoc for a given TemplateArgument. | |
| void InventTemplateArgumentLoc(const TemplateArgument &Arg, | |
| TemplateArgumentLoc &ArgLoc); | |
| /// Fakes up a TypeSourceInfo for a type. | |
| TypeSourceInfo *InventTypeSourceInfo(QualType T) { | |
| return SemaRef.Context.getTrivialTypeSourceInfo(T, | |
| getDerived().getBaseLocation()); | |
| } | |
| #define ABSTRACT_TYPELOC(CLASS, PARENT) | |
| #define TYPELOC(CLASS, PARENT) \ | |
| QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T); | |
| #include "clang/AST/TypeLocNodes.def" | |
| QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB, | |
| TemplateTypeParmTypeLoc TL, | |
| bool SuppressObjCLifetime); | |
| QualType | |
| TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB, | |
| SubstTemplateTypeParmPackTypeLoc TL, | |
| bool SuppressObjCLifetime); | |
| template<typename Fn> | |
| QualType TransformFunctionProtoType(TypeLocBuilder &TLB, | |
| FunctionProtoTypeLoc TL, | |
| CXXRecordDecl *ThisContext, | |
| Qualifiers ThisTypeQuals, | |
| Fn TransformExceptionSpec); | |
| bool TransformExceptionSpec(SourceLocation Loc, | |
| FunctionProtoType::ExceptionSpecInfo &ESI, | |
| SmallVectorImpl<QualType> &Exceptions, | |
| bool &Changed); | |
| StmtResult TransformSEHHandler(Stmt *Handler); | |
| QualType TransformTemplateSpecializationType(TypeLocBuilder &TLB, | |
| TemplateSpecializationTypeLoc TL, | |
| QualType ObjectType, | |
| NamedDecl *FirstQualifierInScope, | |
| bool AllowInjectedClassName); | |
| QualType TransformTagType(TypeLocBuilder &TLB, TagTypeLoc TL); | |
| /// Transforms the parameters of a function type into the | |
| /// given vectors. | |
| /// | |
| /// The result vectors should be kept in sync; null entries in the | |
| /// variables vector are acceptable. | |
| /// | |
| /// LastParamTransformed, if non-null, will be set to the index of the last | |
| /// parameter on which transformation was started. In the event of an error, | |
| /// this will contain the parameter which failed to instantiate. | |
| /// | |
| /// Return true on error. | |
| bool TransformFunctionTypeParams( | |
| SourceLocation Loc, ArrayRef<ParmVarDecl *> Params, | |
| const QualType *ParamTypes, | |
| const FunctionProtoType::ExtParameterInfo *ParamInfos, | |
| SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars, | |
| Sema::ExtParameterInfoBuilder &PInfos, unsigned *LastParamTransformed); | |
| bool TransformFunctionTypeParams( | |
| SourceLocation Loc, ArrayRef<ParmVarDecl *> Params, | |
| const QualType *ParamTypes, | |
| const FunctionProtoType::ExtParameterInfo *ParamInfos, | |
| SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars, | |
| Sema::ExtParameterInfoBuilder &PInfos) { | |
| return getDerived().TransformFunctionTypeParams( | |
| Loc, Params, ParamTypes, ParamInfos, PTypes, PVars, PInfos, nullptr); | |
| } | |
| /// Transforms the parameters of a requires expresison into the given vectors. | |
| /// | |
| /// The result vectors should be kept in sync; null entries in the | |
| /// variables vector are acceptable. | |
| /// | |
| /// Returns an unset ExprResult on success. Returns an ExprResult the 'not | |
| /// satisfied' RequiresExpr if subsitution failed, OR an ExprError, both of | |
| /// which are cases where transformation shouldn't continue. | |
| ExprResult TransformRequiresTypeParams( | |
| SourceLocation KWLoc, SourceLocation RBraceLoc, const RequiresExpr *RE, | |
| RequiresExprBodyDecl *Body, ArrayRef<ParmVarDecl *> Params, | |
| SmallVectorImpl<QualType> &PTypes, | |
| SmallVectorImpl<ParmVarDecl *> &TransParams, | |
| Sema::ExtParameterInfoBuilder &PInfos) { | |
| if (getDerived().TransformFunctionTypeParams( | |
| KWLoc, Params, /*ParamTypes=*/nullptr, | |
| /*ParamInfos=*/nullptr, PTypes, &TransParams, PInfos)) | |
| return ExprError(); | |
| return ExprResult{}; | |
| } | |
| /// Transforms a single function-type parameter. Return null | |
| /// on error. | |
| /// | |
| /// \param indexAdjustment - A number to add to the parameter's | |
| /// scope index; can be negative | |
| ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm, | |
| int indexAdjustment, | |
| UnsignedOrNone NumExpansions, | |
| bool ExpectParameterPack); | |
| /// Transform the body of a lambda-expression. | |
| StmtResult TransformLambdaBody(LambdaExpr *E, Stmt *Body); | |
| /// Alternative implementation of TransformLambdaBody that skips transforming | |
| /// the body. | |
| StmtResult SkipLambdaBody(LambdaExpr *E, Stmt *Body); | |
| CXXRecordDecl::LambdaDependencyKind | |
| ComputeLambdaDependency(LambdaScopeInfo *LSI) { | |
| return static_cast<CXXRecordDecl::LambdaDependencyKind>( | |
| LSI->Lambda->getLambdaDependencyKind()); | |
| } | |
| ExprResult TransformLambdaConstraint(Expr *AC) { return AC; } | |
| QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL); | |
| StmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr); | |
| ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *E); | |
| TemplateParameterList *TransformTemplateParameterList( | |
| TemplateParameterList *TPL) { | |
| return TPL; | |
| } | |
| ExprResult TransformAddressOfOperand(Expr *E); | |
| ExprResult TransformDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E, | |
| bool IsAddressOfOperand, | |
| TypeSourceInfo **RecoveryTSI); | |
| ExprResult TransformParenDependentScopeDeclRefExpr( | |
| ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool IsAddressOfOperand, | |
| TypeSourceInfo **RecoveryTSI); | |
| ExprResult TransformUnresolvedLookupExpr(UnresolvedLookupExpr *E, | |
| bool IsAddressOfOperand); | |
| StmtResult TransformOMPExecutableDirective(OMPExecutableDirective *S); | |
| StmtResult TransformOMPInformationalDirective(OMPExecutableDirective *S); | |
| // FIXME: We use LLVM_ATTRIBUTE_NOINLINE because inlining causes a ridiculous | |
| // amount of stack usage with clang. | |
| #define STMT(Node, Parent) \ | |
| LLVM_ATTRIBUTE_NOINLINE \ | |
| StmtResult Transform##Node(Node *S); | |
| #define VALUESTMT(Node, Parent) \ | |
| LLVM_ATTRIBUTE_NOINLINE \ | |
| StmtResult Transform##Node(Node *S, StmtDiscardKind SDK); | |
| #define EXPR(Node, Parent) \ | |
| LLVM_ATTRIBUTE_NOINLINE \ | |
| ExprResult Transform##Node(Node *E); | |
| #define ABSTRACT_STMT(Stmt) | |
| #include "clang/AST/StmtNodes.inc" | |
| #define GEN_CLANG_CLAUSE_CLASS | |
| #define CLAUSE_CLASS(Enum, Str, Class) \ | |
| LLVM_ATTRIBUTE_NOINLINE \ | |
| OMPClause *Transform##Class(Class *S); | |
| #include "llvm/Frontend/OpenMP/OMP.inc" | |
| /// Build a new qualified type given its unqualified type and type location. | |
| /// | |
| /// By default, this routine adds type qualifiers only to types that can | |
| /// have qualifiers, and silently suppresses those qualifiers that are not | |
| /// permitted. Subclasses may override this routine to provide different | |
| /// behavior. | |
| QualType RebuildQualifiedType(QualType T, QualifiedTypeLoc TL); | |
| /// Build a new pointer type given its pointee type. | |
| /// | |
| /// By default, performs semantic analysis when building the pointer type. | |
| /// Subclasses may override this routine to provide different behavior. | |
| QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil); | |
| /// Build a new block pointer type given its pointee type. | |
| /// | |
| /// By default, performs semantic analysis when building the block pointer | |
| /// type. Subclasses may override this routine to provide different behavior. | |
| QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil); | |
| /// Build a new reference type given the type it references. | |
| /// | |
| /// By default, performs semantic analysis when building the | |
| /// reference type. Subclasses may override this routine to provide | |
| /// different behavior. | |
| /// | |
| /// \param LValue whether the type was written with an lvalue sigil | |
| /// or an rvalue sigil. | |
| QualType RebuildReferenceType(QualType ReferentType, | |
| bool LValue, | |
| SourceLocation Sigil); | |
| /// Build a new member pointer type given the pointee type and the | |
| /// qualifier it refers into. | |
| /// | |
| /// By default, performs semantic analysis when building the member pointer | |
| /// type. Subclasses may override this routine to provide different behavior. | |
| QualType RebuildMemberPointerType(QualType PointeeType, | |
| const CXXScopeSpec &SS, CXXRecordDecl *Cls, | |
| SourceLocation Sigil); | |
| QualType RebuildObjCTypeParamType(const ObjCTypeParamDecl *Decl, | |
| SourceLocation ProtocolLAngleLoc, | |
| ArrayRef<ObjCProtocolDecl *> Protocols, | |
| ArrayRef<SourceLocation> ProtocolLocs, | |
| SourceLocation ProtocolRAngleLoc); | |
| /// Build an Objective-C object type. | |
| /// | |
| /// By default, performs semantic analysis when building the object type. | |
| /// Subclasses may override this routine to provide different behavior. | |
| QualType RebuildObjCObjectType(QualType BaseType, | |
| SourceLocation Loc, | |
| SourceLocation TypeArgsLAngleLoc, | |
| ArrayRef<TypeSourceInfo *> TypeArgs, | |
| SourceLocation TypeArgsRAngleLoc, | |
| SourceLocation ProtocolLAngleLoc, | |
| ArrayRef<ObjCProtocolDecl *> Protocols, | |
| ArrayRef<SourceLocation> ProtocolLocs, | |
| SourceLocation ProtocolRAngleLoc); | |
| /// Build a new Objective-C object pointer type given the pointee type. | |
| /// | |
| /// By default, directly builds the pointer type, with no additional semantic | |
| /// analysis. | |
| QualType RebuildObjCObjectPointerType(QualType PointeeType, | |
| SourceLocation Star); | |
| /// Build a new array type given the element type, size | |
| /// modifier, size of the array (if known), size expression, and index type | |
| /// qualifiers. | |
| /// | |
| /// By default, performs semantic analysis when building the array type. | |
| /// Subclasses may override this routine to provide different behavior. | |
| /// Also by default, all of the other Rebuild*Array | |
| QualType RebuildArrayType(QualType ElementType, ArraySizeModifier SizeMod, | |
| const llvm::APInt *Size, Expr *SizeExpr, | |
| unsigned IndexTypeQuals, SourceRange BracketsRange); | |
| /// Build a new constant array type given the element type, size | |
| /// modifier, (known) size of the array, and index type qualifiers. | |
| /// | |
| /// By default, performs semantic analysis when building the array type. | |
| /// Subclasses may override this routine to provide different behavior. | |
| QualType RebuildConstantArrayType(QualType ElementType, | |
| ArraySizeModifier SizeMod, | |
| const llvm::APInt &Size, Expr *SizeExpr, | |
| unsigned IndexTypeQuals, | |
| SourceRange BracketsRange); | |
| /// Build a new incomplete array type given the element type, size | |
| /// modifier, and index type qualifiers. | |
| /// | |
| /// By default, performs semantic analysis when building the array type. | |
| /// Subclasses may override this routine to provide different behavior. | |
| QualType RebuildIncompleteArrayType(QualType ElementType, | |
| ArraySizeModifier SizeMod, | |
| unsigned IndexTypeQuals, | |
| SourceRange BracketsRange); | |
| /// Build a new variable-length array type given the element type, | |
| /// size modifier, size expression, and index type qualifiers. | |
| /// | |
| /// By default, performs semantic analysis when building the array type. | |
| /// Subclasses may override this routine to provide different behavior. | |
| QualType RebuildVariableArrayType(QualType ElementType, | |
| ArraySizeModifier SizeMod, Expr *SizeExpr, | |
| unsigned IndexTypeQuals, | |
| SourceRange BracketsRange); | |
| /// Build a new dependent-sized array type given the element type, | |
| /// size modifier, size expression, and index type qualifiers. | |
| /// | |
| /// By default, performs semantic analysis when building the array type. | |
| /// Subclasses may override this routine to provide different behavior. | |
| QualType RebuildDependentSizedArrayType(QualType ElementType, | |
| ArraySizeModifier SizeMod, | |
| Expr *SizeExpr, | |
| unsigned IndexTypeQuals, | |
| SourceRange BracketsRange); | |
| /// Build a new vector type given the element type and | |
| /// number of elements. | |
| /// | |
| /// By default, performs semantic analysis when building the vector type. | |
| /// Subclasses may override this routine to provide different behavior. | |
| QualType RebuildVectorType(QualType ElementType, unsigned NumElements, | |
| VectorKind VecKind); | |
| /// Build a new potentially dependently-sized extended vector type | |
| /// given the element type and number of elements. | |
| /// | |
| /// By default, performs semantic analysis when building the vector type. | |
| /// Subclasses may override this routine to provide different behavior. | |
| QualType RebuildDependentVectorType(QualType ElementType, Expr *SizeExpr, | |
| SourceLocation AttributeLoc, VectorKind); | |
| /// Build a new extended vector type given the element type and | |
| /// number of elements. | |
| /// | |
| /// By default, performs semantic analysis when building the vector type. | |
| /// Subclasses may override this routine to provide different behavior. | |
| QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements, | |
| SourceLocation AttributeLoc); | |
| /// Build a new potentially dependently-sized extended vector type | |
| /// given the element type and number of elements. | |
| /// | |
| /// By default, performs semantic analysis when building the vector type. | |
| /// Subclasses may override this routine to provide different behavior. | |
| QualType RebuildDependentSizedExtVectorType(QualType ElementType, | |
| Expr *SizeExpr, | |
| SourceLocation AttributeLoc); | |
| /// Build a new matrix type given the element type and dimensions. | |
| QualType RebuildConstantMatrixType(QualType ElementType, unsigned NumRows, | |
| unsigned NumColumns, | |
| SourceLocation AttributeLoc); | |
| /// Build a new matrix type given the type and dependently-defined | |
| /// dimensions. | |
| QualType RebuildDependentSizedMatrixType(QualType ElementType, Expr *RowExpr, | |
| Expr *ColumnExpr, | |
| SourceLocation AttributeLoc); | |
| /// Build a new DependentAddressSpaceType or return the pointee | |
| /// type variable with the correct address space (retrieved from | |
| /// AddrSpaceExpr) applied to it. The former will be returned in cases | |
| /// where the address space remains dependent. | |
| /// | |
| /// By default, performs semantic analysis when building the type with address | |
| /// space applied. Subclasses may override this routine to provide different | |
| /// behavior. | |
| QualType RebuildDependentAddressSpaceType(QualType PointeeType, | |
| Expr *AddrSpaceExpr, | |
| SourceLocation AttributeLoc); | |
| /// Build a new function type. | |
| /// | |
| /// By default, performs semantic analysis when building the function type. | |
| /// Subclasses may override this routine to provide different behavior. | |
| QualType RebuildFunctionProtoType(QualType T, | |
| MutableArrayRef<QualType> ParamTypes, | |
| const FunctionProtoType::ExtProtoInfo &EPI); | |
| /// Build a new unprototyped function type. | |
| QualType RebuildFunctionNoProtoType(QualType ResultType); | |
| /// Rebuild an unresolved typename type, given the decl that | |
| /// the UnresolvedUsingTypenameDecl was transformed to. | |
| QualType RebuildUnresolvedUsingType(ElaboratedTypeKeyword Keyword, | |
| NestedNameSpecifier Qualifier, | |
| SourceLocation NameLoc, Decl *D); | |
| /// Build a new type found via an alias. | |
| QualType RebuildUsingType(ElaboratedTypeKeyword Keyword, | |
| NestedNameSpecifier Qualifier, UsingShadowDecl *D, | |
| QualType UnderlyingType) { | |
| return SemaRef.Context.getUsingType(Keyword, Qualifier, D, UnderlyingType); | |
| } | |
| /// Build a new typedef type. | |
| QualType RebuildTypedefType(ElaboratedTypeKeyword Keyword, | |
| NestedNameSpecifier Qualifier, | |
| TypedefNameDecl *Typedef) { | |
| return SemaRef.Context.getTypedefType(Keyword, Qualifier, Typedef); | |
| } | |
| /// Build a new MacroDefined type. | |
| QualType RebuildMacroQualifiedType(QualType T, | |
| const IdentifierInfo *MacroII) { | |
| return SemaRef.Context.getMacroQualifiedType(T, MacroII); | |
| } | |
| /// Build a new class/struct/union/enum type. | |
| QualType RebuildTagType(ElaboratedTypeKeyword Keyword, | |
| NestedNameSpecifier Qualifier, TagDecl *Tag) { | |
| return SemaRef.Context.getTagType(Keyword, Qualifier, Tag, | |
| /*OwnsTag=*/false); | |
| } | |
| QualType RebuildCanonicalTagType(TagDecl *Tag) { | |
| return SemaRef.Context.getCanonicalTagType(Tag); | |
| } | |
| /// Build a new typeof(expr) type. | |
| /// | |
| /// By default, performs semantic analysis when building the typeof type. | |
| /// Subclasses may override this routine to provide different behavior. | |
| QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc, | |
| TypeOfKind Kind); | |
| /// Build a new typeof(type) type. | |
| /// | |
| /// By default, builds a new TypeOfType with the given underlying type. | |
| QualType RebuildTypeOfType(QualType Underlying, TypeOfKind Kind); | |
| /// Build a new unary transform type. | |
| QualType RebuildUnaryTransformType(QualType BaseType, | |
| UnaryTransformType::UTTKind UKind, | |
| SourceLocation Loc); | |
| /// Build a new C++11 decltype type. | |
| /// | |
| /// By default, performs semantic analysis when building the decltype type. | |
| /// Subclasses may override this routine to provide different behavior. | |
| QualType RebuildDecltypeType(Expr *Underlying, SourceLocation Loc); | |
| QualType RebuildPackIndexingType(QualType Pattern, Expr *IndexExpr, | |
| SourceLocation Loc, bool FullySubstituted, | |
| ArrayRef<QualType> Expansions = {}); | |
| /// Build a new C++11 auto type. | |
| /// | |
| /// By default, builds a new AutoType with the given deduced type. | |
| QualType RebuildAutoType(DeducedKind DK, QualType DeducedAsType, | |
| AutoTypeKeyword Keyword, | |
| TemplateName TypeConstraintConcept, | |
| ArrayRef<TemplateArgument> TypeConstraintArgs) { | |
| return SemaRef.Context.getAutoType( | |
| DK, DeducedAsType, Keyword, TypeConstraintConcept, TypeConstraintArgs); | |
| } | |
| /// By default, builds a new DeducedTemplateSpecializationType with the given | |
| /// deduced type. | |
| QualType RebuildDeducedTemplateSpecializationType( | |
| DeducedKind DK, QualType DeducedAsType, ElaboratedTypeKeyword Keyword, | |
| TemplateName Template) { | |
| return SemaRef.Context.getDeducedTemplateSpecializationType( | |
| DK, DeducedAsType, Keyword, Template); | |
| } | |
| /// Build a new template specialization type. | |
| /// | |
| /// By default, performs semantic analysis when building the template | |
| /// specialization type. Subclasses may override this routine to provide | |
| /// different behavior. | |
| QualType RebuildTemplateSpecializationType(ElaboratedTypeKeyword Keyword, | |
| TemplateName Template, | |
| SourceLocation TemplateLoc, | |
| TemplateArgumentListInfo &Args); | |
| /// Build a new parenthesized type. | |
| /// | |
| /// By default, builds a new ParenType type from the inner type. | |
| /// Subclasses may override this routine to provide different behavior. | |
| QualType RebuildParenType(QualType InnerType) { | |
| return SemaRef.BuildParenType(InnerType); | |
| } | |
| /// Build a new typename type that refers to an identifier. | |
| /// | |
| /// By default, performs semantic analysis when building the typename type | |
| /// (or elaborated type). Subclasses may override this routine to provide | |
| /// different behavior. | |
| QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword, | |
| SourceLocation KeywordLoc, | |
| NestedNameSpecifierLoc QualifierLoc, | |
| const IdentifierInfo *Id, | |
| SourceLocation IdLoc, | |
| bool DeducedTSTContext) { | |
| CXXScopeSpec SS; | |
| SS.Adopt(QualifierLoc); | |
| if (QualifierLoc.getNestedNameSpecifier().isDependent()) { | |
| // If the name is still dependent, just build a new dependent name type. | |
| if (!SemaRef.computeDeclContext(SS)) | |
| return SemaRef.Context.getDependentNameType(Keyword, | |
| QualifierLoc.getNestedNameSpecifier(), | |
| Id); | |
| } | |
| if (Keyword == ElaboratedTypeKeyword::None || | |
| Keyword == ElaboratedTypeKeyword::Typename) { | |
| return SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc, | |
| *Id, IdLoc, DeducedTSTContext); | |
| } | |
| TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword); | |
| // We had a dependent elaborated-type-specifier that has been transformed | |
| // into a non-dependent elaborated-type-specifier. Find the tag we're | |
| // referring to. | |
| LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName); | |
| DeclContext *DC = SemaRef.computeDeclContext(SS, false); | |
| if (!DC) | |
| return QualType(); | |
| if (SemaRef.RequireCompleteDeclContext(SS, DC)) | |
| return QualType(); | |
| TagDecl *Tag = nullptr; | |
| SemaRef.LookupQualifiedName(Result, DC); | |
| switch (Result.getResultKind()) { | |
| case LookupResultKind::NotFound: | |
| case LookupResultKind::NotFoundInCurrentInstantiation: | |
| break; | |
| case LookupResultKind::Found: | |
| Tag = Result.getAsSingle<TagDecl>(); | |
| break; | |
| case LookupResultKind::FoundOverloaded: | |
| case LookupResultKind::FoundUnresolvedValue: | |
| llvm_unreachable("Tag lookup cannot find non-tags"); | |
| case LookupResultKind::Ambiguous: | |
| // Let the LookupResult structure handle ambiguities. | |
| return QualType(); | |
| } | |
| if (!Tag) { | |
| // Check where the name exists but isn't a tag type and use that to emit | |
| // better diagnostics. | |
| LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName); | |
| SemaRef.LookupQualifiedName(Result, DC); | |
| switch (Result.getResultKind()) { | |
| case LookupResultKind::Found: | |
| case LookupResultKind::FoundOverloaded: | |
| case LookupResultKind::FoundUnresolvedValue: { | |
| NamedDecl *SomeDecl = Result.getRepresentativeDecl(); | |
| NonTagKind NTK = SemaRef.getNonTagTypeDeclKind(SomeDecl, Kind); | |
| SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) | |
| << SomeDecl << NTK << Kind; | |
| SemaRef.Diag(SomeDecl->getLocation(), diag::note_declared_at); | |
| break; | |
| } | |
| default: | |
| SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope) | |
| << Kind << Id << DC << QualifierLoc.getSourceRange(); | |
| break; | |
| } | |
| return QualType(); | |
| } | |
| if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind, /*isDefinition*/false, | |
| IdLoc, Id)) { | |
| SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id; | |
| SemaRef.Diag(Tag->getLocation(), diag::note_previous_use); | |
| return QualType(); | |
| } | |
| return getDerived().RebuildTagType( | |
| Keyword, QualifierLoc.getNestedNameSpecifier(), Tag); | |
| } | |
| /// Build a new pack expansion type. | |
| /// | |
| /// By default, builds a new PackExpansionType type from the given pattern. | |
| /// Subclasses may override this routine to provide different behavior. | |
| QualType RebuildPackExpansionType(QualType Pattern, SourceRange PatternRange, | |
| SourceLocation EllipsisLoc, | |
| UnsignedOrNone NumExpansions) { | |
| return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc, | |
| NumExpansions); | |
| } | |
| /// Build a new atomic type given its value type. | |
| /// | |
| /// By default, performs semantic analysis when building the atomic type. | |
| /// Subclasses may override this routine to provide different behavior. | |
| QualType RebuildAtomicType(QualType ValueType, SourceLocation KWLoc); | |
| /// Build a new pipe type given its value type. | |
| QualType RebuildPipeType(QualType ValueType, SourceLocation KWLoc, | |
| bool isReadPipe); | |
| /// Build a bit-precise int given its value type. | |
| QualType RebuildBitIntType(bool IsUnsigned, unsigned NumBits, | |
| SourceLocation Loc); | |
| /// Build a dependent bit-precise int given its value type. | |
| QualType RebuildDependentBitIntType(bool IsUnsigned, Expr *NumBitsExpr, | |
| SourceLocation Loc); | |
| /// Build a new template name given a nested name specifier, a flag | |
| /// indicating whether the "template" keyword was provided, and the template | |
| /// that the template name refers to. | |
| /// | |
| /// By default, builds the new template name directly. Subclasses may override | |
| /// this routine to provide different behavior. | |
| TemplateName RebuildTemplateName(CXXScopeSpec &SS, bool TemplateKW, | |
| TemplateName Name); | |
| /// Build a new template name given a nested name specifier and the | |
| /// name that is referred to as a template. | |
| /// | |
| /// By default, performs semantic analysis to determine whether the name can | |
| /// be resolved to a specific template, then builds the appropriate kind of | |
| /// template name. Subclasses may override this routine to provide different | |
| /// behavior. | |
| TemplateName RebuildTemplateName(CXXScopeSpec &SS, | |
| SourceLocation TemplateKWLoc, | |
| const IdentifierInfo &Name, | |
| SourceLocation NameLoc, QualType ObjectType, | |
| bool AllowInjectedClassName); | |
| /// Build a new template name given a nested name specifier and the | |
| /// overloaded operator name that is referred to as a template. | |
| /// | |
| /// By default, performs semantic analysis to determine whether the name can | |
| /// be resolved to a specific template, then builds the appropriate kind of | |
| /// template name. Subclasses may override this routine to provide different | |
| /// behavior. | |
| TemplateName RebuildTemplateName(CXXScopeSpec &SS, | |
| SourceLocation TemplateKWLoc, | |
| OverloadedOperatorKind Operator, | |
| SourceLocation NameLoc, QualType ObjectType, | |
| bool AllowInjectedClassName); | |
| TemplateName RebuildTemplateName(CXXScopeSpec &SS, | |
| SourceLocation TemplateKWLoc, | |
| IdentifierOrOverloadedOperator IO, | |
| SourceLocation NameLoc, QualType ObjectType, | |
| bool AllowInjectedClassName); | |
| /// Build a new template name given a template template parameter pack | |
| /// and the | |
| /// | |
| /// By default, performs semantic analysis to determine whether the name can | |
| /// be resolved to a specific template, then builds the appropriate kind of | |
| /// template name. Subclasses may override this routine to provide different | |
| /// behavior. | |
| TemplateName RebuildTemplateName(const TemplateArgument &ArgPack, | |
| Decl *AssociatedDecl, unsigned Index, | |
| bool Final) { | |
| return getSema().Context.getSubstTemplateTemplateParmPack( | |
| ArgPack, AssociatedDecl, Index, Final); | |
| } | |
| /// Build a new pack-index-template-name ([temp.names]). | |
| /// | |
| /// By default, performs semantic analysis to build the new template name. | |
| /// Subclasses may override this routine to provide different behavior. | |
| TemplateName | |
| RebuildPackIndexingTemplateName(TemplateName Pattern, Expr *IndexExpr, | |
| bool FullySubstituted, | |
| ArrayRef<TemplateName> Expansions = {}) { | |
| return getSema().BuildPackIndexingTemplateName( | |
| Pattern, IndexExpr, FullySubstituted, Expansions); | |
| } | |
| /// Build a new compound statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildCompoundStmt(SourceLocation LBraceLoc, | |
| MultiStmtArg Statements, | |
| SourceLocation RBraceLoc, | |
| bool IsStmtExpr) { | |
| return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements, | |
| IsStmtExpr); | |
| } | |
| /// Build a new case statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildCaseStmt(SourceLocation CaseLoc, | |
| Expr *LHS, | |
| SourceLocation EllipsisLoc, | |
| Expr *RHS, | |
| SourceLocation ColonLoc) { | |
| return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS, | |
| ColonLoc); | |
| } | |
| /// Attach the body to a new case statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildCaseStmtBody(Stmt *S, Stmt *Body) { | |
| getSema().ActOnCaseStmtBody(S, Body); | |
| return S; | |
| } | |
| /// Build a new default statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildDefaultStmt(SourceLocation DefaultLoc, | |
| SourceLocation ColonLoc, | |
| Stmt *SubStmt) { | |
| return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt, | |
| /*CurScope=*/nullptr); | |
| } | |
| /// Build a new label statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildLabelStmt(SourceLocation IdentLoc, LabelDecl *L, | |
| SourceLocation ColonLoc, Stmt *SubStmt) { | |
| return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt); | |
| } | |
| /// Build a new attributed statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildAttributedStmt(SourceLocation AttrLoc, | |
| ArrayRef<const Attr *> Attrs, | |
| Stmt *SubStmt) { | |
| if (SemaRef.CheckRebuiltStmtAttributes(Attrs)) | |
| return StmtError(); | |
| return SemaRef.BuildAttributedStmt(AttrLoc, Attrs, SubStmt); | |
| } | |
| /// Build a new "if" statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildIfStmt(SourceLocation IfLoc, IfStatementKind Kind, | |
| SourceLocation LParenLoc, Sema::ConditionResult Cond, | |
| SourceLocation RParenLoc, Stmt *Init, Stmt *Then, | |
| SourceLocation ElseLoc, Stmt *Else) { | |
| return getSema().ActOnIfStmt(IfLoc, Kind, LParenLoc, Init, Cond, RParenLoc, | |
| Then, ElseLoc, Else); | |
| } | |
| /// Start building a new switch statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc, | |
| SourceLocation LParenLoc, Stmt *Init, | |
| Sema::ConditionResult Cond, | |
| SourceLocation RParenLoc) { | |
| return getSema().ActOnStartOfSwitchStmt(SwitchLoc, LParenLoc, Init, Cond, | |
| RParenLoc); | |
| } | |
| /// Attach the body to the switch statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc, | |
| Stmt *Switch, Stmt *Body) { | |
| return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body); | |
| } | |
| /// Build a new while statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc, | |
| Sema::ConditionResult Cond, | |
| SourceLocation RParenLoc, Stmt *Body) { | |
| return getSema().ActOnWhileStmt(WhileLoc, LParenLoc, Cond, RParenLoc, Body); | |
| } | |
| /// Build a new do-while statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildDoStmt(SourceLocation DoLoc, Stmt *Body, | |
| SourceLocation WhileLoc, SourceLocation LParenLoc, | |
| Expr *Cond, SourceLocation RParenLoc) { | |
| return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc, | |
| Cond, RParenLoc); | |
| } | |
| /// Build a new for statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, | |
| Stmt *Init, Sema::ConditionResult Cond, | |
| Sema::FullExprArg Inc, SourceLocation RParenLoc, | |
| Stmt *Body) { | |
| return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond, | |
| Inc, RParenLoc, Body); | |
| } | |
| /// Build a new goto statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc, | |
| LabelDecl *Label) { | |
| return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label); | |
| } | |
| /// Build a new indirect goto statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc, | |
| SourceLocation StarLoc, | |
| Expr *Target) { | |
| return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target); | |
| } | |
| /// Build a new return statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, Expr *Result) { | |
| return getSema().BuildReturnStmt(ReturnLoc, Result); | |
| } | |
| /// Build a new declaration statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildDeclStmt(MutableArrayRef<Decl *> Decls, | |
| SourceLocation StartLoc, SourceLocation EndLoc) { | |
| Sema::DeclGroupPtrTy DG = getSema().BuildDeclaratorGroup(Decls); | |
| return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc); | |
| } | |
| /// Build a new inline asm statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, | |
| bool IsVolatile, unsigned NumOutputs, | |
| unsigned NumInputs, IdentifierInfo **Names, | |
| MultiExprArg Constraints, MultiExprArg Exprs, | |
| Expr *AsmString, MultiExprArg Clobbers, | |
| unsigned NumLabels, | |
| SourceLocation RParenLoc) { | |
| return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs, | |
| NumInputs, Names, Constraints, Exprs, | |
| AsmString, Clobbers, NumLabels, RParenLoc); | |
| } | |
| /// Build a new MS style inline asm statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc, | |
| ArrayRef<Token> AsmToks, | |
| StringRef AsmString, | |
| unsigned NumOutputs, unsigned NumInputs, | |
| ArrayRef<StringRef> Constraints, | |
| ArrayRef<StringRef> Clobbers, | |
| ArrayRef<Expr*> Exprs, | |
| SourceLocation EndLoc) { | |
| return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString, | |
| NumOutputs, NumInputs, | |
| Constraints, Clobbers, Exprs, EndLoc); | |
| } | |
| /// Build a new co_return statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildCoreturnStmt(SourceLocation CoreturnLoc, Expr *Result, | |
| bool IsImplicit) { | |
| return getSema().BuildCoreturnStmt(CoreturnLoc, Result, IsImplicit); | |
| } | |
| /// Build a new co_await expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCoawaitExpr(SourceLocation CoawaitLoc, Expr *Operand, | |
| UnresolvedLookupExpr *OpCoawaitLookup, | |
| bool IsImplicit) { | |
| // This function rebuilds a coawait-expr given its operator. | |
| // For an explicit coawait-expr, the rebuild involves the full set | |
| // of transformations performed by BuildUnresolvedCoawaitExpr(), | |
| // including calling await_transform(). | |
| // For an implicit coawait-expr, we need to rebuild the "operator | |
| // coawait" but not await_transform(), so use BuildResolvedCoawaitExpr(). | |
| // This mirrors how the implicit CoawaitExpr is originally created | |
| // in Sema::ActOnCoroutineBodyStart(). | |
| if (IsImplicit) { | |
| ExprResult Suspend = getSema().BuildOperatorCoawaitCall( | |
| CoawaitLoc, Operand, OpCoawaitLookup); | |
| if (Suspend.isInvalid()) | |
| return ExprError(); | |
| return getSema().BuildResolvedCoawaitExpr(CoawaitLoc, Operand, | |
| Suspend.get(), true); | |
| } | |
| return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Operand, | |
| OpCoawaitLookup); | |
| } | |
| /// Build a new co_await expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildDependentCoawaitExpr(SourceLocation CoawaitLoc, | |
| Expr *Result, | |
| UnresolvedLookupExpr *Lookup) { | |
| return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Result, Lookup); | |
| } | |
| /// Build a new co_yield expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCoyieldExpr(SourceLocation CoyieldLoc, Expr *Result) { | |
| return getSema().BuildCoyieldExpr(CoyieldLoc, Result); | |
| } | |
| StmtResult RebuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs Args) { | |
| return getSema().BuildCoroutineBodyStmt(Args); | |
| } | |
| /// Build a new Objective-C \@try statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc, | |
| Stmt *TryBody, | |
| MultiStmtArg CatchStmts, | |
| Stmt *Finally) { | |
| return getSema().ObjC().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts, | |
| Finally); | |
| } | |
| /// Rebuild an Objective-C exception declaration. | |
| /// | |
| /// By default, performs semantic analysis to build the new declaration. | |
| /// Subclasses may override this routine to provide different behavior. | |
| VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl, | |
| TypeSourceInfo *TInfo, QualType T) { | |
| return getSema().ObjC().BuildObjCExceptionDecl( | |
| TInfo, T, ExceptionDecl->getInnerLocStart(), | |
| ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier()); | |
| } | |
| /// Build a new Objective-C \@catch statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildObjCAtCatchStmt(SourceLocation AtLoc, | |
| SourceLocation RParenLoc, | |
| VarDecl *Var, | |
| Stmt *Body) { | |
| return getSema().ObjC().ActOnObjCAtCatchStmt(AtLoc, RParenLoc, Var, Body); | |
| } | |
| /// Build a new Objective-C \@finally statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildObjCAtFinallyStmt(SourceLocation AtLoc, | |
| Stmt *Body) { | |
| return getSema().ObjC().ActOnObjCAtFinallyStmt(AtLoc, Body); | |
| } | |
| /// Build a new Objective-C \@throw statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc, | |
| Expr *Operand) { | |
| return getSema().ObjC().BuildObjCAtThrowStmt(AtLoc, Operand); | |
| } | |
| /// Build a new OpenMP Canonical loop. | |
| /// | |
| /// Ensures that the outermost loop in @p LoopStmt is wrapped by a | |
| /// OMPCanonicalLoop. | |
| StmtResult RebuildOMPCanonicalLoop(Stmt *LoopStmt) { | |
| return getSema().OpenMP().ActOnOpenMPCanonicalLoop(LoopStmt); | |
| } | |
| /// Build a new OpenMP executable directive. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind, | |
| DeclarationNameInfo DirName, | |
| OpenMPDirectiveKind CancelRegion, | |
| ArrayRef<OMPClause *> Clauses, | |
| Stmt *AStmt, SourceLocation StartLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPExecutableDirective( | |
| Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP informational directive. | |
| StmtResult RebuildOMPInformationalDirective(OpenMPDirectiveKind Kind, | |
| DeclarationNameInfo DirName, | |
| ArrayRef<OMPClause *> Clauses, | |
| Stmt *AStmt, | |
| SourceLocation StartLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPInformationalDirective( | |
| Kind, DirName, Clauses, AStmt, StartLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'if' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPIfClause(OpenMPDirectiveKind NameModifier, | |
| Expr *Condition, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation NameModifierLoc, | |
| SourceLocation ColonLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPIfClause( | |
| NameModifier, Condition, StartLoc, LParenLoc, NameModifierLoc, ColonLoc, | |
| EndLoc); | |
| } | |
| /// Build a new OpenMP 'final' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPFinalClause(Expr *Condition, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPFinalClause(Condition, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'num_threads' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPNumThreadsClause( | |
| ArrayRef<Expr *> VarList, | |
| OpenMPNumThreadsClauseModifier PrescriptivenessModifier, | |
| SourceLocation PrescriptivenessModifierLoc, | |
| OpenMPNumThreadsClauseModifier DimsModifier, Expr *DimsModifierExpr, | |
| SourceLocation DimsModifierLoc, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPNumThreadsClause( | |
| VarList, PrescriptivenessModifier, PrescriptivenessModifierLoc, | |
| DimsModifier, DimsModifierExpr, DimsModifierLoc, StartLoc, LParenLoc, | |
| EndLoc); | |
| } | |
| /// Build a new OpenMP 'safelen' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPSafelenClause(Expr *Len, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, | |
| EndLoc); | |
| } | |
| /// Build a new OpenMP 'simdlen' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPSimdlenClause(Expr *Len, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPSimdlenClause(Len, StartLoc, LParenLoc, | |
| EndLoc); | |
| } | |
| OMPClause *RebuildOMPSizesClause(ArrayRef<Expr *> Sizes, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPSizesClause(Sizes, StartLoc, LParenLoc, | |
| EndLoc); | |
| } | |
| OMPClause *RebuildOMPCountsClause(ArrayRef<Expr *> Counts, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc, | |
| std::optional<unsigned> FillIdx, | |
| SourceLocation FillLoc) { | |
| unsigned FillCount = FillIdx ? 1 : 0; | |
| return getSema().OpenMP().ActOnOpenMPCountsClause( | |
| Counts, StartLoc, LParenLoc, EndLoc, FillIdx, FillLoc, FillCount); | |
| } | |
| /// Build a new OpenMP 'permutation' clause. | |
| OMPClause *RebuildOMPPermutationClause(ArrayRef<Expr *> PermExprs, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPPermutationClause(PermExprs, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'full' clause. | |
| OMPClause *RebuildOMPFullClause(SourceLocation StartLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPFullClause(StartLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'partial' clause. | |
| OMPClause *RebuildOMPPartialClause(Expr *Factor, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPPartialClause(Factor, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'depth' clause. | |
| OMPClause *RebuildOMPDepthClause(Expr *Depth, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPDepthClause(Depth, StartLoc, LParenLoc, | |
| EndLoc); | |
| } | |
| OMPClause * | |
| RebuildOMPLoopRangeClause(Expr *First, Expr *Count, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, SourceLocation FirstLoc, | |
| SourceLocation CountLoc, SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPLoopRangeClause( | |
| First, Count, StartLoc, LParenLoc, FirstLoc, CountLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'allocator' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPAllocatorClause(Expr *A, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPAllocatorClause(A, StartLoc, LParenLoc, | |
| EndLoc); | |
| } | |
| /// Build a new OpenMP 'collapse' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPCollapseClause(Expr *Num, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPCollapseClause(Num, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'default' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPDefaultClause(DefaultKind Kind, SourceLocation KindKwLoc, | |
| OpenMPDefaultClauseVariableCategory VCKind, | |
| SourceLocation VCLoc, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPDefaultClause( | |
| Kind, KindKwLoc, VCKind, VCLoc, StartLoc, LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'proc_bind' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPProcBindClause(ProcBindKind Kind, | |
| SourceLocation KindKwLoc, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPProcBindClause( | |
| Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc); | |
| } | |
| OMPClause *RebuildOMPTransparentClause(Expr *ImpexTypeArg, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPTransparentClause( | |
| ImpexTypeArg, StartLoc, LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'schedule' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPScheduleClause( | |
| OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2, | |
| OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc, | |
| SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPScheduleClause( | |
| M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc, | |
| CommaLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'ordered' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPOrderedClause(SourceLocation StartLoc, | |
| SourceLocation EndLoc, | |
| SourceLocation LParenLoc, Expr *Num) { | |
| return getSema().OpenMP().ActOnOpenMPOrderedClause(StartLoc, EndLoc, | |
| LParenLoc, Num); | |
| } | |
| /// Build a new OpenMP 'nowait' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPNowaitClause(Expr *Condition, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPNowaitClause(StartLoc, EndLoc, | |
| LParenLoc, Condition); | |
| } | |
| /// Build a new OpenMP 'private' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPPrivateClause(ArrayRef<Expr *> VarList, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPPrivateClause(VarList, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'firstprivate' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPFirstprivateClause(ArrayRef<Expr *> VarList, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPFirstprivateClause(VarList, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'lastprivate' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPLastprivateClause(ArrayRef<Expr *> VarList, | |
| OpenMPLastprivateModifier LPKind, | |
| SourceLocation LPKindLoc, | |
| SourceLocation ColonLoc, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPLastprivateClause( | |
| VarList, LPKind, LPKindLoc, ColonLoc, StartLoc, LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'shared' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPSharedClause(ArrayRef<Expr *> VarList, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPSharedClause(VarList, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'reduction' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPReductionClause( | |
| ArrayRef<Expr *> VarList, OpenMPReductionClauseModifier Modifier, | |
| OpenMPOriginalSharingModifier OriginalSharingModifier, | |
| SourceLocation StartLoc, SourceLocation LParenLoc, | |
| SourceLocation ModifierLoc, SourceLocation ColonLoc, | |
| SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec, | |
| const DeclarationNameInfo &ReductionId, | |
| ArrayRef<Expr *> UnresolvedReductions) { | |
| return getSema().OpenMP().ActOnOpenMPReductionClause( | |
| VarList, {Modifier, OriginalSharingModifier}, StartLoc, LParenLoc, | |
| ModifierLoc, ColonLoc, EndLoc, ReductionIdScopeSpec, ReductionId, | |
| UnresolvedReductions); | |
| } | |
| /// Build a new OpenMP 'task_reduction' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPTaskReductionClause( | |
| ArrayRef<Expr *> VarList, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, | |
| CXXScopeSpec &ReductionIdScopeSpec, | |
| const DeclarationNameInfo &ReductionId, | |
| ArrayRef<Expr *> UnresolvedReductions) { | |
| return getSema().OpenMP().ActOnOpenMPTaskReductionClause( | |
| VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec, | |
| ReductionId, UnresolvedReductions); | |
| } | |
| /// Build a new OpenMP 'in_reduction' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause * | |
| RebuildOMPInReductionClause(ArrayRef<Expr *> VarList, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, SourceLocation ColonLoc, | |
| SourceLocation EndLoc, | |
| CXXScopeSpec &ReductionIdScopeSpec, | |
| const DeclarationNameInfo &ReductionId, | |
| ArrayRef<Expr *> UnresolvedReductions) { | |
| return getSema().OpenMP().ActOnOpenMPInReductionClause( | |
| VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec, | |
| ReductionId, UnresolvedReductions); | |
| } | |
| /// Build a new OpenMP 'linear' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPLinearClause( | |
| ArrayRef<Expr *> VarList, Expr *Step, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, | |
| SourceLocation ModifierLoc, SourceLocation ColonLoc, | |
| SourceLocation StepModifierLoc, SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPLinearClause( | |
| VarList, Step, StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc, | |
| StepModifierLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'aligned' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPAlignedClause(ArrayRef<Expr *> VarList, Expr *Alignment, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation ColonLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPAlignedClause( | |
| VarList, Alignment, StartLoc, LParenLoc, ColonLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'copyin' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPCopyinClause(ArrayRef<Expr *> VarList, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPCopyinClause(VarList, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'copyprivate' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPCopyprivateClause(ArrayRef<Expr *> VarList, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPCopyprivateClause(VarList, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'flush' pseudo clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPFlushClause(ArrayRef<Expr *> VarList, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPFlushClause(VarList, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'depobj' pseudo clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPDepobjClause(Expr *Depobj, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPDepobjClause(Depobj, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'depend' pseudo clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPDependClause(OMPDependClause::DependDataTy Data, | |
| Expr *DepModifier, ArrayRef<Expr *> VarList, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPDependClause( | |
| Data, DepModifier, VarList, StartLoc, LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'device' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPDeviceClause(OpenMPDeviceClauseModifier Modifier, | |
| Expr *Device, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation ModifierLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPDeviceClause( | |
| Modifier, Device, StartLoc, LParenLoc, ModifierLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'map' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPMapClause( | |
| Expr *IteratorModifier, ArrayRef<OpenMPMapModifierKind> MapTypeModifiers, | |
| ArrayRef<SourceLocation> MapTypeModifiersLoc, | |
| CXXScopeSpec MapperIdScopeSpec, DeclarationNameInfo MapperId, | |
| OpenMPMapClauseKind MapType, bool IsMapTypeImplicit, | |
| SourceLocation MapLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VarList, | |
| const OMPVarListLocTy &Locs, ArrayRef<Expr *> UnresolvedMappers) { | |
| return getSema().OpenMP().ActOnOpenMPMapClause( | |
| IteratorModifier, MapTypeModifiers, MapTypeModifiersLoc, | |
| MapperIdScopeSpec, MapperId, MapType, IsMapTypeImplicit, MapLoc, | |
| ColonLoc, VarList, Locs, | |
| /*NoDiagnose=*/false, UnresolvedMappers); | |
| } | |
| /// Build a new OpenMP 'allocate' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause * | |
| RebuildOMPAllocateClause(Expr *Allocate, Expr *Alignment, | |
| OpenMPAllocateClauseModifier FirstModifier, | |
| SourceLocation FirstModifierLoc, | |
| OpenMPAllocateClauseModifier SecondModifier, | |
| SourceLocation SecondModifierLoc, | |
| ArrayRef<Expr *> VarList, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, SourceLocation ColonLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPAllocateClause( | |
| Allocate, Alignment, FirstModifier, FirstModifierLoc, SecondModifier, | |
| SecondModifierLoc, VarList, StartLoc, LParenLoc, ColonLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'num_teams' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPNumTeamsClause( | |
| ArrayRef<Expr *> VarList, OpenMPNumTeamsClauseModifier Modifier, | |
| Expr *ModifierExpr, SourceLocation ModifierLoc, | |
| OpenMPNumTeamsClauseModifier ModifierExtra, Expr *ModifierExtraExpr, | |
| SourceLocation ModifierExtraLoc, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPNumTeamsClause( | |
| VarList, Modifier, ModifierExpr, ModifierLoc, ModifierExtra, | |
| ModifierExtraExpr, ModifierExtraLoc, StartLoc, LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'thread_limit' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPThreadLimitClause( | |
| ArrayRef<Expr *> VarList, OpenMPThreadLimitClauseModifier Modifier, | |
| Expr *ModifierExpr, SourceLocation ModifierLoc, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPThreadLimitClause( | |
| VarList, Modifier, ModifierExpr, ModifierLoc, StartLoc, LParenLoc, | |
| EndLoc); | |
| } | |
| /// Build a new OpenMP 'priority' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPPriorityClause(Expr *Priority, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPPriorityClause(Priority, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'grainsize' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPGrainsizeClause(OpenMPGrainsizeClauseModifier Modifier, | |
| Expr *Device, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation ModifierLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPGrainsizeClause( | |
| Modifier, Device, StartLoc, LParenLoc, ModifierLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'num_tasks' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPNumTasksClause(OpenMPNumTasksClauseModifier Modifier, | |
| Expr *NumTasks, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation ModifierLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPNumTasksClause( | |
| Modifier, NumTasks, StartLoc, LParenLoc, ModifierLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'hint' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPHintClause(Expr *Hint, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPHintClause(Hint, StartLoc, LParenLoc, | |
| EndLoc); | |
| } | |
| /// Build a new OpenMP 'detach' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPDetachClause(Expr *Evt, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPDetachClause(Evt, StartLoc, LParenLoc, | |
| EndLoc); | |
| } | |
| /// Build a new OpenMP 'dist_schedule' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause * | |
| RebuildOMPDistScheduleClause(OpenMPDistScheduleClauseKind Kind, | |
| Expr *ChunkSize, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, SourceLocation KindLoc, | |
| SourceLocation CommaLoc, SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPDistScheduleClause( | |
| Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'to' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause * | |
| RebuildOMPToClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers, | |
| ArrayRef<SourceLocation> MotionModifiersLoc, | |
| Expr *IteratorModifier, CXXScopeSpec &MapperIdScopeSpec, | |
| DeclarationNameInfo &MapperId, SourceLocation ColonLoc, | |
| ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs, | |
| ArrayRef<Expr *> UnresolvedMappers) { | |
| return getSema().OpenMP().ActOnOpenMPToClause( | |
| MotionModifiers, MotionModifiersLoc, IteratorModifier, | |
| MapperIdScopeSpec, MapperId, ColonLoc, VarList, Locs, | |
| UnresolvedMappers); | |
| } | |
| /// Build a new OpenMP 'from' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause * | |
| RebuildOMPFromClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers, | |
| ArrayRef<SourceLocation> MotionModifiersLoc, | |
| Expr *IteratorModifier, CXXScopeSpec &MapperIdScopeSpec, | |
| DeclarationNameInfo &MapperId, SourceLocation ColonLoc, | |
| ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs, | |
| ArrayRef<Expr *> UnresolvedMappers) { | |
| return getSema().OpenMP().ActOnOpenMPFromClause( | |
| MotionModifiers, MotionModifiersLoc, IteratorModifier, | |
| MapperIdScopeSpec, MapperId, ColonLoc, VarList, Locs, | |
| UnresolvedMappers); | |
| } | |
| /// Build a new OpenMP 'use_device_ptr' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPUseDevicePtrClause( | |
| ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs, | |
| OpenMPUseDevicePtrFallbackModifier FallbackModifier, | |
| SourceLocation FallbackModifierLoc) { | |
| return getSema().OpenMP().ActOnOpenMPUseDevicePtrClause( | |
| VarList, Locs, FallbackModifier, FallbackModifierLoc); | |
| } | |
| /// Build a new OpenMP 'use_device_addr' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPUseDeviceAddrClause(ArrayRef<Expr *> VarList, | |
| const OMPVarListLocTy &Locs) { | |
| return getSema().OpenMP().ActOnOpenMPUseDeviceAddrClause(VarList, Locs); | |
| } | |
| /// Build a new OpenMP 'is_device_ptr' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPIsDevicePtrClause(ArrayRef<Expr *> VarList, | |
| const OMPVarListLocTy &Locs) { | |
| return getSema().OpenMP().ActOnOpenMPIsDevicePtrClause(VarList, Locs); | |
| } | |
| /// Build a new OpenMP 'has_device_addr' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPHasDeviceAddrClause(ArrayRef<Expr *> VarList, | |
| const OMPVarListLocTy &Locs) { | |
| return getSema().OpenMP().ActOnOpenMPHasDeviceAddrClause(VarList, Locs); | |
| } | |
| /// Build a new OpenMP 'defaultmap' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPDefaultmapClause(OpenMPDefaultmapClauseModifier M, | |
| OpenMPDefaultmapClauseKind Kind, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation MLoc, | |
| SourceLocation KindLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPDefaultmapClause( | |
| M, Kind, StartLoc, LParenLoc, MLoc, KindLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'nontemporal' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPNontemporalClause(ArrayRef<Expr *> VarList, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPNontemporalClause(VarList, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'inclusive' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPInclusiveClause(ArrayRef<Expr *> VarList, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPInclusiveClause(VarList, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'exclusive' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPExclusiveClause(ArrayRef<Expr *> VarList, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPExclusiveClause(VarList, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'uses_allocators' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPUsesAllocatorsClause( | |
| ArrayRef<SemaOpenMP::UsesAllocatorsData> Data, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPUsesAllocatorClause( | |
| StartLoc, LParenLoc, EndLoc, Data); | |
| } | |
| /// Build a new OpenMP 'affinity' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPAffinityClause(SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation ColonLoc, | |
| SourceLocation EndLoc, Expr *Modifier, | |
| ArrayRef<Expr *> Locators) { | |
| return getSema().OpenMP().ActOnOpenMPAffinityClause( | |
| StartLoc, LParenLoc, ColonLoc, EndLoc, Modifier, Locators); | |
| } | |
| /// Build a new OpenMP 'order' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPOrderClause( | |
| OpenMPOrderClauseKind Kind, SourceLocation KindKwLoc, | |
| SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, | |
| OpenMPOrderClauseModifier Modifier, SourceLocation ModifierKwLoc) { | |
| return getSema().OpenMP().ActOnOpenMPOrderClause( | |
| Modifier, Kind, StartLoc, LParenLoc, ModifierKwLoc, KindKwLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'init' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPInitClause(Expr *InteropVar, OMPInteropInfo &InteropInfo, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation VarLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPInitClause( | |
| InteropVar, InteropInfo, StartLoc, LParenLoc, VarLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'use' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPUseClause(Expr *InteropVar, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation VarLoc, SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPUseClause(InteropVar, StartLoc, | |
| LParenLoc, VarLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'destroy' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPDestroyClause(Expr *InteropVar, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation VarLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPDestroyClause( | |
| InteropVar, StartLoc, LParenLoc, VarLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'novariants' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPNovariantsClause(Expr *Condition, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPNovariantsClause(Condition, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'nocontext' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPNocontextClause(Expr *Condition, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPNocontextClause(Condition, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'filter' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPFilterClause(Expr *ThreadID, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPFilterClause(ThreadID, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'bind' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPBindClause(OpenMPBindClauseKind Kind, | |
| SourceLocation KindLoc, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPBindClause(Kind, KindLoc, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'ompx_dyn_cgroup_mem' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPXDynCGroupMemClause(Expr *Size, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPXDynCGroupMemClause(Size, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'dyn_groupprivate' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPDynGroupprivateClause( | |
| OpenMPDynGroupprivateClauseModifier M1, | |
| OpenMPDynGroupprivateClauseFallbackModifier M2, Expr *Size, | |
| SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation M1Loc, | |
| SourceLocation M2Loc, SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPDynGroupprivateClause( | |
| M1, M2, Size, StartLoc, LParenLoc, M1Loc, M2Loc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'ompx_attribute' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPXAttributeClause(ArrayRef<const Attr *> Attrs, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPXAttributeClause(Attrs, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'ompx_bare' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPXBareClause(SourceLocation StartLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPXBareClause(StartLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'align' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPAlignClause(Expr *A, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPAlignClause(A, StartLoc, LParenLoc, | |
| EndLoc); | |
| } | |
| /// Build a new OpenMP 'at' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPAtClause(OpenMPAtClauseKind Kind, SourceLocation KwLoc, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPAtClause(Kind, KwLoc, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'severity' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPSeverityClause(OpenMPSeverityClauseKind Kind, | |
| SourceLocation KwLoc, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPSeverityClause(Kind, KwLoc, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'message' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause *RebuildOMPMessageClause(Expr *MS, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPMessageClause(MS, StartLoc, LParenLoc, | |
| EndLoc); | |
| } | |
| /// Build a new OpenMP 'doacross' clause. | |
| /// | |
| /// By default, performs semantic analysis to build the new OpenMP clause. | |
| /// Subclasses may override this routine to provide different behavior. | |
| OMPClause * | |
| RebuildOMPDoacrossClause(OpenMPDoacrossClauseModifier DepType, | |
| SourceLocation DepLoc, SourceLocation ColonLoc, | |
| ArrayRef<Expr *> VarList, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPDoacrossClause( | |
| DepType, DepLoc, ColonLoc, VarList, StartLoc, LParenLoc, EndLoc); | |
| } | |
| /// Build a new OpenMP 'holds' clause. | |
| OMPClause *RebuildOMPHoldsClause(Expr *A, SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPHoldsClause(A, StartLoc, LParenLoc, | |
| EndLoc); | |
| } | |
| /// Rebuild the operand to an Objective-C \@synchronized statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildObjCAtSynchronizedOperand(SourceLocation atLoc, | |
| Expr *object) { | |
| return getSema().ObjC().ActOnObjCAtSynchronizedOperand(atLoc, object); | |
| } | |
| /// Build a new Objective-C \@synchronized statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc, | |
| Expr *Object, Stmt *Body) { | |
| return getSema().ObjC().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body); | |
| } | |
| /// Build a new Objective-C \@autoreleasepool statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildObjCAutoreleasePoolStmt(SourceLocation AtLoc, | |
| Stmt *Body) { | |
| return getSema().ObjC().ActOnObjCAutoreleasePoolStmt(AtLoc, Body); | |
| } | |
| /// Build a new Objective-C fast enumeration statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildObjCForCollectionStmt(SourceLocation ForLoc, | |
| Stmt *Element, | |
| Expr *Collection, | |
| SourceLocation RParenLoc, | |
| Stmt *Body) { | |
| StmtResult ForEachStmt = getSema().ObjC().ActOnObjCForCollectionStmt( | |
| ForLoc, Element, Collection, RParenLoc); | |
| if (ForEachStmt.isInvalid()) | |
| return StmtError(); | |
| return getSema().ObjC().FinishObjCForCollectionStmt(ForEachStmt.get(), | |
| Body); | |
| } | |
| /// Build a new C++ exception declaration. | |
| /// | |
| /// By default, performs semantic analysis to build the new decaration. | |
| /// Subclasses may override this routine to provide different behavior. | |
| VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl, | |
| TypeSourceInfo *Declarator, | |
| SourceLocation StartLoc, | |
| SourceLocation IdLoc, | |
| IdentifierInfo *Id) { | |
| VarDecl *Var = getSema().BuildExceptionDeclaration(nullptr, Declarator, | |
| StartLoc, IdLoc, Id); | |
| if (Var) | |
| getSema().CurContext->addDecl(Var); | |
| return Var; | |
| } | |
| /// Build a new C++ catch statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc, | |
| VarDecl *ExceptionDecl, | |
| Stmt *Handler) { | |
| return Owned(new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl, | |
| Handler)); | |
| } | |
| /// Build a new C++ try statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildCXXTryStmt(SourceLocation TryLoc, Stmt *TryBlock, | |
| ArrayRef<Stmt *> Handlers) { | |
| return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers); | |
| } | |
| /// Build a new C++0x range-based for statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildCXXForRangeStmt( | |
| SourceLocation ForLoc, SourceLocation CoawaitLoc, Stmt *Init, | |
| SourceLocation ColonLoc, Stmt *Range, Stmt *Begin, Stmt *End, Expr *Cond, | |
| Expr *Inc, Stmt *LoopVar, SourceLocation RParenLoc, | |
| ArrayRef<MaterializeTemporaryExpr *> LifetimeExtendTemps) { | |
| // If we've just learned that the range is actually an Objective-C | |
| // collection, treat this as an Objective-C fast enumeration loop. | |
| if (DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) { | |
| if (RangeStmt->isSingleDecl()) { | |
| if (VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) { | |
| if (RangeVar->isInvalidDecl()) | |
| return StmtError(); | |
| Expr *RangeExpr = RangeVar->getInit(); | |
| if (!RangeExpr->isTypeDependent() && | |
| RangeExpr->getType()->isObjCObjectPointerType()) { | |
| // FIXME: Support init-statements in Objective-C++20 ranged for | |
| // statement. | |
| if (Init) { | |
| return SemaRef.Diag(Init->getBeginLoc(), | |
| diag::err_objc_for_range_init_stmt) | |
| << Init->getSourceRange(); | |
| } | |
| return getSema().ObjC().ActOnObjCForCollectionStmt( | |
| ForLoc, LoopVar, RangeExpr, RParenLoc); | |
| } | |
| } | |
| } | |
| } | |
| return getSema().BuildCXXForRangeStmt( | |
| ForLoc, CoawaitLoc, Init, ColonLoc, Range, Begin, End, Cond, Inc, | |
| LoopVar, RParenLoc, Sema::BFRK_Rebuild, LifetimeExtendTemps); | |
| } | |
| /// Build a new C++0x range-based for statement. | |
| /// | |
| /// By default, performs semantic analysis to build the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult RebuildMSDependentExistsStmt(SourceLocation KeywordLoc, | |
| bool IsIfExists, | |
| NestedNameSpecifierLoc QualifierLoc, | |
| DeclarationNameInfo NameInfo, | |
| Stmt *Nested) { | |
| return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists, | |
| QualifierLoc, NameInfo, Nested); | |
| } | |
| /// Attach body to a C++0x range-based for statement. | |
| /// | |
| /// By default, performs semantic analysis to finish the new statement. | |
| /// Subclasses may override this routine to provide different behavior. | |
| StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body) { | |
| return getSema().FinishCXXForRangeStmt(ForRange, Body); | |
| } | |
| StmtResult RebuildSEHTryStmt(bool IsCXXTry, SourceLocation TryLoc, | |
| Stmt *TryBlock, Stmt *Handler) { | |
| return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler); | |
| } | |
| StmtResult RebuildSEHExceptStmt(SourceLocation Loc, Expr *FilterExpr, | |
| Stmt *Block) { | |
| return getSema().ActOnSEHExceptBlock(Loc, FilterExpr, Block); | |
| } | |
| StmtResult RebuildSEHFinallyStmt(SourceLocation Loc, Stmt *Block) { | |
| return SEHFinallyStmt::Create(getSema().getASTContext(), Loc, Block); | |
| } | |
| ExprResult RebuildSYCLUniqueStableNameExpr(SourceLocation OpLoc, | |
| SourceLocation LParen, | |
| SourceLocation RParen, | |
| TypeSourceInfo *TSI) { | |
| return getSema().SYCL().BuildUniqueStableNameExpr(OpLoc, LParen, RParen, | |
| TSI); | |
| } | |
| /// Build a new predefined expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildPredefinedExpr(SourceLocation Loc, PredefinedIdentKind IK) { | |
| return getSema().BuildPredefinedExpr(Loc, IK); | |
| } | |
| /// Build a new expression that references a declaration. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS, | |
| LookupResult &R, | |
| bool RequiresADL) { | |
| return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL); | |
| } | |
| /// Build a new expression that references a declaration. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildDeclRefExpr(NestedNameSpecifierLoc QualifierLoc, | |
| ValueDecl *VD, | |
| const DeclarationNameInfo &NameInfo, | |
| NamedDecl *Found, | |
| TemplateArgumentListInfo *TemplateArgs) { | |
| CXXScopeSpec SS; | |
| SS.Adopt(QualifierLoc); | |
| return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD, Found, | |
| TemplateArgs); | |
| } | |
| /// Build a new expression in parentheses. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildParenExpr(Expr *SubExpr, SourceLocation LParen, | |
| SourceLocation RParen) { | |
| return getSema().ActOnParenExpr(LParen, RParen, SubExpr); | |
| } | |
| /// Build a new pseudo-destructor expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXPseudoDestructorExpr(Expr *Base, | |
| SourceLocation OperatorLoc, | |
| bool isArrow, | |
| CXXScopeSpec &SS, | |
| TypeSourceInfo *ScopeType, | |
| SourceLocation CCLoc, | |
| SourceLocation TildeLoc, | |
| PseudoDestructorTypeStorage Destroyed); | |
| /// Build a new unary operator expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildUnaryOperator(SourceLocation OpLoc, | |
| UnaryOperatorKind Opc, | |
| Expr *SubExpr) { | |
| return getSema().BuildUnaryOp(/*Scope=*/nullptr, OpLoc, Opc, SubExpr); | |
| } | |
| /// Build a new builtin offsetof expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildOffsetOfExpr(SourceLocation OperatorLoc, | |
| TypeSourceInfo *Type, const Designation &Desig, | |
| SourceLocation RParenLoc) { | |
| return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Desig, RParenLoc); | |
| } | |
| /// Build a new sizeof, alignof or vec_step expression with a | |
| /// type argument. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildUnaryExprOrTypeTrait(TypeSourceInfo *TInfo, | |
| SourceLocation OpLoc, | |
| UnaryExprOrTypeTrait ExprKind, | |
| SourceRange R) { | |
| return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R); | |
| } | |
| /// Build a new sizeof, alignof or vec step expression with an | |
| /// expression argument. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildUnaryExprOrTypeTrait(Expr *SubExpr, SourceLocation OpLoc, | |
| UnaryExprOrTypeTrait ExprKind, | |
| SourceRange R) { | |
| ExprResult Result | |
| = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind); | |
| if (Result.isInvalid()) | |
| return ExprError(); | |
| return Result; | |
| } | |
| /// Build a new array subscript expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildArraySubscriptExpr(Expr *LHS, | |
| SourceLocation LBracketLoc, | |
| Expr *RHS, | |
| SourceLocation RBracketLoc) { | |
| return getSema().ActOnArraySubscriptExpr(/*Scope=*/nullptr, LHS, | |
| LBracketLoc, RHS, | |
| RBracketLoc); | |
| } | |
| /// Build a new matrix single subscript expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildMatrixSingleSubscriptExpr(Expr *Base, Expr *RowIdx, | |
| SourceLocation RBracketLoc) { | |
| return getSema().CreateBuiltinMatrixSingleSubscriptExpr(Base, RowIdx, | |
| RBracketLoc); | |
| } | |
| /// Build a new matrix subscript expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildMatrixSubscriptExpr(Expr *Base, Expr *RowIdx, | |
| Expr *ColumnIdx, | |
| SourceLocation RBracketLoc) { | |
| return getSema().CreateBuiltinMatrixSubscriptExpr(Base, RowIdx, ColumnIdx, | |
| RBracketLoc); | |
| } | |
| /// Build a new array section expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildArraySectionExpr(bool IsOMPArraySection, Expr *Base, | |
| SourceLocation LBracketLoc, | |
| Expr *LowerBound, | |
| SourceLocation ColonLocFirst, | |
| SourceLocation ColonLocSecond, | |
| Expr *Length, Expr *Stride, | |
| SourceLocation RBracketLoc) { | |
| if (IsOMPArraySection) | |
| return getSema().OpenMP().ActOnOMPArraySectionExpr( | |
| Base, LBracketLoc, LowerBound, ColonLocFirst, ColonLocSecond, Length, | |
| Stride, RBracketLoc); | |
| assert(Stride == nullptr && !ColonLocSecond.isValid() && | |
| "Stride/second colon not allowed for OpenACC"); | |
| return getSema().OpenACC().ActOnArraySectionExpr( | |
| Base, LBracketLoc, LowerBound, ColonLocFirst, Length, RBracketLoc); | |
| } | |
| /// Build a new array shaping expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc, | |
| SourceLocation RParenLoc, | |
| ArrayRef<Expr *> Dims, | |
| ArrayRef<SourceRange> BracketsRanges) { | |
| return getSema().OpenMP().ActOnOMPArrayShapingExpr( | |
| Base, LParenLoc, RParenLoc, Dims, BracketsRanges); | |
| } | |
| /// Build a new iterator expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult | |
| RebuildOMPIteratorExpr(SourceLocation IteratorKwLoc, SourceLocation LLoc, | |
| SourceLocation RLoc, | |
| ArrayRef<SemaOpenMP::OMPIteratorData> Data) { | |
| return getSema().OpenMP().ActOnOMPIteratorExpr( | |
| /*Scope=*/nullptr, IteratorKwLoc, LLoc, RLoc, Data); | |
| } | |
| /// Build a new call expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc, | |
| MultiExprArg Args, | |
| SourceLocation RParenLoc, | |
| Expr *ExecConfig = nullptr) { | |
| return getSema().ActOnCallExpr( | |
| /*Scope=*/nullptr, Callee, LParenLoc, Args, RParenLoc, ExecConfig); | |
| } | |
| ExprResult RebuildCxxSubscriptExpr(Expr *Callee, SourceLocation LParenLoc, | |
| MultiExprArg Args, | |
| SourceLocation RParenLoc) { | |
| return getSema().ActOnArraySubscriptExpr( | |
| /*Scope=*/nullptr, Callee, LParenLoc, Args, RParenLoc); | |
| } | |
| /// Build a new member access expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildMemberExpr(Expr *Base, SourceLocation OpLoc, | |
| bool isArrow, | |
| NestedNameSpecifierLoc QualifierLoc, | |
| SourceLocation TemplateKWLoc, | |
| const DeclarationNameInfo &MemberNameInfo, | |
| ValueDecl *Member, | |
| NamedDecl *FoundDecl, | |
| const TemplateArgumentListInfo *ExplicitTemplateArgs, | |
| NamedDecl *FirstQualifierInScope) { | |
| ExprResult BaseResult = getSema().PerformMemberExprBaseConversion(Base, | |
| isArrow); | |
| if (!Member->getDeclName()) { | |
| // We have a reference to an unnamed field. This is always the | |
| // base of an anonymous struct/union member access, i.e. the | |
| // field is always of record type. | |
| assert(Member->getType()->isRecordType() && | |
| "unnamed member not of record type?"); | |
| BaseResult = | |
| getSema().PerformObjectMemberConversion(BaseResult.get(), | |
| QualifierLoc.getNestedNameSpecifier(), | |
| FoundDecl, Member); | |
| if (BaseResult.isInvalid()) | |
| return ExprError(); | |
| Base = BaseResult.get(); | |
| // `TranformMaterializeTemporaryExpr()` removes materialized temporaries | |
| // from the AST, so we need to re-insert them if needed (since | |
| // `BuildFieldRefereneExpr()` doesn't do this). | |
| if (!isArrow && Base->isPRValue()) { | |
| BaseResult = getSema().TemporaryMaterializationConversion(Base); | |
| if (BaseResult.isInvalid()) | |
| return ExprError(); | |
| Base = BaseResult.get(); | |
| } | |
| CXXScopeSpec EmptySS; | |
| return getSema().BuildFieldReferenceExpr( | |
| Base, isArrow, OpLoc, EmptySS, cast<FieldDecl>(Member), | |
| DeclAccessPair::make(FoundDecl, FoundDecl->getAccess()), | |
| MemberNameInfo); | |
| } | |
| CXXScopeSpec SS; | |
| SS.Adopt(QualifierLoc); | |
| Base = BaseResult.get(); | |
| if (Base->containsErrors()) | |
| return ExprError(); | |
| QualType BaseType = Base->getType(); | |
| if (isArrow && !BaseType->isPointerType()) | |
| return ExprError(); | |
| // FIXME: this involves duplicating earlier analysis in a lot of | |
| // cases; we should avoid this when possible. | |
| LookupResult R(getSema(), MemberNameInfo, Sema::LookupMemberName); | |
| R.addDecl(FoundDecl); | |
| R.resolveKind(); | |
| if (getSema().isUnevaluatedContext() && Base->isImplicitCXXThis() && | |
| isa<FieldDecl, IndirectFieldDecl, MSPropertyDecl>(Member)) { | |
| if (auto *ThisClass = cast<CXXThisExpr>(Base) | |
| ->getType() | |
| ->getPointeeType() | |
| ->getAsCXXRecordDecl()) { | |
| auto *Class = cast<CXXRecordDecl>(Member->getDeclContext()); | |
| // In unevaluated contexts, an expression supposed to be a member access | |
| // might reference a member in an unrelated class. | |
| if (!ThisClass->Equals(Class) && !ThisClass->isDerivedFrom(Class)) | |
| return getSema().BuildDeclRefExpr(Member, Member->getType(), | |
| VK_LValue, Member->getLocation()); | |
| } | |
| } | |
| return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow, | |
| SS, TemplateKWLoc, | |
| FirstQualifierInScope, | |
| R, ExplicitTemplateArgs, | |
| /*S*/nullptr); | |
| } | |
| /// Build a new binary operator expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildBinaryOperator(SourceLocation OpLoc, BinaryOperatorKind Opc, | |
| Expr *LHS, Expr *RHS, | |
| bool ForFoldExpression = false) { | |
| return getSema().BuildBinOp(/*Scope=*/nullptr, OpLoc, Opc, LHS, RHS, | |
| ForFoldExpression); | |
| } | |
| /// Build a new rewritten operator expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXRewrittenBinaryOperator( | |
| SourceLocation OpLoc, BinaryOperatorKind Opcode, | |
| const UnresolvedSetImpl &UnqualLookups, Expr *LHS, Expr *RHS) { | |
| return getSema().CreateOverloadedBinOp(OpLoc, Opcode, UnqualLookups, LHS, | |
| RHS, /*RequiresADL*/false); | |
| } | |
| /// Build a new conditional operator expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildConditionalOperator(Expr *Cond, | |
| SourceLocation QuestionLoc, | |
| Expr *LHS, | |
| SourceLocation ColonLoc, | |
| Expr *RHS) { | |
| return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond, | |
| LHS, RHS); | |
| } | |
| /// Build a new C-style cast expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCStyleCastExpr(SourceLocation LParenLoc, | |
| TypeSourceInfo *TInfo, | |
| SourceLocation RParenLoc, | |
| Expr *SubExpr) { | |
| return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, | |
| SubExpr); | |
| } | |
| /// Build a new compound literal expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc, | |
| TypeSourceInfo *TInfo, | |
| SourceLocation RParenLoc, | |
| Expr *Init) { | |
| return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, | |
| Init); | |
| } | |
| /// Build a new extended vector or matrix element access expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildExtVectorOrMatrixElementExpr(Expr *Base, | |
| SourceLocation OpLoc, | |
| bool IsArrow, | |
| SourceLocation AccessorLoc, | |
| IdentifierInfo &Accessor) { | |
| CXXScopeSpec SS; | |
| DeclarationNameInfo NameInfo(&Accessor, AccessorLoc); | |
| return getSema().BuildMemberReferenceExpr( | |
| Base, Base->getType(), OpLoc, IsArrow, SS, SourceLocation(), | |
| /*FirstQualifierInScope*/ nullptr, NameInfo, | |
| /* TemplateArgs */ nullptr, | |
| /*S*/ nullptr); | |
| } | |
| /// Build a new initializer list expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildInitList(SourceLocation LBraceLoc, MultiExprArg Inits, | |
| SourceLocation RBraceLoc, bool IsExplicit) { | |
| return SemaRef.BuildInitList(LBraceLoc, Inits, RBraceLoc, IsExplicit); | |
| } | |
| /// Build a new designated initializer expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildDesignatedInitExpr(Designation &Desig, | |
| MultiExprArg ArrayExprs, | |
| SourceLocation EqualOrColonLoc, | |
| bool GNUSyntax, | |
| Expr *Init) { | |
| ExprResult Result | |
| = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax, | |
| Init); | |
| if (Result.isInvalid()) | |
| return ExprError(); | |
| return Result; | |
| } | |
| /// Build a new value-initialized expression. | |
| /// | |
| /// By default, builds the implicit value initialization without performing | |
| /// any semantic analysis. Subclasses may override this routine to provide | |
| /// different behavior. | |
| ExprResult RebuildImplicitValueInitExpr(QualType T) { | |
| return new (SemaRef.Context) ImplicitValueInitExpr(T); | |
| } | |
| /// Build a new \c va_arg expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc, | |
| Expr *SubExpr, TypeSourceInfo *TInfo, | |
| SourceLocation RParenLoc) { | |
| return getSema().BuildVAArgExpr(BuiltinLoc, | |
| SubExpr, TInfo, | |
| RParenLoc); | |
| } | |
| /// Build a new expression list in parentheses. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildParenListExpr(SourceLocation LParenLoc, | |
| MultiExprArg SubExprs, | |
| SourceLocation RParenLoc) { | |
| return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs); | |
| } | |
| ExprResult RebuildCXXParenListInitExpr(ArrayRef<Expr *> Args, QualType T, | |
| unsigned NumUserSpecifiedExprs, | |
| SourceLocation InitLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation RParenLoc) { | |
| return getSema().ActOnCXXParenListInitExpr(Args, T, NumUserSpecifiedExprs, | |
| InitLoc, LParenLoc, RParenLoc); | |
| } | |
| /// Build a new address-of-label expression. | |
| /// | |
| /// By default, performs semantic analysis, using the name of the label | |
| /// rather than attempting to map the label statement itself. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc, | |
| SourceLocation LabelLoc, LabelDecl *Label) { | |
| return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label); | |
| } | |
| /// Build a new GNU statement expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildStmtExpr(SourceLocation LParenLoc, Stmt *SubStmt, | |
| SourceLocation RParenLoc, unsigned TemplateDepth) { | |
| return getSema().BuildStmtExpr(LParenLoc, SubStmt, RParenLoc, | |
| TemplateDepth); | |
| } | |
| /// Build a new __builtin_choose_expr expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildChooseExpr(SourceLocation BuiltinLoc, | |
| Expr *Cond, Expr *LHS, Expr *RHS, | |
| SourceLocation RParenLoc) { | |
| return SemaRef.ActOnChooseExpr(BuiltinLoc, | |
| Cond, LHS, RHS, | |
| RParenLoc); | |
| } | |
| /// Build a new generic selection expression with an expression predicate. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildGenericSelectionExpr(SourceLocation KeyLoc, | |
| SourceLocation DefaultLoc, | |
| SourceLocation RParenLoc, | |
| Expr *ControllingExpr, | |
| ArrayRef<TypeSourceInfo *> Types, | |
| ArrayRef<Expr *> Exprs) { | |
| return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc, | |
| /*PredicateIsExpr=*/true, | |
| ControllingExpr, Types, Exprs); | |
| } | |
| /// Build a new generic selection expression with a type predicate. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildGenericSelectionExpr(SourceLocation KeyLoc, | |
| SourceLocation DefaultLoc, | |
| SourceLocation RParenLoc, | |
| TypeSourceInfo *ControllingType, | |
| ArrayRef<TypeSourceInfo *> Types, | |
| ArrayRef<Expr *> Exprs) { | |
| return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc, | |
| /*PredicateIsExpr=*/false, | |
| ControllingType, Types, Exprs); | |
| } | |
| /// Build a new overloaded operator call expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// The semantic analysis provides the behavior of template instantiation, | |
| /// copying with transformations that turn what looks like an overloaded | |
| /// operator call into a use of a builtin operator, performing | |
| /// argument-dependent lookup, etc. Subclasses may override this routine to | |
| /// provide different behavior. | |
| ExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, | |
| SourceLocation OpLoc, | |
| SourceLocation CalleeLoc, | |
| bool RequiresADL, | |
| const UnresolvedSetImpl &Functions, | |
| Expr *First, Expr *Second); | |
| /// Build a new C++ "named" cast expression, such as static_cast or | |
| /// reinterpret_cast. | |
| /// | |
| /// By default, this routine dispatches to one of the more-specific routines | |
| /// for a particular named case, e.g., RebuildCXXStaticCastExpr(). | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc, | |
| Stmt::StmtClass Class, | |
| SourceLocation LAngleLoc, | |
| TypeSourceInfo *TInfo, | |
| SourceLocation RAngleLoc, | |
| SourceLocation LParenLoc, | |
| Expr *SubExpr, | |
| SourceLocation RParenLoc) { | |
| switch (Class) { | |
| case Stmt::CXXStaticCastExprClass: | |
| return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo, | |
| RAngleLoc, LParenLoc, | |
| SubExpr, RParenLoc); | |
| case Stmt::CXXDynamicCastExprClass: | |
| return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo, | |
| RAngleLoc, LParenLoc, | |
| SubExpr, RParenLoc); | |
| case Stmt::CXXReinterpretCastExprClass: | |
| return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo, | |
| RAngleLoc, LParenLoc, | |
| SubExpr, | |
| RParenLoc); | |
| case Stmt::CXXConstCastExprClass: | |
| return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo, | |
| RAngleLoc, LParenLoc, | |
| SubExpr, RParenLoc); | |
| case Stmt::CXXAddrspaceCastExprClass: | |
| return getDerived().RebuildCXXAddrspaceCastExpr( | |
| OpLoc, LAngleLoc, TInfo, RAngleLoc, LParenLoc, SubExpr, RParenLoc); | |
| default: | |
| llvm_unreachable("Invalid C++ named cast"); | |
| } | |
| } | |
| /// Build a new C++ static_cast expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc, | |
| SourceLocation LAngleLoc, | |
| TypeSourceInfo *TInfo, | |
| SourceLocation RAngleLoc, | |
| SourceLocation LParenLoc, | |
| Expr *SubExpr, | |
| SourceLocation RParenLoc) { | |
| return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast, | |
| TInfo, SubExpr, | |
| SourceRange(LAngleLoc, RAngleLoc), | |
| SourceRange(LParenLoc, RParenLoc)); | |
| } | |
| /// Build a new C++ dynamic_cast expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc, | |
| SourceLocation LAngleLoc, | |
| TypeSourceInfo *TInfo, | |
| SourceLocation RAngleLoc, | |
| SourceLocation LParenLoc, | |
| Expr *SubExpr, | |
| SourceLocation RParenLoc) { | |
| return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast, | |
| TInfo, SubExpr, | |
| SourceRange(LAngleLoc, RAngleLoc), | |
| SourceRange(LParenLoc, RParenLoc)); | |
| } | |
| /// Build a new C++ reinterpret_cast expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc, | |
| SourceLocation LAngleLoc, | |
| TypeSourceInfo *TInfo, | |
| SourceLocation RAngleLoc, | |
| SourceLocation LParenLoc, | |
| Expr *SubExpr, | |
| SourceLocation RParenLoc) { | |
| return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast, | |
| TInfo, SubExpr, | |
| SourceRange(LAngleLoc, RAngleLoc), | |
| SourceRange(LParenLoc, RParenLoc)); | |
| } | |
| /// Build a new C++ const_cast expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc, | |
| SourceLocation LAngleLoc, | |
| TypeSourceInfo *TInfo, | |
| SourceLocation RAngleLoc, | |
| SourceLocation LParenLoc, | |
| Expr *SubExpr, | |
| SourceLocation RParenLoc) { | |
| return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast, | |
| TInfo, SubExpr, | |
| SourceRange(LAngleLoc, RAngleLoc), | |
| SourceRange(LParenLoc, RParenLoc)); | |
| } | |
| ExprResult | |
| RebuildCXXAddrspaceCastExpr(SourceLocation OpLoc, SourceLocation LAngleLoc, | |
| TypeSourceInfo *TInfo, SourceLocation RAngleLoc, | |
| SourceLocation LParenLoc, Expr *SubExpr, | |
| SourceLocation RParenLoc) { | |
| return getSema().BuildCXXNamedCast( | |
| OpLoc, tok::kw_addrspace_cast, TInfo, SubExpr, | |
| SourceRange(LAngleLoc, RAngleLoc), SourceRange(LParenLoc, RParenLoc)); | |
| } | |
| /// Build a new C++ functional-style cast expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, | |
| SourceLocation LParenLoc, | |
| Expr *Sub, | |
| SourceLocation RParenLoc, | |
| bool ListInitialization) { | |
| // If Sub is a ParenListExpr, then Sub is the syntatic form of a | |
| // CXXParenListInitExpr. Pass its expanded arguments so that the | |
| // CXXParenListInitExpr can be rebuilt. | |
| if (auto *PLE = dyn_cast<ParenListExpr>(Sub)) | |
| return getSema().BuildCXXTypeConstructExpr( | |
| TInfo, LParenLoc, MultiExprArg(PLE->getExprs(), PLE->getNumExprs()), | |
| RParenLoc, ListInitialization); | |
| if (auto *PLE = dyn_cast<CXXParenListInitExpr>(Sub)) | |
| return getSema().BuildCXXTypeConstructExpr( | |
| TInfo, LParenLoc, PLE->getUserSpecifiedInitExprs(), RParenLoc, | |
| ListInitialization); | |
| return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc, | |
| MultiExprArg(&Sub, 1), RParenLoc, | |
| ListInitialization); | |
| } | |
| /// Build a new C++ __builtin_bit_cast expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildBuiltinBitCastExpr(SourceLocation KWLoc, | |
| TypeSourceInfo *TSI, Expr *Sub, | |
| SourceLocation RParenLoc) { | |
| return getSema().BuildBuiltinBitCastExpr(KWLoc, TSI, Sub, RParenLoc); | |
| } | |
| /// Build a new C++ typeid(type) expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType, | |
| SourceLocation TypeidLoc, | |
| TypeSourceInfo *Operand, | |
| SourceLocation RParenLoc) { | |
| return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand, | |
| RParenLoc); | |
| } | |
| /// Build a new C++ typeid(expr) expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType, | |
| SourceLocation TypeidLoc, | |
| Expr *Operand, | |
| SourceLocation RParenLoc) { | |
| return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand, | |
| RParenLoc); | |
| } | |
| /// Build a new C++ __uuidof(type) expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXUuidofExpr(QualType Type, SourceLocation TypeidLoc, | |
| TypeSourceInfo *Operand, | |
| SourceLocation RParenLoc) { | |
| return getSema().BuildCXXUuidof(Type, TypeidLoc, Operand, RParenLoc); | |
| } | |
| /// Build a new C++ __uuidof(expr) expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXUuidofExpr(QualType Type, SourceLocation TypeidLoc, | |
| Expr *Operand, SourceLocation RParenLoc) { | |
| return getSema().BuildCXXUuidof(Type, TypeidLoc, Operand, RParenLoc); | |
| } | |
| /// Build a new C++ "this" expression. | |
| /// | |
| /// By default, performs semantic analysis to build a new "this" expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXThisExpr(SourceLocation ThisLoc, | |
| QualType ThisType, | |
| bool isImplicit) { | |
| if (getSema().CheckCXXThisType(ThisLoc, ThisType)) | |
| return ExprError(); | |
| return getSema().BuildCXXThisExpr(ThisLoc, ThisType, isImplicit); | |
| } | |
| /// Build a new C++ throw expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, Expr *Sub, | |
| bool IsThrownVariableInScope) { | |
| return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope); | |
| } | |
| /// Build a new C++ default-argument expression. | |
| /// | |
| /// By default, builds a new default-argument expression, which does not | |
| /// require any semantic analysis. Subclasses may override this routine to | |
| /// provide different behavior. | |
| ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc, ParmVarDecl *Param, | |
| Expr *RewrittenExpr) { | |
| return CXXDefaultArgExpr::Create(getSema().Context, Loc, Param, | |
| RewrittenExpr, getSema().CurContext); | |
| } | |
| /// Build a new C++11 default-initialization expression. | |
| /// | |
| /// By default, builds a new default field initialization expression, which | |
| /// does not require any semantic analysis. Subclasses may override this | |
| /// routine to provide different behavior. | |
| ExprResult RebuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field, | |
| Expr *RewrittenInit) { | |
| return CXXDefaultInitExpr::Create(getSema().Context, Loc, Field, | |
| getSema().CurContext, RewrittenInit); | |
| } | |
| /// Build a new C++ zero-initialization expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXScalarValueInitExpr(TypeSourceInfo *TSInfo, | |
| SourceLocation LParenLoc, | |
| SourceLocation RParenLoc) { | |
| return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, {}, RParenLoc, | |
| /*ListInitialization=*/false); | |
| } | |
| /// Build a new C++ "new" expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXNewExpr(SourceLocation StartLoc, bool UseGlobal, | |
| SourceLocation PlacementLParen, | |
| MultiExprArg PlacementArgs, | |
| SourceLocation PlacementRParen, | |
| SourceRange TypeIdParens, QualType AllocatedType, | |
| TypeSourceInfo *AllocatedTypeInfo, | |
| std::optional<Expr *> ArraySize, | |
| SourceRange DirectInitRange, Expr *Initializer) { | |
| return getSema().BuildCXXNew(StartLoc, UseGlobal, | |
| PlacementLParen, | |
| PlacementArgs, | |
| PlacementRParen, | |
| TypeIdParens, | |
| AllocatedType, | |
| AllocatedTypeInfo, | |
| ArraySize, | |
| DirectInitRange, | |
| Initializer); | |
| } | |
| /// Build a new C++ "delete" expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc, | |
| bool IsGlobalDelete, | |
| bool IsArrayForm, | |
| Expr *Operand) { | |
| return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm, | |
| Operand); | |
| } | |
| /// Build a new type trait expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildTypeTrait(TypeTrait Trait, | |
| SourceLocation StartLoc, | |
| ArrayRef<TypeSourceInfo *> Args, | |
| SourceLocation RParenLoc) { | |
| return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc); | |
| } | |
| /// Build a new array type trait expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildArrayTypeTrait(ArrayTypeTrait Trait, | |
| SourceLocation StartLoc, | |
| TypeSourceInfo *TSInfo, | |
| Expr *DimExpr, | |
| SourceLocation RParenLoc) { | |
| return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc); | |
| } | |
| /// Build a new expression trait expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildExpressionTrait(ExpressionTrait Trait, | |
| SourceLocation StartLoc, | |
| Expr *Queried, | |
| SourceLocation RParenLoc) { | |
| return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc); | |
| } | |
| /// Build a new (previously unresolved) declaration reference | |
| /// expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildDependentScopeDeclRefExpr( | |
| NestedNameSpecifierLoc QualifierLoc, | |
| SourceLocation TemplateKWLoc, | |
| const DeclarationNameInfo &NameInfo, | |
| const TemplateArgumentListInfo *TemplateArgs, | |
| bool IsAddressOfOperand, | |
| TypeSourceInfo **RecoveryTSI) { | |
| CXXScopeSpec SS; | |
| SS.Adopt(QualifierLoc); | |
| if (TemplateArgs || TemplateKWLoc.isValid()) | |
| return getSema().BuildQualifiedTemplateIdExpr( | |
| SS, TemplateKWLoc, NameInfo, TemplateArgs, IsAddressOfOperand); | |
| return getSema().BuildQualifiedDeclarationNameExpr( | |
| SS, NameInfo, IsAddressOfOperand, RecoveryTSI); | |
| } | |
| /// Build a new template-id expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildTemplateIdExpr(const CXXScopeSpec &SS, | |
| SourceLocation TemplateKWLoc, | |
| LookupResult &R, | |
| bool RequiresADL, | |
| const TemplateArgumentListInfo *TemplateArgs) { | |
| return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL, | |
| TemplateArgs); | |
| } | |
| /// Build a new object-construction expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXConstructExpr( | |
| QualType T, SourceLocation Loc, CXXConstructorDecl *Constructor, | |
| bool IsElidable, MultiExprArg Args, bool HadMultipleCandidates, | |
| bool ListInitialization, bool StdInitListInitialization, | |
| bool RequiresZeroInit, CXXConstructionKind ConstructKind, | |
| SourceRange ParenRange) { | |
| // Reconstruct the constructor we originally found, which might be | |
| // different if this is a call to an inherited constructor. | |
| CXXConstructorDecl *FoundCtor = Constructor; | |
| if (Constructor->isInheritingConstructor()) | |
| FoundCtor = Constructor->getInheritedConstructor().getConstructor(); | |
| SmallVector<Expr *, 8> ConvertedArgs; | |
| if (getSema().CompleteConstructorCall(FoundCtor, T, Args, Loc, | |
| ConvertedArgs)) | |
| return ExprError(); | |
| return getSema().BuildCXXConstructExpr(Loc, T, Constructor, | |
| IsElidable, | |
| ConvertedArgs, | |
| HadMultipleCandidates, | |
| ListInitialization, | |
| StdInitListInitialization, | |
| RequiresZeroInit, ConstructKind, | |
| ParenRange); | |
| } | |
| /// Build a new implicit construction via inherited constructor | |
| /// expression. | |
| ExprResult RebuildCXXInheritedCtorInitExpr(QualType T, SourceLocation Loc, | |
| CXXConstructorDecl *Constructor, | |
| bool ConstructsVBase, | |
| bool InheritedFromVBase) { | |
| return new (getSema().Context) CXXInheritedCtorInitExpr( | |
| Loc, T, Constructor, ConstructsVBase, InheritedFromVBase); | |
| } | |
| /// Build a new object-construction expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXTemporaryObjectExpr(TypeSourceInfo *TSInfo, | |
| SourceLocation LParenOrBraceLoc, | |
| MultiExprArg Args, | |
| SourceLocation RParenOrBraceLoc, | |
| bool ListInitialization) { | |
| return getSema().BuildCXXTypeConstructExpr( | |
| TSInfo, LParenOrBraceLoc, Args, RParenOrBraceLoc, ListInitialization); | |
| } | |
| /// Build a new object-construction expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXUnresolvedConstructExpr(TypeSourceInfo *TSInfo, | |
| SourceLocation LParenLoc, | |
| MultiExprArg Args, | |
| SourceLocation RParenLoc, | |
| bool ListInitialization) { | |
| return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, Args, | |
| RParenLoc, ListInitialization); | |
| } | |
| /// Build a new member reference expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXDependentScopeMemberExpr(Expr *BaseE, | |
| QualType BaseType, | |
| bool IsArrow, | |
| SourceLocation OperatorLoc, | |
| NestedNameSpecifierLoc QualifierLoc, | |
| SourceLocation TemplateKWLoc, | |
| NamedDecl *FirstQualifierInScope, | |
| const DeclarationNameInfo &MemberNameInfo, | |
| const TemplateArgumentListInfo *TemplateArgs) { | |
| CXXScopeSpec SS; | |
| SS.Adopt(QualifierLoc); | |
| return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType, | |
| OperatorLoc, IsArrow, | |
| SS, TemplateKWLoc, | |
| FirstQualifierInScope, | |
| MemberNameInfo, | |
| TemplateArgs, /*S*/nullptr); | |
| } | |
| /// Build a new member reference expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildUnresolvedMemberExpr(Expr *BaseE, QualType BaseType, | |
| SourceLocation OperatorLoc, | |
| bool IsArrow, | |
| NestedNameSpecifierLoc QualifierLoc, | |
| SourceLocation TemplateKWLoc, | |
| NamedDecl *FirstQualifierInScope, | |
| LookupResult &R, | |
| const TemplateArgumentListInfo *TemplateArgs) { | |
| CXXScopeSpec SS; | |
| SS.Adopt(QualifierLoc); | |
| return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType, | |
| OperatorLoc, IsArrow, | |
| SS, TemplateKWLoc, | |
| FirstQualifierInScope, | |
| R, TemplateArgs, /*S*/nullptr); | |
| } | |
| /// Build a new noexcept expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildCXXNoexceptExpr(SourceRange Range, Expr *Arg) { | |
| return SemaRef.BuildCXXNoexceptExpr(Range.getBegin(), Arg, Range.getEnd()); | |
| } | |
| UnsignedOrNone | |
| ComputeSizeOfPackExprWithoutSubstitution(ArrayRef<TemplateArgument> PackArgs); | |
| /// Build a new expression to compute the length of a parameter pack. | |
| ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc, NamedDecl *Pack, | |
| SourceLocation PackLoc, | |
| SourceLocation RParenLoc, | |
| UnsignedOrNone Length, | |
| ArrayRef<TemplateArgument> PartialArgs) { | |
| return SizeOfPackExpr::Create(SemaRef.Context, OperatorLoc, Pack, PackLoc, | |
| RParenLoc, Length, PartialArgs); | |
| } | |
| ExprResult RebuildPackIndexingExpr(SourceLocation EllipsisLoc, | |
| SourceLocation RSquareLoc, | |
| Expr *PackIdExpression, Expr *IndexExpr, | |
| ArrayRef<Expr *> ExpandedExprs, | |
| bool FullySubstituted = false) { | |
| return getSema().BuildPackIndexingExpr(PackIdExpression, EllipsisLoc, | |
| IndexExpr, RSquareLoc, ExpandedExprs, | |
| FullySubstituted); | |
| } | |
| /// Build a new expression representing a call to a source location | |
| /// builtin. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildSourceLocExpr(SourceLocIdentKind Kind, QualType ResultTy, | |
| SourceLocation BuiltinLoc, | |
| SourceLocation RPLoc, | |
| DeclContext *ParentContext) { | |
| return getSema().BuildSourceLocExpr(Kind, ResultTy, BuiltinLoc, RPLoc, | |
| ParentContext); | |
| } | |
| ExprResult RebuildConceptSpecializationExpr(NestedNameSpecifierLoc NNS, | |
| SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, | |
| NamedDecl *FoundDecl, ConceptDecl *NamedConcept, | |
| TemplateArgumentListInfo *TALI) { | |
| CXXScopeSpec SS; | |
| SS.Adopt(NNS); | |
| ExprResult Result = getSema().CheckConceptTemplateId(SS, TemplateKWLoc, | |
| ConceptNameInfo, | |
| FoundDecl, | |
| NamedConcept, TALI); | |
| if (Result.isInvalid()) | |
| return ExprError(); | |
| return Result; | |
| } | |
| /// \brief Build a new requires expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildRequiresExpr(SourceLocation RequiresKWLoc, | |
| RequiresExprBodyDecl *Body, | |
| SourceLocation LParenLoc, | |
| ArrayRef<ParmVarDecl *> LocalParameters, | |
| SourceLocation RParenLoc, | |
| ArrayRef<concepts::Requirement *> Requirements, | |
| SourceLocation ClosingBraceLoc) { | |
| return RequiresExpr::Create(SemaRef.Context, RequiresKWLoc, Body, LParenLoc, | |
| LocalParameters, RParenLoc, Requirements, | |
| ClosingBraceLoc); | |
| } | |
| concepts::TypeRequirement * | |
| RebuildTypeRequirement( | |
| concepts::Requirement::SubstitutionDiagnostic *SubstDiag) { | |
| return SemaRef.BuildTypeRequirement(SubstDiag); | |
| } | |
| concepts::TypeRequirement *RebuildTypeRequirement(TypeSourceInfo *T) { | |
| return SemaRef.BuildTypeRequirement(T); | |
| } | |
| concepts::ExprRequirement * | |
| RebuildExprRequirement( | |
| concepts::Requirement::SubstitutionDiagnostic *SubstDiag, bool IsSimple, | |
| SourceLocation NoexceptLoc, | |
| concepts::ExprRequirement::ReturnTypeRequirement Ret) { | |
| return SemaRef.BuildExprRequirement(SubstDiag, IsSimple, NoexceptLoc, | |
| std::move(Ret)); | |
| } | |
| concepts::ExprRequirement * | |
| RebuildExprRequirement(Expr *E, bool IsSimple, SourceLocation NoexceptLoc, | |
| concepts::ExprRequirement::ReturnTypeRequirement Ret) { | |
| return SemaRef.BuildExprRequirement(E, IsSimple, NoexceptLoc, | |
| std::move(Ret)); | |
| } | |
| concepts::NestedRequirement * | |
| RebuildNestedRequirement(StringRef InvalidConstraintEntity, | |
| const ASTConstraintSatisfaction &Satisfaction) { | |
| return SemaRef.BuildNestedRequirement(InvalidConstraintEntity, | |
| Satisfaction); | |
| } | |
| concepts::NestedRequirement *RebuildNestedRequirement(Expr *Constraint) { | |
| return SemaRef.BuildNestedRequirement(Constraint); | |
| } | |
| /// \brief Build a new Objective-C boxed expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) { | |
| return getSema().ObjC().BuildObjCBoxedExpr(SR, ValueExpr); | |
| } | |
| /// Build a new Objective-C array literal. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildObjCArrayLiteral(SourceRange Range, | |
| Expr **Elements, unsigned NumElements) { | |
| return getSema().ObjC().BuildObjCArrayLiteral( | |
| Range, MultiExprArg(Elements, NumElements)); | |
| } | |
| ExprResult RebuildObjCSubscriptRefExpr(SourceLocation RB, | |
| Expr *Base, Expr *Key, | |
| ObjCMethodDecl *getterMethod, | |
| ObjCMethodDecl *setterMethod) { | |
| return getSema().ObjC().BuildObjCSubscriptExpression( | |
| RB, Base, Key, getterMethod, setterMethod); | |
| } | |
| /// Build a new Objective-C dictionary literal. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildObjCDictionaryLiteral(SourceRange Range, | |
| MutableArrayRef<ObjCDictionaryElement> Elements) { | |
| return getSema().ObjC().BuildObjCDictionaryLiteral(Range, Elements); | |
| } | |
| /// Build a new Objective-C \@encode expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc, | |
| TypeSourceInfo *EncodeTypeInfo, | |
| SourceLocation RParenLoc) { | |
| return SemaRef.ObjC().BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo, | |
| RParenLoc); | |
| } | |
| /// Build a new Objective-C class message. | |
| ExprResult RebuildObjCMessageExpr(TypeSourceInfo *ReceiverTypeInfo, | |
| Selector Sel, | |
| ArrayRef<SourceLocation> SelectorLocs, | |
| ObjCMethodDecl *Method, | |
| SourceLocation LBracLoc, | |
| MultiExprArg Args, | |
| SourceLocation RBracLoc) { | |
| return SemaRef.ObjC().BuildClassMessage( | |
| ReceiverTypeInfo, ReceiverTypeInfo->getType(), | |
| /*SuperLoc=*/SourceLocation(), Sel, Method, LBracLoc, SelectorLocs, | |
| RBracLoc, Args); | |
| } | |
| /// Build a new Objective-C instance message. | |
| ExprResult RebuildObjCMessageExpr(Expr *Receiver, | |
| Selector Sel, | |
| ArrayRef<SourceLocation> SelectorLocs, | |
| ObjCMethodDecl *Method, | |
| SourceLocation LBracLoc, | |
| MultiExprArg Args, | |
| SourceLocation RBracLoc) { | |
| return SemaRef.ObjC().BuildInstanceMessage(Receiver, Receiver->getType(), | |
| /*SuperLoc=*/SourceLocation(), | |
| Sel, Method, LBracLoc, | |
| SelectorLocs, RBracLoc, Args); | |
| } | |
| /// Build a new Objective-C instance/class message to 'super'. | |
| ExprResult RebuildObjCMessageExpr(SourceLocation SuperLoc, | |
| Selector Sel, | |
| ArrayRef<SourceLocation> SelectorLocs, | |
| QualType SuperType, | |
| ObjCMethodDecl *Method, | |
| SourceLocation LBracLoc, | |
| MultiExprArg Args, | |
| SourceLocation RBracLoc) { | |
| return Method->isInstanceMethod() | |
| ? SemaRef.ObjC().BuildInstanceMessage( | |
| nullptr, SuperType, SuperLoc, Sel, Method, LBracLoc, | |
| SelectorLocs, RBracLoc, Args) | |
| : SemaRef.ObjC().BuildClassMessage(nullptr, SuperType, SuperLoc, | |
| Sel, Method, LBracLoc, | |
| SelectorLocs, RBracLoc, Args); | |
| } | |
| /// Build a new Objective-C ivar reference expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildObjCIvarRefExpr(Expr *BaseArg, ObjCIvarDecl *Ivar, | |
| SourceLocation IvarLoc, | |
| bool IsArrow, bool IsFreeIvar) { | |
| CXXScopeSpec SS; | |
| DeclarationNameInfo NameInfo(Ivar->getDeclName(), IvarLoc); | |
| ExprResult Result = getSema().BuildMemberReferenceExpr( | |
| BaseArg, BaseArg->getType(), | |
| /*FIXME:*/ IvarLoc, IsArrow, SS, SourceLocation(), | |
| /*FirstQualifierInScope=*/nullptr, NameInfo, | |
| /*TemplateArgs=*/nullptr, | |
| /*S=*/nullptr); | |
| if (IsFreeIvar && Result.isUsable()) | |
| cast<ObjCIvarRefExpr>(Result.get())->setIsFreeIvar(IsFreeIvar); | |
| return Result; | |
| } | |
| /// Build a new Objective-C property reference expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildObjCPropertyRefExpr(Expr *BaseArg, | |
| ObjCPropertyDecl *Property, | |
| SourceLocation PropertyLoc) { | |
| CXXScopeSpec SS; | |
| DeclarationNameInfo NameInfo(Property->getDeclName(), PropertyLoc); | |
| return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(), | |
| /*FIXME:*/PropertyLoc, | |
| /*IsArrow=*/false, | |
| SS, SourceLocation(), | |
| /*FirstQualifierInScope=*/nullptr, | |
| NameInfo, | |
| /*TemplateArgs=*/nullptr, | |
| /*S=*/nullptr); | |
| } | |
| /// Build a new Objective-C property reference expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildObjCPropertyRefExpr(Expr *Base, QualType T, | |
| ObjCMethodDecl *Getter, | |
| ObjCMethodDecl *Setter, | |
| SourceLocation PropertyLoc) { | |
| // Since these expressions can only be value-dependent, we do not | |
| // need to perform semantic analysis again. | |
| return Owned( | |
| new (getSema().Context) ObjCPropertyRefExpr(Getter, Setter, T, | |
| VK_LValue, OK_ObjCProperty, | |
| PropertyLoc, Base)); | |
| } | |
| /// Build a new Objective-C "isa" expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildObjCIsaExpr(Expr *BaseArg, SourceLocation IsaLoc, | |
| SourceLocation OpLoc, bool IsArrow) { | |
| CXXScopeSpec SS; | |
| DeclarationNameInfo NameInfo(&getSema().Context.Idents.get("isa"), IsaLoc); | |
| return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(), | |
| OpLoc, IsArrow, | |
| SS, SourceLocation(), | |
| /*FirstQualifierInScope=*/nullptr, | |
| NameInfo, | |
| /*TemplateArgs=*/nullptr, | |
| /*S=*/nullptr); | |
| } | |
| /// Build a new shuffle vector expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc, | |
| MultiExprArg SubExprs, | |
| SourceLocation RParenLoc) { | |
| // Find the declaration for __builtin_shufflevector | |
| const IdentifierInfo &Name | |
| = SemaRef.Context.Idents.get("__builtin_shufflevector"); | |
| TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl(); | |
| DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name)); | |
| assert(!Lookup.empty() && "No __builtin_shufflevector?"); | |
| // Build a reference to the __builtin_shufflevector builtin | |
| FunctionDecl *Builtin = cast<FunctionDecl>(Lookup.front()); | |
| Expr *Callee = new (SemaRef.Context) | |
| DeclRefExpr(SemaRef.Context, Builtin, false, | |
| SemaRef.Context.BuiltinFnTy, VK_PRValue, BuiltinLoc); | |
| QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType()); | |
| Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy, | |
| CK_BuiltinFnToFnPtr).get(); | |
| // Build the CallExpr | |
| ExprResult TheCall = CallExpr::Create( | |
| SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(), | |
| Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc, | |
| FPOptionsOverride()); | |
| // Type-check the __builtin_shufflevector expression. | |
| return SemaRef.BuiltinShuffleVector(cast<CallExpr>(TheCall.get())); | |
| } | |
| /// Build a new convert vector expression. | |
| ExprResult RebuildConvertVectorExpr(SourceLocation BuiltinLoc, | |
| Expr *SrcExpr, TypeSourceInfo *DstTInfo, | |
| SourceLocation RParenLoc) { | |
| return SemaRef.ConvertVectorExpr(SrcExpr, DstTInfo, BuiltinLoc, RParenLoc); | |
| } | |
| /// Build a new template argument pack expansion. | |
| /// | |
| /// By default, performs semantic analysis to build a new pack expansion | |
| /// for a template argument. Subclasses may override this routine to provide | |
| /// different behavior. | |
| TemplateArgumentLoc RebuildPackExpansion(TemplateArgumentLoc Pattern, | |
| SourceLocation EllipsisLoc, | |
| UnsignedOrNone NumExpansions) { | |
| switch (Pattern.getArgument().getKind()) { | |
| case TemplateArgument::Expression: { | |
| ExprResult Result | |
| = getSema().CheckPackExpansion(Pattern.getSourceExpression(), | |
| EllipsisLoc, NumExpansions); | |
| if (Result.isInvalid()) | |
| return TemplateArgumentLoc(); | |
| return TemplateArgumentLoc(TemplateArgument(Result.get(), | |
| /*IsCanonical=*/false), | |
| Result.get()); | |
| } | |
| case TemplateArgument::Template: | |
| return TemplateArgumentLoc( | |
| SemaRef.Context, | |
| TemplateArgument(Pattern.getArgument().getAsTemplate(), | |
| NumExpansions), | |
| Pattern.getTemplateKWLoc(), Pattern.getTemplateQualifierLoc(), | |
| Pattern.getTemplateNameLoc(), EllipsisLoc); | |
| case TemplateArgument::Null: | |
| case TemplateArgument::Integral: | |
| case TemplateArgument::Declaration: | |
| case TemplateArgument::StructuralValue: | |
| case TemplateArgument::Pack: | |
| case TemplateArgument::TemplateExpansion: | |
| case TemplateArgument::NullPtr: | |
| llvm_unreachable("Pack expansion pattern has no parameter packs"); | |
| case TemplateArgument::Type: | |
| if (TypeSourceInfo *Expansion | |
| = getSema().CheckPackExpansion(Pattern.getTypeSourceInfo(), | |
| EllipsisLoc, | |
| NumExpansions)) | |
| return TemplateArgumentLoc(TemplateArgument(Expansion->getType()), | |
| Expansion); | |
| break; | |
| } | |
| return TemplateArgumentLoc(); | |
| } | |
| /// Build a new expression pack expansion. | |
| /// | |
| /// By default, performs semantic analysis to build a new pack expansion | |
| /// for an expression. Subclasses may override this routine to provide | |
| /// different behavior. | |
| ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, | |
| UnsignedOrNone NumExpansions) { | |
| return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions); | |
| } | |
| /// Build a new C++1z fold-expression. | |
| /// | |
| /// By default, performs semantic analysis in order to build a new fold | |
| /// expression. | |
| ExprResult RebuildCXXFoldExpr(UnresolvedLookupExpr *ULE, | |
| SourceLocation LParenLoc, Expr *LHS, | |
| BinaryOperatorKind Operator, | |
| SourceLocation EllipsisLoc, Expr *RHS, | |
| SourceLocation RParenLoc, | |
| UnsignedOrNone NumExpansions) { | |
| return getSema().BuildCXXFoldExpr(ULE, LParenLoc, LHS, Operator, | |
| EllipsisLoc, RHS, RParenLoc, | |
| NumExpansions); | |
| } | |
| ExprResult RebuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc, | |
| LambdaScopeInfo *LSI) { | |
| for (ParmVarDecl *PVD : LSI->CallOperator->parameters()) { | |
| if (Expr *Init = PVD->getInit()) | |
| LSI->ContainsUnexpandedParameterPack |= | |
| Init->containsUnexpandedParameterPack(); | |
| else if (PVD->hasUninstantiatedDefaultArg()) | |
| LSI->ContainsUnexpandedParameterPack |= | |
| PVD->getUninstantiatedDefaultArg() | |
| ->containsUnexpandedParameterPack(); | |
| } | |
| return getSema().BuildLambdaExpr(StartLoc, EndLoc); | |
| } | |
| /// Build an empty C++1z fold-expression with the given operator. | |
| /// | |
| /// By default, produces the fallback value for the fold-expression, or | |
| /// produce an error if there is no fallback value. | |
| ExprResult RebuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc, | |
| BinaryOperatorKind Operator) { | |
| return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator); | |
| } | |
| /// Build a new atomic operation expression. | |
| /// | |
| /// By default, performs semantic analysis to build the new expression. | |
| /// Subclasses may override this routine to provide different behavior. | |
| ExprResult RebuildAtomicExpr(SourceLocation BuiltinLoc, MultiExprArg SubExprs, | |
| AtomicExpr::AtomicOp Op, | |
| SourceLocation RParenLoc) { | |
| // Use this for all of the locations, since we don't know the difference | |
| // between the call and the expr at this point. | |
| SourceRange Range{BuiltinLoc, RParenLoc}; | |
| return getSema().BuildAtomicExpr(Range, Range, RParenLoc, SubExprs, Op, | |
| Sema::AtomicArgumentOrder::AST); | |
| } | |
| ExprResult RebuildRecoveryExpr(SourceLocation BeginLoc, SourceLocation EndLoc, | |
| ArrayRef<Expr *> SubExprs, QualType Type) { | |
| return getSema().CreateRecoveryExpr(BeginLoc, EndLoc, SubExprs, Type); | |
| } | |
| StmtResult RebuildOpenACCComputeConstruct(OpenACCDirectiveKind K, | |
| SourceLocation BeginLoc, | |
| SourceLocation DirLoc, | |
| SourceLocation EndLoc, | |
| ArrayRef<OpenACCClause *> Clauses, | |
| StmtResult StrBlock) { | |
| return getSema().OpenACC().ActOnEndStmtDirective( | |
| K, BeginLoc, DirLoc, SourceLocation{}, SourceLocation{}, {}, | |
| OpenACCAtomicKind::None, SourceLocation{}, EndLoc, Clauses, StrBlock); | |
| } | |
| StmtResult RebuildOpenACCLoopConstruct(SourceLocation BeginLoc, | |
| SourceLocation DirLoc, | |
| SourceLocation EndLoc, | |
| ArrayRef<OpenACCClause *> Clauses, | |
| StmtResult Loop) { | |
| return getSema().OpenACC().ActOnEndStmtDirective( | |
| OpenACCDirectiveKind::Loop, BeginLoc, DirLoc, SourceLocation{}, | |
| SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc, | |
| Clauses, Loop); | |
| } | |
| StmtResult RebuildOpenACCCombinedConstruct(OpenACCDirectiveKind K, | |
| SourceLocation BeginLoc, | |
| SourceLocation DirLoc, | |
| SourceLocation EndLoc, | |
| ArrayRef<OpenACCClause *> Clauses, | |
| StmtResult Loop) { | |
| return getSema().OpenACC().ActOnEndStmtDirective( | |
| K, BeginLoc, DirLoc, SourceLocation{}, SourceLocation{}, {}, | |
| OpenACCAtomicKind::None, SourceLocation{}, EndLoc, Clauses, Loop); | |
| } | |
| StmtResult RebuildOpenACCDataConstruct(SourceLocation BeginLoc, | |
| SourceLocation DirLoc, | |
| SourceLocation EndLoc, | |
| ArrayRef<OpenACCClause *> Clauses, | |
| StmtResult StrBlock) { | |
| return getSema().OpenACC().ActOnEndStmtDirective( | |
| OpenACCDirectiveKind::Data, BeginLoc, DirLoc, SourceLocation{}, | |
| SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc, | |
| Clauses, StrBlock); | |
| } | |
| StmtResult | |
| RebuildOpenACCEnterDataConstruct(SourceLocation BeginLoc, | |
| SourceLocation DirLoc, SourceLocation EndLoc, | |
| ArrayRef<OpenACCClause *> Clauses) { | |
| return getSema().OpenACC().ActOnEndStmtDirective( | |
| OpenACCDirectiveKind::EnterData, BeginLoc, DirLoc, SourceLocation{}, | |
| SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc, | |
| Clauses, {}); | |
| } | |
| StmtResult | |
| RebuildOpenACCExitDataConstruct(SourceLocation BeginLoc, | |
| SourceLocation DirLoc, SourceLocation EndLoc, | |
| ArrayRef<OpenACCClause *> Clauses) { | |
| return getSema().OpenACC().ActOnEndStmtDirective( | |
| OpenACCDirectiveKind::ExitData, BeginLoc, DirLoc, SourceLocation{}, | |
| SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc, | |
| Clauses, {}); | |
| } | |
| StmtResult RebuildOpenACCHostDataConstruct(SourceLocation BeginLoc, | |
| SourceLocation DirLoc, | |
| SourceLocation EndLoc, | |
| ArrayRef<OpenACCClause *> Clauses, | |
| StmtResult StrBlock) { | |
| return getSema().OpenACC().ActOnEndStmtDirective( | |
| OpenACCDirectiveKind::HostData, BeginLoc, DirLoc, SourceLocation{}, | |
| SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc, | |
| Clauses, StrBlock); | |
| } | |
| StmtResult RebuildOpenACCInitConstruct(SourceLocation BeginLoc, | |
| SourceLocation DirLoc, | |
| SourceLocation EndLoc, | |
| ArrayRef<OpenACCClause *> Clauses) { | |
| return getSema().OpenACC().ActOnEndStmtDirective( | |
| OpenACCDirectiveKind::Init, BeginLoc, DirLoc, SourceLocation{}, | |
| SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc, | |
| Clauses, {}); | |
| } | |
| StmtResult | |
| RebuildOpenACCShutdownConstruct(SourceLocation BeginLoc, | |
| SourceLocation DirLoc, SourceLocation EndLoc, | |
| ArrayRef<OpenACCClause *> Clauses) { | |
| return getSema().OpenACC().ActOnEndStmtDirective( | |
| OpenACCDirectiveKind::Shutdown, BeginLoc, DirLoc, SourceLocation{}, | |
| SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc, | |
| Clauses, {}); | |
| } | |
| StmtResult RebuildOpenACCSetConstruct(SourceLocation BeginLoc, | |
| SourceLocation DirLoc, | |
| SourceLocation EndLoc, | |
| ArrayRef<OpenACCClause *> Clauses) { | |
| return getSema().OpenACC().ActOnEndStmtDirective( | |
| OpenACCDirectiveKind::Set, BeginLoc, DirLoc, SourceLocation{}, | |
| SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc, | |
| Clauses, {}); | |
| } | |
| StmtResult RebuildOpenACCUpdateConstruct(SourceLocation BeginLoc, | |
| SourceLocation DirLoc, | |
| SourceLocation EndLoc, | |
| ArrayRef<OpenACCClause *> Clauses) { | |
| return getSema().OpenACC().ActOnEndStmtDirective( | |
| OpenACCDirectiveKind::Update, BeginLoc, DirLoc, SourceLocation{}, | |
| SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc, | |
| Clauses, {}); | |
| } | |
| StmtResult RebuildOpenACCWaitConstruct( | |
| SourceLocation BeginLoc, SourceLocation DirLoc, SourceLocation LParenLoc, | |
| Expr *DevNumExpr, SourceLocation QueuesLoc, ArrayRef<Expr *> QueueIdExprs, | |
| SourceLocation RParenLoc, SourceLocation EndLoc, | |
| ArrayRef<OpenACCClause *> Clauses) { | |
| llvm::SmallVector<Expr *> Exprs; | |
| Exprs.push_back(DevNumExpr); | |
| llvm::append_range(Exprs, QueueIdExprs); | |
| return getSema().OpenACC().ActOnEndStmtDirective( | |
| OpenACCDirectiveKind::Wait, BeginLoc, DirLoc, LParenLoc, QueuesLoc, | |
| Exprs, OpenACCAtomicKind::None, RParenLoc, EndLoc, Clauses, {}); | |
| } | |
| StmtResult RebuildOpenACCCacheConstruct( | |
| SourceLocation BeginLoc, SourceLocation DirLoc, SourceLocation LParenLoc, | |
| SourceLocation ReadOnlyLoc, ArrayRef<Expr *> VarList, | |
| SourceLocation RParenLoc, SourceLocation EndLoc) { | |
| return getSema().OpenACC().ActOnEndStmtDirective( | |
| OpenACCDirectiveKind::Cache, BeginLoc, DirLoc, LParenLoc, ReadOnlyLoc, | |
| VarList, OpenACCAtomicKind::None, RParenLoc, EndLoc, {}, {}); | |
| } | |
| StmtResult RebuildOpenACCAtomicConstruct(SourceLocation BeginLoc, | |
| SourceLocation DirLoc, | |
| OpenACCAtomicKind AtKind, | |
| SourceLocation EndLoc, | |
| ArrayRef<OpenACCClause *> Clauses, | |
| StmtResult AssociatedStmt) { | |
| return getSema().OpenACC().ActOnEndStmtDirective( | |
| OpenACCDirectiveKind::Atomic, BeginLoc, DirLoc, SourceLocation{}, | |
| SourceLocation{}, {}, AtKind, SourceLocation{}, EndLoc, Clauses, | |
| AssociatedStmt); | |
| } | |
| ExprResult RebuildOpenACCAsteriskSizeExpr(SourceLocation AsteriskLoc) { | |
| return getSema().OpenACC().ActOnOpenACCAsteriskSizeExpr(AsteriskLoc); | |
| } | |
| ExprResult | |
| RebuildSubstNonTypeTemplateParmExpr(Decl *AssociatedDecl, unsigned Index, | |
| QualType ParamType, SourceLocation Loc, | |
| TemplateArgument Arg, | |
| UnsignedOrNone PackIndex, bool Final) { | |
| return getSema().BuildSubstNonTypeTemplateParmExpr( | |
| AssociatedDecl, Index, ParamType, Loc, Arg, PackIndex, Final); | |
| } | |
| OMPClause *RebuildOpenMPTransparentClause(Expr *ImpexType, | |
| SourceLocation StartLoc, | |
| SourceLocation LParenLoc, | |
| SourceLocation EndLoc) { | |
| return getSema().OpenMP().ActOnOpenMPTransparentClause(ImpexType, StartLoc, | |
| LParenLoc, EndLoc); | |
| } | |
| private: | |
| QualType TransformTypeInObjectScope(TypeLocBuilder &TLB, TypeLoc TL, | |
| QualType ObjectType, | |
| NamedDecl *FirstQualifierInScope); | |
| TypeSourceInfo *TransformTypeInObjectScope(TypeSourceInfo *TSInfo, | |
| QualType ObjectType, | |
| NamedDecl *FirstQualifierInScope) { | |
| if (getDerived().AlreadyTransformed(TSInfo->getType())) | |
| return TSInfo; | |
| TypeLocBuilder TLB; | |
| QualType T = TransformTypeInObjectScope(TLB, TSInfo->getTypeLoc(), | |
| ObjectType, FirstQualifierInScope); | |
| if (T.isNull()) | |
| return nullptr; | |
| return TLB.getTypeSourceInfo(SemaRef.Context, T); | |
| } | |
| QualType TransformDependentNameType(TypeLocBuilder &TLB, | |
| DependentNameTypeLoc TL, | |
| bool DeducibleTSTContext, | |
| QualType ObjectType = QualType(), | |
| NamedDecl *UnqualLookup = nullptr); | |
| llvm::SmallVector<OpenACCClause *> | |
| TransformOpenACCClauseList(OpenACCDirectiveKind DirKind, | |
| ArrayRef<const OpenACCClause *> OldClauses); | |
| OpenACCClause * | |
| TransformOpenACCClause(ArrayRef<const OpenACCClause *> ExistingClauses, | |
| OpenACCDirectiveKind DirKind, | |
| const OpenACCClause *OldClause); | |
| }; | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S, StmtDiscardKind SDK) { | |
| if (!S) | |
| return S; | |
| switch (S->getStmtClass()) { | |
| case Stmt::NoStmtClass: break; | |
| // Transform individual statement nodes | |
| // Pass SDK into statements that can produce a value | |
| #define STMT(Node, Parent) \ | |
| case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S)); | |
| #define VALUESTMT(Node, Parent) \ | |
| case Stmt::Node##Class: \ | |
| return getDerived().Transform##Node(cast<Node>(S), SDK); | |
| #define ABSTRACT_STMT(Node) | |
| #define EXPR(Node, Parent) | |
| #include "clang/AST/StmtNodes.inc" | |
| // Transform expressions by calling TransformExpr. | |
| #define STMT(Node, Parent) | |
| #define ABSTRACT_STMT(Stmt) | |
| #define EXPR(Node, Parent) case Stmt::Node##Class: | |
| #include "clang/AST/StmtNodes.inc" | |
| { | |
| ExprResult E = getDerived().TransformExpr(cast<Expr>(S)); | |
| if (SDK == StmtDiscardKind::StmtExprResult) | |
| E = getSema().ActOnStmtExprResult(E); | |
| return getSema().ActOnExprStmt(E, SDK == StmtDiscardKind::Discarded); | |
| } | |
| } | |
| return S; | |
| } | |
| template<typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPClause(OMPClause *S) { | |
| if (!S) | |
| return S; | |
| switch (S->getClauseKind()) { | |
| default: break; | |
| // Transform individual clause nodes | |
| #define GEN_CLANG_CLAUSE_CLASS | |
| #define CLAUSE_CLASS(Enum, Str, Class) \ | |
| case Enum: \ | |
| return getDerived().Transform##Class(cast<Class>(S)); | |
| #include "llvm/Frontend/OpenMP/OMP.inc" | |
| } | |
| return S; | |
| } | |
| template<typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) { | |
| if (!E) | |
| return E; | |
| switch (E->getStmtClass()) { | |
| case Stmt::NoStmtClass: break; | |
| #define STMT(Node, Parent) case Stmt::Node##Class: break; | |
| #define ABSTRACT_STMT(Stmt) | |
| #define EXPR(Node, Parent) \ | |
| case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E)); | |
| #include "clang/AST/StmtNodes.inc" | |
| } | |
| return E; | |
| } | |
| template<typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init, | |
| bool NotCopyInit) { | |
| // Initializers are instantiated like expressions, except that various outer | |
| // layers are stripped. | |
| if (!Init) | |
| return Init; | |
| if (auto *FE = dyn_cast<FullExpr>(Init)) | |
| Init = FE->getSubExpr(); | |
| if (auto *AIL = dyn_cast<ArrayInitLoopExpr>(Init)) { | |
| OpaqueValueExpr *OVE = AIL->getCommonExpr(); | |
| Init = OVE->getSourceExpr(); | |
| } | |
| if (MaterializeTemporaryExpr *MTE = dyn_cast<MaterializeTemporaryExpr>(Init)) | |
| Init = MTE->getSubExpr(); | |
| while (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(Init)) | |
| Init = Binder->getSubExpr(); | |
| if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Init)) | |
| Init = ICE->getSubExprAsWritten(); | |
| if (CXXStdInitializerListExpr *ILE = | |
| dyn_cast<CXXStdInitializerListExpr>(Init)) | |
| return TransformInitializer(ILE->getSubExpr(), NotCopyInit); | |
| // If this is copy-initialization, we only need to reconstruct | |
| // InitListExprs. Other forms of copy-initialization will be a no-op if | |
| // the initializer is already the right type. | |
| CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init); | |
| if (!NotCopyInit && !(Construct && Construct->isListInitialization())) | |
| return getDerived().TransformExpr(Init); | |
| // Revert value-initialization back to empty parens. | |
| if (CXXScalarValueInitExpr *VIE = dyn_cast<CXXScalarValueInitExpr>(Init)) { | |
| SourceRange Parens = VIE->getSourceRange(); | |
| return getDerived().RebuildParenListExpr(Parens.getBegin(), {}, | |
| Parens.getEnd()); | |
| } | |
| // FIXME: We shouldn't build ImplicitValueInitExprs for direct-initialization. | |
| if (isa<ImplicitValueInitExpr>(Init)) | |
| return getDerived().RebuildParenListExpr(SourceLocation(), {}, | |
| SourceLocation()); | |
| // Revert initialization by constructor back to a parenthesized or braced list | |
| // of expressions. Any other form of initializer can just be reused directly. | |
| if (!Construct || isa<CXXTemporaryObjectExpr>(Construct)) | |
| return getDerived().TransformExpr(Init); | |
| // If the initialization implicitly converted an initializer list to a | |
| // std::initializer_list object, unwrap the std::initializer_list too. | |
| if (Construct && Construct->isStdInitListInitialization()) | |
| return TransformInitializer(Construct->getArg(0), NotCopyInit); | |
| // Enter a list-init context if this was list initialization. | |
| EnterExpressionEvaluationContext Context( | |
| getSema(), EnterExpressionEvaluationContext::InitList, | |
| Construct->isListInitialization()); | |
| getSema().currentEvaluationContext().InLifetimeExtendingContext = | |
| getSema().parentEvaluationContext().InLifetimeExtendingContext; | |
| getSema().currentEvaluationContext().RebuildDefaultArgOrDefaultInit = | |
| getSema().parentEvaluationContext().RebuildDefaultArgOrDefaultInit; | |
| SmallVector<Expr*, 8> NewArgs; | |
| bool ArgChanged = false; | |
| if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(), | |
| /*IsCall*/true, NewArgs, &ArgChanged)) | |
| return ExprError(); | |
| // If this was list initialization, revert to syntactic list form. | |
| if (Construct->isListInitialization()) | |
| return getDerived().RebuildInitList(Construct->getBeginLoc(), NewArgs, | |
| Construct->getEndLoc(), | |
| /*IsExplicit=*/true); | |
| // Build a ParenListExpr to represent anything else. | |
| SourceRange Parens = Construct->getParenOrBraceRange(); | |
| if (Parens.isInvalid()) { | |
| // This was a variable declaration's initialization for which no initializer | |
| // was specified. | |
| assert(NewArgs.empty() && | |
| "no parens or braces but have direct init with arguments?"); | |
| return ExprEmpty(); | |
| } | |
| return getDerived().RebuildParenListExpr(Parens.getBegin(), NewArgs, | |
| Parens.getEnd()); | |
| } | |
| template<typename Derived> | |
| bool TreeTransform<Derived>::TransformExprs(Expr *const *Inputs, | |
| unsigned NumInputs, | |
| bool IsCall, | |
| SmallVectorImpl<Expr *> &Outputs, | |
| bool *ArgChanged) { | |
| for (unsigned I = 0; I != NumInputs; ++I) { | |
| // If requested, drop call arguments that need to be dropped. | |
| if (IsCall && getDerived().DropCallArgument(Inputs[I])) { | |
| if (ArgChanged) | |
| *ArgChanged = true; | |
| break; | |
| } | |
| if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(Inputs[I])) { | |
| Expr *Pattern = Expansion->getPattern(); | |
| SmallVector<UnexpandedParameterPack, 2> Unexpanded; | |
| getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); | |
| assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); | |
| // Determine whether the set of unexpanded parameter packs can and should | |
| // be expanded. | |
| bool Expand = true; | |
| bool RetainExpansion = false; | |
| UnsignedOrNone OrigNumExpansions = Expansion->getNumExpansions(); | |
| UnsignedOrNone NumExpansions = OrigNumExpansions; | |
| if (getDerived().TryExpandParameterPacks( | |
| Expansion->getEllipsisLoc(), Pattern->getSourceRange(), | |
| Unexpanded, /*FailOnPackProducingTemplates=*/true, Expand, | |
| RetainExpansion, NumExpansions)) | |
| return true; | |
| if (!Expand) { | |
| // The transform has determined that we should perform a simple | |
| // transformation on the pack expansion, producing another pack | |
| // expansion. | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); | |
| ExprResult OutPattern = getDerived().TransformExpr(Pattern); | |
| if (OutPattern.isInvalid()) | |
| return true; | |
| ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(), | |
| Expansion->getEllipsisLoc(), | |
| NumExpansions); | |
| if (Out.isInvalid()) | |
| return true; | |
| if (ArgChanged) | |
| *ArgChanged = true; | |
| Outputs.push_back(Out.get()); | |
| continue; | |
| } | |
| // Record right away that the argument was changed. This needs | |
| // to happen even if the array expands to nothing. | |
| if (ArgChanged) *ArgChanged = true; | |
| // The transform has determined that we should perform an elementwise | |
| // expansion of the pattern. Do so. | |
| for (unsigned I = 0; I != *NumExpansions; ++I) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); | |
| ExprResult Out = getDerived().TransformExpr(Pattern); | |
| if (Out.isInvalid()) | |
| return true; | |
| if (Out.get()->containsUnexpandedParameterPack()) { | |
| Out = getDerived().RebuildPackExpansion( | |
| Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions); | |
| if (Out.isInvalid()) | |
| return true; | |
| } | |
| Outputs.push_back(Out.get()); | |
| } | |
| // If we're supposed to retain a pack expansion, do so by temporarily | |
| // forgetting the partially-substituted parameter pack. | |
| if (RetainExpansion) { | |
| ForgetPartiallySubstitutedPackRAII Forget(getDerived()); | |
| ExprResult Out = getDerived().TransformExpr(Pattern); | |
| if (Out.isInvalid()) | |
| return true; | |
| Out = getDerived().RebuildPackExpansion( | |
| Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions); | |
| if (Out.isInvalid()) | |
| return true; | |
| Outputs.push_back(Out.get()); | |
| } | |
| continue; | |
| } | |
| ExprResult Result = | |
| IsCall ? getDerived().TransformInitializer(Inputs[I], /*DirectInit*/false) | |
| : getDerived().TransformExpr(Inputs[I]); | |
| if (Result.isInvalid()) | |
| return true; | |
| if (Result.get() != Inputs[I] && ArgChanged) | |
| *ArgChanged = true; | |
| Outputs.push_back(Result.get()); | |
| } | |
| return false; | |
| } | |
| template <typename Derived> | |
| Sema::ConditionResult TreeTransform<Derived>::TransformCondition( | |
| SourceLocation Loc, VarDecl *Var, Expr *Expr, Sema::ConditionKind Kind) { | |
| EnterExpressionEvaluationContext Eval( | |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated, | |
| /*LambdaContextDecl=*/nullptr, | |
| /*ExprContext=*/Sema::ExpressionEvaluationContextRecord::EK_Other, | |
| /*ShouldEnter=*/Kind == Sema::ConditionKind::ConstexprIf); | |
| if (Var) { | |
| VarDecl *ConditionVar = cast_or_null<VarDecl>( | |
| getDerived().TransformDefinition(Var->getLocation(), Var)); | |
| if (!ConditionVar) | |
| return Sema::ConditionError(); | |
| return getSema().ActOnConditionVariable(ConditionVar, Loc, Kind); | |
| } | |
| if (Expr) { | |
| ExprResult CondExpr = getDerived().TransformExpr(Expr); | |
| if (CondExpr.isInvalid()) | |
| return Sema::ConditionError(); | |
| return getSema().ActOnCondition(nullptr, Loc, CondExpr.get(), Kind, | |
| /*MissingOK=*/true); | |
| } | |
| return Sema::ConditionResult(); | |
| } | |
| template <typename Derived> | |
| NestedNameSpecifierLoc TreeTransform<Derived>::TransformNestedNameSpecifierLoc( | |
| NestedNameSpecifierLoc NNS, QualType ObjectType, | |
| NamedDecl *FirstQualifierInScope) { | |
| SmallVector<NestedNameSpecifierLoc, 4> Qualifiers; | |
| auto insertNNS = [&Qualifiers](NestedNameSpecifierLoc NNS) { | |
| for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier; | |
| Qualifier = Qualifier.getAsNamespaceAndPrefix().Prefix) | |
| Qualifiers.push_back(Qualifier); | |
| }; | |
| insertNNS(NNS); | |
| CXXScopeSpec SS; | |
| while (!Qualifiers.empty()) { | |
| NestedNameSpecifierLoc Q = Qualifiers.pop_back_val(); | |
| NestedNameSpecifier QNNS = Q.getNestedNameSpecifier(); | |
| switch (QNNS.getKind()) { | |
| case NestedNameSpecifier::Kind::Null: | |
| llvm_unreachable("unexpected null nested name specifier"); | |
| case NestedNameSpecifier::Kind::Namespace: { | |
| auto *NS = cast<NamespaceBaseDecl>(getDerived().TransformDecl( | |
| Q.getLocalBeginLoc(), const_cast<NamespaceBaseDecl *>( | |
| QNNS.getAsNamespaceAndPrefix().Namespace))); | |
| SS.Extend(SemaRef.Context, NS, Q.getLocalBeginLoc(), Q.getLocalEndLoc()); | |
| break; | |
| } | |
| case NestedNameSpecifier::Kind::Global: | |
| // There is no meaningful transformation that one could perform on the | |
| // global scope. | |
| SS.MakeGlobal(SemaRef.Context, Q.getBeginLoc()); | |
| break; | |
| case NestedNameSpecifier::Kind::MicrosoftSuper: { | |
| CXXRecordDecl *RD = cast_or_null<CXXRecordDecl>( | |
| getDerived().TransformDecl(SourceLocation(), QNNS.getAsRecordDecl())); | |
| SS.MakeMicrosoftSuper(SemaRef.Context, RD, Q.getBeginLoc(), | |
| Q.getEndLoc()); | |
| break; | |
| } | |
| case NestedNameSpecifier::Kind::Type: { | |
| assert(SS.isEmpty()); | |
| TypeLoc TL = Q.castAsTypeLoc(); | |
| if (auto DNT = TL.getAs<DependentNameTypeLoc>()) { | |
| NestedNameSpecifierLoc QualifierLoc = DNT.getQualifierLoc(); | |
| if (QualifierLoc) { | |
| QualifierLoc = getDerived().TransformNestedNameSpecifierLoc( | |
| QualifierLoc, ObjectType, FirstQualifierInScope); | |
| if (!QualifierLoc) | |
| return NestedNameSpecifierLoc(); | |
| ObjectType = QualType(); | |
| FirstQualifierInScope = nullptr; | |
| } | |
| SS.Adopt(QualifierLoc); | |
| Sema::NestedNameSpecInfo IdInfo( | |
| const_cast<IdentifierInfo *>(DNT.getTypePtr()->getIdentifier()), | |
| DNT.getNameLoc(), Q.getLocalEndLoc(), ObjectType); | |
| if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/nullptr, IdInfo, | |
| false, SS, | |
| FirstQualifierInScope, false)) | |
| return NestedNameSpecifierLoc(); | |
| return SS.getWithLocInContext(SemaRef.Context); | |
| } | |
| QualType T = TL.getType(); | |
| TypeLocBuilder TLB; | |
| if (!getDerived().AlreadyTransformed(T)) { | |
| T = TransformTypeInObjectScope(TLB, TL, ObjectType, | |
| FirstQualifierInScope); | |
| if (T.isNull()) | |
| return NestedNameSpecifierLoc(); | |
| TL = TLB.getTypeLocInContext(SemaRef.Context, T); | |
| } | |
| if (T->isDependentType() || T->isRecordType() || | |
| (SemaRef.getLangOpts().CPlusPlus11 && T->isEnumeralType())) { | |
| if (T->isEnumeralType()) | |
| SemaRef.Diag(TL.getBeginLoc(), | |
| diag::warn_cxx98_compat_enum_nested_name_spec); | |
| SS.Make(SemaRef.Context, TL, Q.getLocalEndLoc()); | |
| break; | |
| } | |
| // If the nested-name-specifier is an invalid type def, don't emit an | |
| // error because a previous error should have already been emitted. | |
| TypedefTypeLoc TTL = TL.getAsAdjusted<TypedefTypeLoc>(); | |
| if (!TTL || !TTL.getDecl()->isInvalidDecl()) { | |
| SemaRef.Diag(TL.getBeginLoc(), diag::err_nested_name_spec_non_tag) | |
| << T << SS.getRange(); | |
| } | |
| return NestedNameSpecifierLoc(); | |
| } | |
| } | |
| } | |
| // Don't rebuild the nested-name-specifier if we don't have to. | |
| if (SS.getScopeRep() == NNS.getNestedNameSpecifier() && | |
| !getDerived().AlwaysRebuild()) | |
| return NNS; | |
| // If we can re-use the source-location data from the original | |
| // nested-name-specifier, do so. | |
| if (SS.location_size() == NNS.getDataLength() && | |
| memcmp(SS.location_data(), NNS.getOpaqueData(), SS.location_size()) == 0) | |
| return NestedNameSpecifierLoc(SS.getScopeRep(), NNS.getOpaqueData()); | |
| // Allocate new nested-name-specifier location information. | |
| return SS.getWithLocInContext(SemaRef.Context); | |
| } | |
| template<typename Derived> | |
| DeclarationNameInfo | |
| TreeTransform<Derived> | |
| ::TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo) { | |
| DeclarationName Name = NameInfo.getName(); | |
| if (!Name) | |
| return DeclarationNameInfo(); | |
| switch (Name.getNameKind()) { | |
| case DeclarationName::Identifier: | |
| case DeclarationName::ObjCZeroArgSelector: | |
| case DeclarationName::ObjCOneArgSelector: | |
| case DeclarationName::ObjCMultiArgSelector: | |
| case DeclarationName::CXXOperatorName: | |
| case DeclarationName::CXXLiteralOperatorName: | |
| case DeclarationName::CXXUsingDirective: | |
| return NameInfo; | |
| case DeclarationName::CXXDeductionGuideName: { | |
| TemplateDecl *OldTemplate = Name.getCXXDeductionGuideTemplate(); | |
| TemplateDecl *NewTemplate = cast_or_null<TemplateDecl>( | |
| getDerived().TransformDecl(NameInfo.getLoc(), OldTemplate)); | |
| if (!NewTemplate) | |
| return DeclarationNameInfo(); | |
| DeclarationNameInfo NewNameInfo(NameInfo); | |
| NewNameInfo.setName( | |
| SemaRef.Context.DeclarationNames.getCXXDeductionGuideName(NewTemplate)); | |
| return NewNameInfo; | |
| } | |
| case DeclarationName::CXXConstructorName: | |
| case DeclarationName::CXXDestructorName: | |
| case DeclarationName::CXXConversionFunctionName: { | |
| TypeSourceInfo *NewTInfo; | |
| CanQualType NewCanTy; | |
| if (TypeSourceInfo *OldTInfo = NameInfo.getNamedTypeInfo()) { | |
| NewTInfo = getDerived().TransformType(OldTInfo); | |
| if (!NewTInfo) | |
| return DeclarationNameInfo(); | |
| NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->getType()); | |
| } | |
| else { | |
| NewTInfo = nullptr; | |
| TemporaryBase Rebase(*this, NameInfo.getLoc(), Name); | |
| QualType NewT = getDerived().TransformType(Name.getCXXNameType()); | |
| if (NewT.isNull()) | |
| return DeclarationNameInfo(); | |
| NewCanTy = SemaRef.Context.getCanonicalType(NewT); | |
| } | |
| DeclarationName NewName | |
| = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.getNameKind(), | |
| NewCanTy); | |
| DeclarationNameInfo NewNameInfo(NameInfo); | |
| NewNameInfo.setName(NewName); | |
| NewNameInfo.setNamedTypeInfo(NewTInfo); | |
| return NewNameInfo; | |
| } | |
| } | |
| llvm_unreachable("Unknown name kind."); | |
| } | |
| template <typename Derived> | |
| TemplateName TreeTransform<Derived>::RebuildTemplateName( | |
| CXXScopeSpec &SS, SourceLocation TemplateKWLoc, | |
| IdentifierOrOverloadedOperator IO, SourceLocation NameLoc, | |
| QualType ObjectType, bool AllowInjectedClassName) { | |
| if (const IdentifierInfo *II = IO.getIdentifier()) | |
| return getDerived().RebuildTemplateName(SS, TemplateKWLoc, *II, NameLoc, | |
| ObjectType, AllowInjectedClassName); | |
| return getDerived().RebuildTemplateName(SS, TemplateKWLoc, IO.getOperator(), | |
| NameLoc, ObjectType, | |
| AllowInjectedClassName); | |
| } | |
| template <typename Derived> | |
| TemplateName TreeTransform<Derived>::TransformTemplateName( | |
| NestedNameSpecifierLoc &QualifierLoc, SourceLocation TemplateKWLoc, | |
| TemplateName Name, SourceLocation NameLoc, QualType ObjectType, | |
| NamedDecl *FirstQualifierInScope, bool AllowInjectedClassName) { | |
| if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) { | |
| TemplateName UnderlyingName = QTN->getUnderlyingTemplate(); | |
| if (QualifierLoc) { | |
| QualifierLoc = getDerived().TransformNestedNameSpecifierLoc( | |
| QualifierLoc, ObjectType, FirstQualifierInScope); | |
| if (!QualifierLoc) | |
| return TemplateName(); | |
| } | |
| NestedNameSpecifierLoc UnderlyingQualifier; | |
| TemplateName NewUnderlyingName = getDerived().TransformTemplateName( | |
| UnderlyingQualifier, TemplateKWLoc, UnderlyingName, NameLoc, ObjectType, | |
| FirstQualifierInScope, AllowInjectedClassName); | |
| if (NewUnderlyingName.isNull()) | |
| return TemplateName(); | |
| assert(!UnderlyingQualifier && "unexpected qualifier"); | |
| if (!getDerived().AlwaysRebuild() && | |
| QualifierLoc.getNestedNameSpecifier() == QTN->getQualifier() && | |
| NewUnderlyingName == UnderlyingName) | |
| return Name; | |
| CXXScopeSpec SS; | |
| SS.Adopt(QualifierLoc); | |
| return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(), | |
| NewUnderlyingName); | |
| } | |
| if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) { | |
| if (QualifierLoc) { | |
| QualifierLoc = getDerived().TransformNestedNameSpecifierLoc( | |
| QualifierLoc, ObjectType, FirstQualifierInScope); | |
| if (!QualifierLoc) | |
| return TemplateName(); | |
| // The qualifier-in-scope and object type only apply to the leftmost | |
| // entity. | |
| ObjectType = QualType(); | |
| } | |
| if (!getDerived().AlwaysRebuild() && | |
| QualifierLoc.getNestedNameSpecifier() == DTN->getQualifier() && | |
| ObjectType.isNull()) | |
| return Name; | |
| CXXScopeSpec SS; | |
| SS.Adopt(QualifierLoc); | |
| return getDerived().RebuildTemplateName(SS, TemplateKWLoc, DTN->getName(), | |
| NameLoc, ObjectType, | |
| AllowInjectedClassName); | |
| } | |
| if (SubstTemplateTemplateParmStorage *S = | |
| Name.getAsSubstTemplateTemplateParm()) { | |
| assert(!QualifierLoc && "Unexpected qualified SubstTemplateTemplateParm"); | |
| NestedNameSpecifierLoc ReplacementQualifierLoc; | |
| TemplateName ReplacementName = S->getReplacement(); | |
| if (NestedNameSpecifier Qualifier = ReplacementName.getQualifier()) { | |
| NestedNameSpecifierLocBuilder Builder; | |
| Builder.MakeTrivial(SemaRef.Context, Qualifier, NameLoc); | |
| ReplacementQualifierLoc = Builder.getWithLocInContext(SemaRef.Context); | |
| } | |
| TemplateName NewName = getDerived().TransformTemplateName( | |
| ReplacementQualifierLoc, TemplateKWLoc, ReplacementName, NameLoc, | |
| ObjectType, FirstQualifierInScope, AllowInjectedClassName); | |
| if (NewName.isNull()) | |
| return TemplateName(); | |
| Decl *AssociatedDecl = | |
| getDerived().TransformDecl(NameLoc, S->getAssociatedDecl()); | |
| if (!getDerived().AlwaysRebuild() && NewName == S->getReplacement() && | |
| AssociatedDecl == S->getAssociatedDecl()) | |
| return Name; | |
| return SemaRef.Context.getSubstTemplateTemplateParm( | |
| NewName, AssociatedDecl, S->getIndex(), S->getPackIndex(), | |
| S->getFinal()); | |
| } | |
| if (PackIndexingTemplateStorage *PI = Name.getAsPackIndexingTemplate()) { | |
| assert(!QualifierLoc && "Unexpected qualified pack-index-template-name"); | |
| ExprResult IndexExpr; | |
| { | |
| EnterExpressionEvaluationContext ConstantContext( | |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); | |
| IndexExpr = getDerived().TransformExpr(PI->getIndexExpr()); | |
| if (IndexExpr.isInvalid()) | |
| return TemplateName(); | |
| } | |
| auto TransformOne = [&](TemplateName N) { | |
| NestedNameSpecifierLoc NoQualifier; | |
| return getDerived().TransformTemplateName( | |
| NoQualifier, TemplateKWLoc, N, NameLoc, ObjectType, | |
| FirstQualifierInScope, AllowInjectedClassName); | |
| }; | |
| TemplateName Pattern = PI->getPattern(); | |
| SmallVector<TemplateName, 4> SubstitutedNames; | |
| ArrayRef<TemplateName> Names = PI->getExpansions(); | |
| bool NotYetExpanded = Names.empty(); | |
| bool FullySubstituted = true; | |
| if (Names.empty() && !PI->expandsToEmptyPack()) | |
| Names = ArrayRef(&Pattern, 1); | |
| for (TemplateName N : Names) { | |
| if (!N.containsUnexpandedParameterPack()) { | |
| TemplateName Transformed = TransformOne(N); | |
| if (Transformed.isNull()) | |
| return TemplateName(); | |
| SubstitutedNames.push_back(Transformed); | |
| continue; | |
| } | |
| SmallVector<UnexpandedParameterPack, 2> Unexpanded; | |
| getSema().collectUnexpandedParameterPacks(N, Unexpanded); | |
| assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); | |
| bool ShouldExpand = true; | |
| bool RetainExpansion = false; | |
| UnsignedOrNone NumExpansions = std::nullopt; | |
| if (getDerived().TryExpandParameterPacks( | |
| NameLoc, SourceRange(), Unexpanded, | |
| /*FailOnPackProducingTemplates=*/true, ShouldExpand, | |
| RetainExpansion, NumExpansions)) | |
| return TemplateName(); | |
| if (!ShouldExpand) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); | |
| TemplateName Pack = TransformOne(N); | |
| if (Pack.isNull()) | |
| return TemplateName(); | |
| if (NotYetExpanded) { | |
| FullySubstituted = false; | |
| return getDerived().RebuildPackIndexingTemplateName( | |
| Pack, IndexExpr.get(), FullySubstituted); | |
| } | |
| SubstitutedNames.push_back(Pack); | |
| continue; | |
| } | |
| for (unsigned I = 0; I != *NumExpansions; ++I) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); | |
| TemplateName Out = TransformOne(N); | |
| if (Out.isNull()) | |
| return TemplateName(); | |
| SubstitutedNames.push_back(Out); | |
| FullySubstituted &= !Out.containsUnexpandedParameterPack(); | |
| } | |
| // If we're supposed to retain a pack expansion, do so by temporarily | |
| // forgetting the partially-substituted parameter pack. | |
| if (RetainExpansion) { | |
| FullySubstituted = false; | |
| ForgetPartiallySubstitutedPackRAII Forget(getDerived()); | |
| TemplateName Out = TransformOne(N); | |
| if (Out.isNull()) | |
| return TemplateName(); | |
| SubstitutedNames.push_back(Out); | |
| } | |
| } | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); | |
| TemplateName NewPattern = TransformOne(Pattern); | |
| if (NewPattern.isNull()) | |
| return TemplateName(); | |
| return getDerived().RebuildPackIndexingTemplateName( | |
| NewPattern, IndexExpr.get(), FullySubstituted, SubstitutedNames); | |
| } | |
| assert(!Name.getAsDeducedTemplateName() && | |
| "DeducedTemplateName should not escape partial ordering"); | |
| // FIXME: Preserve UsingTemplateName. | |
| if (auto *Template = Name.getAsTemplateDecl()) { | |
| assert(!QualifierLoc && "Unexpected qualifier"); | |
| return TemplateName(cast_or_null<TemplateDecl>( | |
| getDerived().TransformDecl(NameLoc, Template))); | |
| } | |
| if (SubstTemplateTemplateParmPackStorage *SubstPack | |
| = Name.getAsSubstTemplateTemplateParmPack()) { | |
| assert(!QualifierLoc && | |
| "Unexpected qualified SubstTemplateTemplateParmPack"); | |
| return getDerived().RebuildTemplateName( | |
| SubstPack->getArgumentPack(), SubstPack->getAssociatedDecl(), | |
| SubstPack->getIndex(), SubstPack->getFinal()); | |
| } | |
| // These should be getting filtered out before they reach the AST. | |
| llvm_unreachable("overloaded function decl survived to here"); | |
| } | |
| template <typename Derived> | |
| TemplateName | |
| TreeTransform<Derived>::TransformConceptTemplateName(TemplateName Name, | |
| SourceLocation NameLoc) { | |
| NestedNameSpecifierLoc QualifierLoc; | |
| return getDerived().TransformTemplateName( | |
| QualifierLoc, /*TemplateKWLoc=*/SourceLocation(), Name, NameLoc); | |
| } | |
| template <typename Derived> | |
| TemplateArgument TreeTransform<Derived>::TransformNamedTemplateTemplateArgument( | |
| NestedNameSpecifierLoc &QualifierLoc, SourceLocation TemplateKeywordLoc, | |
| TemplateName Name, SourceLocation NameLoc) { | |
| TemplateName TN = getDerived().TransformTemplateName( | |
| QualifierLoc, TemplateKeywordLoc, Name, NameLoc); | |
| if (TN.isNull()) | |
| return TemplateArgument(); | |
| return TemplateArgument(TN); | |
| } | |
| template<typename Derived> | |
| void TreeTransform<Derived>::InventTemplateArgumentLoc( | |
| const TemplateArgument &Arg, | |
| TemplateArgumentLoc &Output) { | |
| Output = getSema().getTrivialTemplateArgumentLoc( | |
| Arg, QualType(), getDerived().getBaseLocation()); | |
| } | |
| template <typename Derived> | |
| bool TreeTransform<Derived>::TransformTemplateArgument( | |
| const TemplateArgumentLoc &Input, TemplateArgumentLoc &Output, | |
| bool Uneval) { | |
| const TemplateArgument &Arg = Input.getArgument(); | |
| switch (Arg.getKind()) { | |
| case TemplateArgument::Null: | |
| case TemplateArgument::Pack: | |
| llvm_unreachable("Unexpected TemplateArgument"); | |
| case TemplateArgument::Integral: | |
| case TemplateArgument::NullPtr: | |
| case TemplateArgument::Declaration: | |
| case TemplateArgument::StructuralValue: { | |
| // Transform a resolved template argument straight to a resolved template | |
| // argument. We get here when substituting into an already-substituted | |
| // template type argument during concept satisfaction checking. | |
| QualType T = Arg.getNonTypeTemplateArgumentType(); | |
| QualType NewT = getDerived().TransformType(T); | |
| if (NewT.isNull()) | |
| return true; | |
| ValueDecl *D = Arg.getKind() == TemplateArgument::Declaration | |
| ? Arg.getAsDecl() | |
| : nullptr; | |
| ValueDecl *NewD = D ? cast_or_null<ValueDecl>(getDerived().TransformDecl( | |
| getDerived().getBaseLocation(), D)) | |
| : nullptr; | |
| if (D && !NewD) | |
| return true; | |
| if (NewT == T && D == NewD) | |
| Output = Input; | |
| else if (Arg.getKind() == TemplateArgument::Integral) | |
| Output = TemplateArgumentLoc( | |
| TemplateArgument(getSema().Context, Arg.getAsIntegral(), NewT), | |
| TemplateArgumentLocInfo()); | |
| else if (Arg.getKind() == TemplateArgument::NullPtr) | |
| Output = TemplateArgumentLoc(TemplateArgument(NewT, /*IsNullPtr=*/true), | |
| TemplateArgumentLocInfo()); | |
| else if (Arg.getKind() == TemplateArgument::Declaration) | |
| Output = TemplateArgumentLoc(TemplateArgument(NewD, NewT), | |
| TemplateArgumentLocInfo()); | |
| else if (Arg.getKind() == TemplateArgument::StructuralValue) | |
| Output = TemplateArgumentLoc( | |
| TemplateArgument(getSema().Context, NewT, Arg.getAsStructuralValue()), | |
| TemplateArgumentLocInfo()); | |
| else | |
| llvm_unreachable("unexpected template argument kind"); | |
| return false; | |
| } | |
| case TemplateArgument::Type: { | |
| TypeSourceInfo *TSI = Input.getTypeSourceInfo(); | |
| if (!TSI) | |
| TSI = InventTypeSourceInfo(Input.getArgument().getAsType()); | |
| TSI = getDerived().TransformType(TSI); | |
| if (!TSI) | |
| return true; | |
| Output = TemplateArgumentLoc(TemplateArgument(TSI->getType()), TSI); | |
| return false; | |
| } | |
| case TemplateArgument::Template: { | |
| NestedNameSpecifierLoc QualifierLoc = Input.getTemplateQualifierLoc(); | |
| TemplateArgument Out = getDerived().TransformNamedTemplateTemplateArgument( | |
| QualifierLoc, Input.getTemplateKWLoc(), Arg.getAsTemplate(), | |
| Input.getTemplateNameLoc()); | |
| if (Out.isNull()) | |
| return true; | |
| Output = TemplateArgumentLoc(SemaRef.Context, Out, Input.getTemplateKWLoc(), | |
| QualifierLoc, Input.getTemplateNameLoc()); | |
| return false; | |
| } | |
| case TemplateArgument::TemplateExpansion: | |
| llvm_unreachable("Caller should expand pack expansions"); | |
| case TemplateArgument::Expression: { | |
| // Template argument expressions are constant expressions. | |
| EnterExpressionEvaluationContext Unevaluated( | |
| getSema(), | |
| Uneval ? Sema::ExpressionEvaluationContext::Unevaluated | |
| : Sema::ExpressionEvaluationContext::ConstantEvaluated, | |
| Sema::ReuseLambdaContextDecl, /*ExprContext=*/ | |
| Sema::ExpressionEvaluationContextRecord::EK_TemplateArgument); | |
| Expr *InputExpr = Input.getSourceExpression(); | |
| if (!InputExpr) | |
| InputExpr = Input.getArgument().getAsExpr(); | |
| ExprResult E = getDerived().TransformExpr(InputExpr); | |
| E = SemaRef.ActOnConstantExpression(E); | |
| if (E.isInvalid()) | |
| return true; | |
| Output = TemplateArgumentLoc( | |
| TemplateArgument(E.get(), /*IsCanonical=*/false), E.get()); | |
| return false; | |
| } | |
| } | |
| // Work around bogus GCC warning | |
| return true; | |
| } | |
| /// Iterator adaptor that invents template argument location information | |
| /// for each of the template arguments in its underlying iterator. | |
| template<typename Derived, typename InputIterator> | |
| class TemplateArgumentLocInventIterator { | |
| TreeTransform<Derived> &Self; | |
| InputIterator Iter; | |
| public: | |
| typedef TemplateArgumentLoc value_type; | |
| typedef TemplateArgumentLoc reference; | |
| typedef typename std::iterator_traits<InputIterator>::difference_type | |
| difference_type; | |
| typedef std::input_iterator_tag iterator_category; | |
| class pointer { | |
| TemplateArgumentLoc Arg; | |
| public: | |
| explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { } | |
| const TemplateArgumentLoc *operator->() const { return &Arg; } | |
| }; | |
| explicit TemplateArgumentLocInventIterator(TreeTransform<Derived> &Self, | |
| InputIterator Iter) | |
| : Self(Self), Iter(Iter) { } | |
| TemplateArgumentLocInventIterator &operator++() { | |
| ++Iter; | |
| return *this; | |
| } | |
| TemplateArgumentLocInventIterator operator++(int) { | |
| TemplateArgumentLocInventIterator Old(*this); | |
| ++(*this); | |
| return Old; | |
| } | |
| reference operator*() const { | |
| TemplateArgumentLoc Result; | |
| Self.InventTemplateArgumentLoc(*Iter, Result); | |
| return Result; | |
| } | |
| pointer operator->() const { return pointer(**this); } | |
| friend bool operator==(const TemplateArgumentLocInventIterator &X, | |
| const TemplateArgumentLocInventIterator &Y) { | |
| return X.Iter == Y.Iter; | |
| } | |
| friend bool operator!=(const TemplateArgumentLocInventIterator &X, | |
| const TemplateArgumentLocInventIterator &Y) { | |
| return X.Iter != Y.Iter; | |
| } | |
| }; | |
| template<typename Derived> | |
| template<typename InputIterator> | |
| bool TreeTransform<Derived>::TransformTemplateArguments( | |
| InputIterator First, InputIterator Last, TemplateArgumentListInfo &Outputs, | |
| bool Uneval) { | |
| for (TemplateArgumentLoc In : llvm::make_range(First, Last)) { | |
| TemplateArgumentLoc Out; | |
| if (In.getArgument().getKind() == TemplateArgument::Pack) { | |
| // Unpack argument packs, which we translate them into separate | |
| // arguments. | |
| // FIXME: We could do much better if we could guarantee that the | |
| // TemplateArgumentLocInfo for the pack expansion would be usable for | |
| // all of the template arguments in the argument pack. | |
| typedef TemplateArgumentLocInventIterator<Derived, | |
| TemplateArgument::pack_iterator> | |
| PackLocIterator; | |
| TemplateArgumentListInfo *PackOutput = &Outputs; | |
| TemplateArgumentListInfo New; | |
| if (TransformTemplateArguments( | |
| PackLocIterator(*this, In.getArgument().pack_begin()), | |
| PackLocIterator(*this, In.getArgument().pack_end()), *PackOutput, | |
| Uneval)) | |
| return true; | |
| continue; | |
| } | |
| if (In.getArgument().isPackExpansion()) { | |
| UnexpandedInfo Info; | |
| TemplateArgumentLoc Prepared; | |
| if (getDerived().PreparePackForExpansion(In, Uneval, Prepared, Info)) | |
| return true; | |
| if (!Info.Expand) { | |
| Outputs.addArgument(Prepared); | |
| continue; | |
| } | |
| // The transform has determined that we should perform an elementwise | |
| // expansion of the pattern. Do so. | |
| std::optional<ForgetSubstitutionRAII> ForgetSubst; | |
| if (Info.ExpandUnderForgetSubstitions) | |
| ForgetSubst.emplace(getDerived()); | |
| for (unsigned I = 0; I != *Info.NumExpansions; ++I) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); | |
| TemplateArgumentLoc Out; | |
| if (getDerived().TransformTemplateArgument(Prepared, Out, Uneval)) | |
| return true; | |
| if (Out.getArgument().containsUnexpandedParameterPack()) { | |
| Out = getDerived().RebuildPackExpansion(Out, Info.Ellipsis, | |
| Info.OrigNumExpansions); | |
| if (Out.getArgument().isNull()) | |
| return true; | |
| } | |
| Outputs.addArgument(Out); | |
| } | |
| // If we're supposed to retain a pack expansion, do so by temporarily | |
| // forgetting the partially-substituted parameter pack. | |
| if (Info.RetainExpansion) { | |
| ForgetPartiallySubstitutedPackRAII Forget(getDerived()); | |
| TemplateArgumentLoc Out; | |
| if (getDerived().TransformTemplateArgument(Prepared, Out, Uneval)) | |
| return true; | |
| Out = getDerived().RebuildPackExpansion(Out, Info.Ellipsis, | |
| Info.OrigNumExpansions); | |
| if (Out.getArgument().isNull()) | |
| return true; | |
| Outputs.addArgument(Out); | |
| } | |
| continue; | |
| } | |
| // The simple case: | |
| if (getDerived().TransformTemplateArgument(In, Out, Uneval)) | |
| return true; | |
| Outputs.addArgument(Out); | |
| } | |
| return false; | |
| } | |
| template <typename Derived> | |
| template <typename InputIterator> | |
| bool TreeTransform<Derived>::TransformConceptTemplateArguments( | |
| InputIterator First, InputIterator Last, TemplateArgumentListInfo &Outputs, | |
| bool Uneval) { | |
| // [C++26][temp.constr.normal] | |
| // any non-dependent concept template argument | |
| // is substituted into the constraint-expression of C. | |
| auto isNonDependentConceptArgument = [](const TemplateArgument &Arg) { | |
| return !Arg.isDependent() && Arg.isConceptOrConceptTemplateParameter(); | |
| }; | |
| for (; First != Last; ++First) { | |
| TemplateArgumentLoc Out; | |
| TemplateArgumentLoc In = *First; | |
| if (In.getArgument().getKind() == TemplateArgument::Pack) { | |
| typedef TemplateArgumentLocInventIterator<Derived, | |
| TemplateArgument::pack_iterator> | |
| PackLocIterator; | |
| if (TransformConceptTemplateArguments( | |
| PackLocIterator(*this, In.getArgument().pack_begin()), | |
| PackLocIterator(*this, In.getArgument().pack_end()), Outputs, | |
| Uneval)) | |
| return true; | |
| continue; | |
| } | |
| if (!isNonDependentConceptArgument(In.getArgument())) { | |
| Outputs.addArgument(In); | |
| continue; | |
| } | |
| if (getDerived().TransformTemplateArgument(In, Out, Uneval)) | |
| return true; | |
| Outputs.addArgument(Out); | |
| } | |
| return false; | |
| } | |
| // FIXME: Find ways to reduce code duplication for pack expansions. | |
| template <typename Derived> | |
| bool TreeTransform<Derived>::PreparePackForExpansion(TemplateArgumentLoc In, | |
| bool Uneval, | |
| TemplateArgumentLoc &Out, | |
| UnexpandedInfo &Info) { | |
| auto ComputeInfo = [this](TemplateArgumentLoc Arg, | |
| bool IsLateExpansionAttempt, UnexpandedInfo &Info, | |
| TemplateArgumentLoc &Pattern) { | |
| assert(Arg.getArgument().isPackExpansion()); | |
| // We have a pack expansion, for which we will be substituting into the | |
| // pattern. | |
| Pattern = getSema().getTemplateArgumentPackExpansionPattern( | |
| Arg, Info.Ellipsis, Info.OrigNumExpansions); | |
| SmallVector<UnexpandedParameterPack, 2> Unexpanded; | |
| getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); | |
| if (IsLateExpansionAttempt) { | |
| // Request expansion only when there is an opportunity to expand a pack | |
| // that required a substituion first. | |
| bool SawPackTypes = | |
| llvm::any_of(Unexpanded, [](UnexpandedParameterPack P) { | |
| return isa<const SubstBuiltinTemplatePackType *>(P.first); | |
| }); | |
| if (!SawPackTypes) { | |
| Info.Expand = false; | |
| return false; | |
| } | |
| } | |
| assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); | |
| // Determine whether the set of unexpanded parameter packs can and | |
| // should be expanded. | |
| Info.Expand = true; | |
| Info.RetainExpansion = false; | |
| Info.NumExpansions = Info.OrigNumExpansions; | |
| return getDerived().TryExpandParameterPacks( | |
| Info.Ellipsis, Pattern.getSourceRange(), Unexpanded, | |
| /*FailOnPackProducingTemplates=*/false, Info.Expand, | |
| Info.RetainExpansion, Info.NumExpansions); | |
| }; | |
| TemplateArgumentLoc Pattern; | |
| if (ComputeInfo(In, false, Info, Pattern)) | |
| return true; | |
| if (Info.Expand) { | |
| Out = Pattern; | |
| return false; | |
| } | |
| // The transform has determined that we should perform a simple | |
| // transformation on the pack expansion, producing another pack | |
| // expansion. | |
| TemplateArgumentLoc OutPattern; | |
| std::optional<Sema::ArgPackSubstIndexRAII> SubstIndex( | |
| std::in_place, getSema(), std::nullopt); | |
| if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval)) | |
| return true; | |
| Out = getDerived().RebuildPackExpansion(OutPattern, Info.Ellipsis, | |
| Info.NumExpansions); | |
| if (Out.getArgument().isNull()) | |
| return true; | |
| SubstIndex.reset(); | |
| if (!OutPattern.getArgument().containsUnexpandedParameterPack()) | |
| return false; | |
| // Some packs will learn their length after substitution, e.g. | |
| // __builtin_dedup_pack<T,int> has size 1 or 2, depending on the substitution | |
| // value of `T`. | |
| // | |
| // We only expand after we know sizes of all packs, check if this is the case | |
| // or not. However, we avoid a full template substitution and only do | |
| // expanstions after this point. | |
| // E.g. when substituting template arguments of tuple with {T -> int} in the | |
| // following example: | |
| // template <class T> | |
| // struct TupleWithInt { | |
| // using type = std::tuple<__builtin_dedup_pack<T, int>...>; | |
| // }; | |
| // TupleWithInt<int>::type y; | |
| // At this point we will see the `__builtin_dedup_pack<int, int>` with a known | |
| // length and run `ComputeInfo()` to provide the necessary information to our | |
| // caller. | |
| // | |
| // Note that we may still have situations where builtin is not going to be | |
| // expanded. For example: | |
| // template <class T> | |
| // struct Foo { | |
| // template <class U> using tuple_with_t = | |
| // std::tuple<__builtin_dedup_pack<T, U, int>...>; using type = | |
| // tuple_with_t<short>; | |
| // } | |
| // Because the substitution into `type` happens in dependent context, `type` | |
| // will be `tuple<builtin_dedup_pack<T, short, int>...>` after substitution | |
| // and the caller will not be able to expand it. | |
| ForgetSubstitutionRAII ForgetSubst(getDerived()); | |
| if (ComputeInfo(Out, true, Info, OutPattern)) | |
| return true; | |
| if (!Info.Expand) | |
| return false; | |
| Out = OutPattern; | |
| Info.ExpandUnderForgetSubstitions = true; | |
| return false; | |
| } | |
| //===----------------------------------------------------------------------===// | |
| // Type transformation | |
| //===----------------------------------------------------------------------===// | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformType(QualType T) { | |
| if (getDerived().AlreadyTransformed(T)) | |
| return T; | |
| // Temporary workaround. All of these transformations should | |
| // eventually turn into transformations on TypeLocs. | |
| TypeSourceInfo *TSI = getSema().Context.getTrivialTypeSourceInfo( | |
| T, getDerived().getBaseLocation()); | |
| TypeSourceInfo *NewTSI = getDerived().TransformType(TSI); | |
| if (!NewTSI) | |
| return QualType(); | |
| return NewTSI->getType(); | |
| } | |
| template <typename Derived> | |
| TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *TSI) { | |
| // Refine the base location to the type's location. | |
| TemporaryBase Rebase(*this, TSI->getTypeLoc().getBeginLoc(), | |
| getDerived().getBaseEntity()); | |
| if (getDerived().AlreadyTransformed(TSI->getType())) | |
| return TSI; | |
| TypeLocBuilder TLB; | |
| TypeLoc TL = TSI->getTypeLoc(); | |
| TLB.reserve(TL.getFullDataSize()); | |
| QualType Result = getDerived().TransformType(TLB, TL); | |
| if (Result.isNull()) | |
| return nullptr; | |
| return TLB.getTypeSourceInfo(SemaRef.Context, Result); | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) { | |
| switch (T.getTypeLocClass()) { | |
| #define ABSTRACT_TYPELOC(CLASS, PARENT) | |
| #define TYPELOC(CLASS, PARENT) \ | |
| case TypeLoc::CLASS: \ | |
| return getDerived().Transform##CLASS##Type(TLB, \ | |
| T.castAs<CLASS##TypeLoc>()); | |
| #include "clang/AST/TypeLocNodes.def" | |
| } | |
| llvm_unreachable("unhandled type loc!"); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformTypeWithDeducedTST(QualType T) { | |
| if (!isa<DependentNameType>(T)) | |
| return TransformType(T); | |
| if (getDerived().AlreadyTransformed(T)) | |
| return T; | |
| TypeSourceInfo *TSI = getSema().Context.getTrivialTypeSourceInfo( | |
| T, getDerived().getBaseLocation()); | |
| TypeSourceInfo *NewTSI = getDerived().TransformTypeWithDeducedTST(TSI); | |
| return NewTSI ? NewTSI->getType() : QualType(); | |
| } | |
| template <typename Derived> | |
| TypeSourceInfo * | |
| TreeTransform<Derived>::TransformTypeWithDeducedTST(TypeSourceInfo *TSI) { | |
| if (!isa<DependentNameType>(TSI->getType())) | |
| return TransformType(TSI); | |
| // Refine the base location to the type's location. | |
| TemporaryBase Rebase(*this, TSI->getTypeLoc().getBeginLoc(), | |
| getDerived().getBaseEntity()); | |
| if (getDerived().AlreadyTransformed(TSI->getType())) | |
| return TSI; | |
| TypeLocBuilder TLB; | |
| TypeLoc TL = TSI->getTypeLoc(); | |
| TLB.reserve(TL.getFullDataSize()); | |
| auto QTL = TL.getAs<QualifiedTypeLoc>(); | |
| if (QTL) | |
| TL = QTL.getUnqualifiedLoc(); | |
| auto DNTL = TL.castAs<DependentNameTypeLoc>(); | |
| QualType Result = getDerived().TransformDependentNameType( | |
| TLB, DNTL, /*DeducedTSTContext*/true); | |
| if (Result.isNull()) | |
| return nullptr; | |
| if (QTL) { | |
| Result = getDerived().RebuildQualifiedType(Result, QTL); | |
| if (Result.isNull()) | |
| return nullptr; | |
| TLB.TypeWasModifiedSafely(Result); | |
| } | |
| return TLB.getTypeSourceInfo(SemaRef.Context, Result); | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB, | |
| QualifiedTypeLoc T) { | |
| QualType Result; | |
| TypeLoc UnqualTL = T.getUnqualifiedLoc(); | |
| auto SuppressObjCLifetime = | |
| T.getType().getLocalQualifiers().hasObjCLifetime(); | |
| if (auto TTP = UnqualTL.getAs<TemplateTypeParmTypeLoc>()) { | |
| Result = getDerived().TransformTemplateTypeParmType(TLB, TTP, | |
| SuppressObjCLifetime); | |
| } else if (auto STTP = UnqualTL.getAs<SubstTemplateTypeParmPackTypeLoc>()) { | |
| Result = getDerived().TransformSubstTemplateTypeParmPackType( | |
| TLB, STTP, SuppressObjCLifetime); | |
| } else { | |
| Result = getDerived().TransformType(TLB, UnqualTL); | |
| } | |
| if (Result.isNull()) | |
| return QualType(); | |
| Result = getDerived().RebuildQualifiedType(Result, T); | |
| if (Result.isNull()) | |
| return QualType(); | |
| // RebuildQualifiedType might have updated the type, but not in a way | |
| // that invalidates the TypeLoc. (There's no location information for | |
| // qualifiers.) | |
| TLB.TypeWasModifiedSafely(Result); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildQualifiedType(QualType T, | |
| QualifiedTypeLoc TL) { | |
| SourceLocation Loc = TL.getBeginLoc(); | |
| Qualifiers Quals = TL.getType().getLocalQualifiers(); | |
| if ((T.getAddressSpace() != LangAS::Default && | |
| Quals.getAddressSpace() != LangAS::Default) && | |
| T.getAddressSpace() != Quals.getAddressSpace()) { | |
| SemaRef.Diag(Loc, diag::err_address_space_mismatch_templ_inst) | |
| << TL.getType() << T; | |
| return QualType(); | |
| } | |
| PointerAuthQualifier LocalPointerAuth = Quals.getPointerAuth(); | |
| if (LocalPointerAuth.isPresent()) { | |
| if (T.getPointerAuth().isPresent()) { | |
| SemaRef.Diag(Loc, diag::err_ptrauth_qualifier_redundant) << TL.getType(); | |
| return QualType(); | |
| } | |
| if (!T->isDependentType()) { | |
| if (!T->isSignableType(SemaRef.getASTContext())) { | |
| SemaRef.Diag(Loc, diag::err_ptrauth_qualifier_invalid_target) << T; | |
| return QualType(); | |
| } | |
| } | |
| } | |
| // C++ [dcl.fct]p7: | |
| // [When] adding cv-qualifications on top of the function type [...] the | |
| // cv-qualifiers are ignored. | |
| if (T->isFunctionType()) { | |
| T = SemaRef.getASTContext().getAddrSpaceQualType(T, | |
| Quals.getAddressSpace()); | |
| return T; | |
| } | |
| // C++ [dcl.ref]p1: | |
| // when the cv-qualifiers are introduced through the use of a typedef-name | |
| // or decltype-specifier [...] the cv-qualifiers are ignored. | |
| // Note that [dcl.ref]p1 lists all cases in which cv-qualifiers can be | |
| // applied to a reference type. | |
| if (T->isReferenceType()) { | |
| // The only qualifier that applies to a reference type is restrict. | |
| if (!Quals.hasRestrict()) | |
| return T; | |
| Quals = Qualifiers::fromCVRMask(Qualifiers::Restrict); | |
| } | |
| // Suppress Objective-C lifetime qualifiers if they don't make sense for the | |
| // resulting type. | |
| if (Quals.hasObjCLifetime()) { | |
| if (!T->isObjCLifetimeType() && !T->isDependentType()) | |
| Quals.removeObjCLifetime(); | |
| else if (T.getObjCLifetime()) { | |
| // Objective-C ARC: | |
| // A lifetime qualifier applied to a substituted template parameter | |
| // overrides the lifetime qualifier from the template argument. | |
| const AutoType *AutoTy; | |
| if ((AutoTy = dyn_cast<AutoType>(T)) && AutoTy->isDeduced()) { | |
| // 'auto' types behave the same way as template parameters. | |
| QualType Deduced = AutoTy->getDeducedType(); | |
| Qualifiers Qs = Deduced.getQualifiers(); | |
| Qs.removeObjCLifetime(); | |
| Deduced = | |
| SemaRef.Context.getQualifiedType(Deduced.getUnqualifiedType(), Qs); | |
| T = SemaRef.Context.getAutoType(AutoTy->getDeducedKind(), Deduced, | |
| AutoTy->getKeyword(), | |
| AutoTy->getTypeConstraintConcept(), | |
| AutoTy->getTypeConstraintArguments()); | |
| } else { | |
| // Otherwise, complain about the addition of a qualifier to an | |
| // already-qualified type. | |
| // FIXME: Why is this check not in Sema::BuildQualifiedType? | |
| SemaRef.Diag(Loc, diag::err_attr_objc_ownership_redundant) << T; | |
| Quals.removeObjCLifetime(); | |
| } | |
| } | |
| } | |
| return SemaRef.BuildQualifiedType(T, Loc, Quals); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformTypeInObjectScope( | |
| TypeLocBuilder &TLB, TypeLoc TL, QualType ObjectType, | |
| NamedDecl *FirstQualifierInScope) { | |
| assert(!getDerived().AlreadyTransformed(TL.getType())); | |
| switch (TL.getTypeLocClass()) { | |
| case TypeLoc::TemplateSpecialization: | |
| return getDerived().TransformTemplateSpecializationType( | |
| TLB, TL.castAs<TemplateSpecializationTypeLoc>(), ObjectType, | |
| FirstQualifierInScope, /*AllowInjectedClassName=*/true); | |
| case TypeLoc::DependentName: | |
| return getDerived().TransformDependentNameType( | |
| TLB, TL.castAs<DependentNameTypeLoc>(), /*DeducedTSTContext=*/false, | |
| ObjectType, FirstQualifierInScope); | |
| default: | |
| // Any dependent canonical type can appear here, through type alias | |
| // templates. | |
| return getDerived().TransformType(TLB, TL); | |
| } | |
| } | |
| template <class TyLoc> static inline | |
| QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) { | |
| TyLoc NewT = TLB.push<TyLoc>(T.getType()); | |
| NewT.setNameLoc(T.getNameLoc()); | |
| return T.getType(); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB, | |
| BuiltinTypeLoc T) { | |
| BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType()); | |
| NewT.setBuiltinLoc(T.getBuiltinLoc()); | |
| if (T.needsExtraLocalData()) | |
| NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs(); | |
| return T.getType(); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB, | |
| ComplexTypeLoc T) { | |
| // FIXME: recurse? | |
| return TransformTypeSpecType(TLB, T); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB, | |
| AdjustedTypeLoc TL) { | |
| // Adjustments applied during transformation are handled elsewhere. | |
| return getDerived().TransformType(TLB, TL.getOriginalLoc()); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB, | |
| DecayedTypeLoc TL) { | |
| QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc()); | |
| if (OriginalType.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| OriginalType != TL.getOriginalLoc().getType()) | |
| Result = SemaRef.Context.getDecayedType(OriginalType); | |
| TLB.push<DecayedTypeLoc>(Result); | |
| // Nothing to set for DecayedTypeLoc. | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformArrayParameterType(TypeLocBuilder &TLB, | |
| ArrayParameterTypeLoc TL) { | |
| QualType OriginalType = getDerived().TransformType(TLB, TL.getElementLoc()); | |
| if (OriginalType.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| OriginalType != TL.getElementLoc().getType()) | |
| Result = SemaRef.Context.getArrayParameterType(OriginalType); | |
| TLB.push<ArrayParameterTypeLoc>(Result); | |
| // Nothing to set for ArrayParameterTypeLoc. | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB, | |
| PointerTypeLoc TL) { | |
| QualType PointeeType | |
| = getDerived().TransformType(TLB, TL.getPointeeLoc()); | |
| if (PointeeType.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (PointeeType->getAs<ObjCObjectType>()) { | |
| // A dependent pointer type 'T *' has is being transformed such | |
| // that an Objective-C class type is being replaced for 'T'. The | |
| // resulting pointer type is an ObjCObjectPointerType, not a | |
| // PointerType. | |
| Result = SemaRef.Context.getObjCObjectPointerType(PointeeType); | |
| ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result); | |
| NewT.setStarLoc(TL.getStarLoc()); | |
| return Result; | |
| } | |
| if (getDerived().AlwaysRebuild() || | |
| PointeeType != TL.getPointeeLoc().getType()) { | |
| Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| // Objective-C ARC can add lifetime qualifiers to the type that we're | |
| // pointing to. | |
| TLB.TypeWasModifiedSafely(Result->getPointeeType()); | |
| PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result); | |
| NewT.setSigilLoc(TL.getSigilLoc()); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB, | |
| BlockPointerTypeLoc TL) { | |
| QualType PointeeType | |
| = getDerived().TransformType(TLB, TL.getPointeeLoc()); | |
| if (PointeeType.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| PointeeType != TL.getPointeeLoc().getType()) { | |
| Result = getDerived().RebuildBlockPointerType(PointeeType, | |
| TL.getSigilLoc()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result); | |
| NewT.setSigilLoc(TL.getSigilLoc()); | |
| return Result; | |
| } | |
| /// Transforms a reference type. Note that somewhat paradoxically we | |
| /// don't care whether the type itself is an l-value type or an r-value | |
| /// type; we only care if the type was *written* as an l-value type | |
| /// or an r-value type. | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB, | |
| ReferenceTypeLoc TL) { | |
| const ReferenceType *T = TL.getTypePtr(); | |
| // Note that this works with the pointee-as-written. | |
| QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); | |
| if (PointeeType.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| PointeeType != T->getPointeeTypeAsWritten()) { | |
| Result = getDerived().RebuildReferenceType(PointeeType, | |
| T->isSpelledAsLValue(), | |
| TL.getSigilLoc()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| // Objective-C ARC can add lifetime qualifiers to the type that we're | |
| // referring to. | |
| TLB.TypeWasModifiedSafely( | |
| Result->castAs<ReferenceType>()->getPointeeTypeAsWritten()); | |
| // r-value references can be rebuilt as l-value references. | |
| ReferenceTypeLoc NewTL; | |
| if (isa<LValueReferenceType>(Result)) | |
| NewTL = TLB.push<LValueReferenceTypeLoc>(Result); | |
| else | |
| NewTL = TLB.push<RValueReferenceTypeLoc>(Result); | |
| NewTL.setSigilLoc(TL.getSigilLoc()); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB, | |
| LValueReferenceTypeLoc TL) { | |
| return TransformReferenceType(TLB, TL); | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB, | |
| RValueReferenceTypeLoc TL) { | |
| return TransformReferenceType(TLB, TL); | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB, | |
| MemberPointerTypeLoc TL) { | |
| QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); | |
| if (PointeeType.isNull()) | |
| return QualType(); | |
| const MemberPointerType *T = TL.getTypePtr(); | |
| NestedNameSpecifierLoc OldQualifierLoc = TL.getQualifierLoc(); | |
| NestedNameSpecifierLoc NewQualifierLoc = | |
| getDerived().TransformNestedNameSpecifierLoc(OldQualifierLoc); | |
| if (!NewQualifierLoc) | |
| return QualType(); | |
| CXXRecordDecl *OldCls = T->getMostRecentCXXRecordDecl(), *NewCls = nullptr; | |
| if (OldCls) { | |
| NewCls = cast_or_null<CXXRecordDecl>( | |
| getDerived().TransformDecl(TL.getStarLoc(), OldCls)); | |
| if (!NewCls) | |
| return QualType(); | |
| } | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || PointeeType != T->getPointeeType() || | |
| NewQualifierLoc.getNestedNameSpecifier() != | |
| OldQualifierLoc.getNestedNameSpecifier() || | |
| NewCls != OldCls) { | |
| CXXScopeSpec SS; | |
| SS.Adopt(NewQualifierLoc); | |
| Result = getDerived().RebuildMemberPointerType(PointeeType, SS, NewCls, | |
| TL.getStarLoc()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| // If we had to adjust the pointee type when building a member pointer, make | |
| // sure to push TypeLoc info for it. | |
| const MemberPointerType *MPT = Result->getAs<MemberPointerType>(); | |
| if (MPT && PointeeType != MPT->getPointeeType()) { | |
| assert(isa<AdjustedType>(MPT->getPointeeType())); | |
| TLB.push<AdjustedTypeLoc>(MPT->getPointeeType()); | |
| } | |
| MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result); | |
| NewTL.setSigilLoc(TL.getSigilLoc()); | |
| NewTL.setQualifierLoc(NewQualifierLoc); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB, | |
| ConstantArrayTypeLoc TL) { | |
| const ConstantArrayType *T = TL.getTypePtr(); | |
| QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); | |
| if (ElementType.isNull()) | |
| return QualType(); | |
| // Prefer the expression from the TypeLoc; the other may have been uniqued. | |
| Expr *OldSize = TL.getSizeExpr(); | |
| if (!OldSize) | |
| OldSize = const_cast<Expr*>(T->getSizeExpr()); | |
| Expr *NewSize = nullptr; | |
| if (OldSize) { | |
| EnterExpressionEvaluationContext Unevaluated( | |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); | |
| NewSize = getDerived().TransformExpr(OldSize).template getAs<Expr>(); | |
| NewSize = SemaRef.ActOnConstantExpression(NewSize).get(); | |
| } | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| ElementType != T->getElementType() || | |
| (T->getSizeExpr() && NewSize != OldSize)) { | |
| Result = getDerived().RebuildConstantArrayType(ElementType, | |
| T->getSizeModifier(), | |
| T->getSize(), NewSize, | |
| T->getIndexTypeCVRQualifiers(), | |
| TL.getBracketsRange()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| // We might have either a ConstantArrayType or a VariableArrayType now: | |
| // a ConstantArrayType is allowed to have an element type which is a | |
| // VariableArrayType if the type is dependent. Fortunately, all array | |
| // types have the same location layout. | |
| ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); | |
| NewTL.setLBracketLoc(TL.getLBracketLoc()); | |
| NewTL.setRBracketLoc(TL.getRBracketLoc()); | |
| NewTL.setSizeExpr(NewSize); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformIncompleteArrayType( | |
| TypeLocBuilder &TLB, | |
| IncompleteArrayTypeLoc TL) { | |
| const IncompleteArrayType *T = TL.getTypePtr(); | |
| QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); | |
| if (ElementType.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| ElementType != T->getElementType()) { | |
| Result = getDerived().RebuildIncompleteArrayType(ElementType, | |
| T->getSizeModifier(), | |
| T->getIndexTypeCVRQualifiers(), | |
| TL.getBracketsRange()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result); | |
| NewTL.setLBracketLoc(TL.getLBracketLoc()); | |
| NewTL.setRBracketLoc(TL.getRBracketLoc()); | |
| NewTL.setSizeExpr(nullptr); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB, | |
| VariableArrayTypeLoc TL) { | |
| const VariableArrayType *T = TL.getTypePtr(); | |
| QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); | |
| if (ElementType.isNull()) | |
| return QualType(); | |
| ExprResult SizeResult; | |
| { | |
| EnterExpressionEvaluationContext Context( | |
| SemaRef, Sema::ExpressionEvaluationContext::PotentiallyEvaluated); | |
| SizeResult = getDerived().TransformExpr(T->getSizeExpr()); | |
| } | |
| if (SizeResult.isInvalid()) | |
| return QualType(); | |
| SizeResult = | |
| SemaRef.ActOnFinishFullExpr(SizeResult.get(), /*DiscardedValue*/ false); | |
| if (SizeResult.isInvalid()) | |
| return QualType(); | |
| Expr *Size = SizeResult.get(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| ElementType != T->getElementType() || | |
| Size != T->getSizeExpr()) { | |
| Result = getDerived().RebuildVariableArrayType(ElementType, | |
| T->getSizeModifier(), | |
| Size, | |
| T->getIndexTypeCVRQualifiers(), | |
| TL.getBracketsRange()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| // We might have constant size array now, but fortunately it has the same | |
| // location layout. | |
| ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); | |
| NewTL.setLBracketLoc(TL.getLBracketLoc()); | |
| NewTL.setRBracketLoc(TL.getRBracketLoc()); | |
| NewTL.setSizeExpr(Size); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB, | |
| DependentSizedArrayTypeLoc TL) { | |
| const DependentSizedArrayType *T = TL.getTypePtr(); | |
| QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); | |
| if (ElementType.isNull()) | |
| return QualType(); | |
| // Array bounds are constant expressions. | |
| EnterExpressionEvaluationContext Unevaluated( | |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); | |
| // If we have a VLA then it won't be a constant. | |
| SemaRef.ExprEvalContexts.back().InConditionallyConstantEvaluateContext = true; | |
| // Prefer the expression from the TypeLoc; the other may have been uniqued. | |
| Expr *origSize = TL.getSizeExpr(); | |
| if (!origSize) origSize = T->getSizeExpr(); | |
| ExprResult sizeResult | |
| = getDerived().TransformExpr(origSize); | |
| sizeResult = SemaRef.ActOnConstantExpression(sizeResult); | |
| if (sizeResult.isInvalid()) | |
| return QualType(); | |
| Expr *size = sizeResult.get(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| ElementType != T->getElementType() || | |
| size != origSize) { | |
| Result = getDerived().RebuildDependentSizedArrayType(ElementType, | |
| T->getSizeModifier(), | |
| size, | |
| T->getIndexTypeCVRQualifiers(), | |
| TL.getBracketsRange()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| // We might have any sort of array type now, but fortunately they | |
| // all have the same location layout. | |
| ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); | |
| NewTL.setLBracketLoc(TL.getLBracketLoc()); | |
| NewTL.setRBracketLoc(TL.getRBracketLoc()); | |
| NewTL.setSizeExpr(size); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformDependentVectorType( | |
| TypeLocBuilder &TLB, DependentVectorTypeLoc TL) { | |
| const DependentVectorType *T = TL.getTypePtr(); | |
| QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); | |
| if (ElementType.isNull()) | |
| return QualType(); | |
| EnterExpressionEvaluationContext Unevaluated( | |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); | |
| ExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); | |
| Size = SemaRef.ActOnConstantExpression(Size); | |
| if (Size.isInvalid()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || ElementType != T->getElementType() || | |
| Size.get() != T->getSizeExpr()) { | |
| Result = getDerived().RebuildDependentVectorType( | |
| ElementType, Size.get(), T->getAttributeLoc(), T->getVectorKind()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| // Result might be dependent or not. | |
| if (isa<DependentVectorType>(Result)) { | |
| DependentVectorTypeLoc NewTL = | |
| TLB.push<DependentVectorTypeLoc>(Result); | |
| NewTL.setNameLoc(TL.getNameLoc()); | |
| } else { | |
| VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result); | |
| NewTL.setNameLoc(TL.getNameLoc()); | |
| } | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType( | |
| TypeLocBuilder &TLB, | |
| DependentSizedExtVectorTypeLoc TL) { | |
| const DependentSizedExtVectorType *T = TL.getTypePtr(); | |
| // FIXME: ext vector locs should be nested | |
| QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); | |
| if (ElementType.isNull()) | |
| return QualType(); | |
| // Vector sizes are constant expressions. | |
| EnterExpressionEvaluationContext Unevaluated( | |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); | |
| ExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); | |
| Size = SemaRef.ActOnConstantExpression(Size); | |
| if (Size.isInvalid()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| ElementType != T->getElementType() || | |
| Size.get() != T->getSizeExpr()) { | |
| Result = getDerived().RebuildDependentSizedExtVectorType(ElementType, | |
| Size.get(), | |
| T->getAttributeLoc()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| // Result might be dependent or not. | |
| if (isa<DependentSizedExtVectorType>(Result)) { | |
| DependentSizedExtVectorTypeLoc NewTL | |
| = TLB.push<DependentSizedExtVectorTypeLoc>(Result); | |
| NewTL.setNameLoc(TL.getNameLoc()); | |
| } else { | |
| ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); | |
| NewTL.setNameLoc(TL.getNameLoc()); | |
| } | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformConstantMatrixType(TypeLocBuilder &TLB, | |
| ConstantMatrixTypeLoc TL) { | |
| const ConstantMatrixType *T = TL.getTypePtr(); | |
| QualType ElementType = getDerived().TransformType(T->getElementType()); | |
| if (ElementType.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || ElementType != T->getElementType()) { | |
| Result = getDerived().RebuildConstantMatrixType( | |
| ElementType, T->getNumRows(), T->getNumColumns(), TL.getAttrNameLoc()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| ConstantMatrixTypeLoc NewTL = TLB.push<ConstantMatrixTypeLoc>(Result); | |
| NewTL.setAttrNameLoc(TL.getAttrNameLoc()); | |
| NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange()); | |
| NewTL.setAttrRowOperand(TL.getAttrRowOperand()); | |
| NewTL.setAttrColumnOperand(TL.getAttrColumnOperand()); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformDependentSizedMatrixType( | |
| TypeLocBuilder &TLB, DependentSizedMatrixTypeLoc TL) { | |
| const DependentSizedMatrixType *T = TL.getTypePtr(); | |
| QualType ElementType = getDerived().TransformType(T->getElementType()); | |
| if (ElementType.isNull()) { | |
| return QualType(); | |
| } | |
| // Matrix dimensions are constant expressions. | |
| EnterExpressionEvaluationContext Unevaluated( | |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); | |
| Expr *origRows = TL.getAttrRowOperand(); | |
| if (!origRows) | |
| origRows = T->getRowExpr(); | |
| Expr *origColumns = TL.getAttrColumnOperand(); | |
| if (!origColumns) | |
| origColumns = T->getColumnExpr(); | |
| ExprResult rowResult = getDerived().TransformExpr(origRows); | |
| rowResult = SemaRef.ActOnConstantExpression(rowResult); | |
| if (rowResult.isInvalid()) | |
| return QualType(); | |
| ExprResult columnResult = getDerived().TransformExpr(origColumns); | |
| columnResult = SemaRef.ActOnConstantExpression(columnResult); | |
| if (columnResult.isInvalid()) | |
| return QualType(); | |
| Expr *rows = rowResult.get(); | |
| Expr *columns = columnResult.get(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || ElementType != T->getElementType() || | |
| rows != origRows || columns != origColumns) { | |
| Result = getDerived().RebuildDependentSizedMatrixType( | |
| ElementType, rows, columns, T->getAttributeLoc()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| // We might have any sort of matrix type now, but fortunately they | |
| // all have the same location layout. | |
| MatrixTypeLoc NewTL = TLB.push<MatrixTypeLoc>(Result); | |
| NewTL.setAttrNameLoc(TL.getAttrNameLoc()); | |
| NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange()); | |
| NewTL.setAttrRowOperand(rows); | |
| NewTL.setAttrColumnOperand(columns); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformDependentAddressSpaceType( | |
| TypeLocBuilder &TLB, DependentAddressSpaceTypeLoc TL) { | |
| const DependentAddressSpaceType *T = TL.getTypePtr(); | |
| QualType pointeeType = | |
| getDerived().TransformType(TLB, TL.getPointeeTypeLoc()); | |
| if (pointeeType.isNull()) | |
| return QualType(); | |
| // Address spaces are constant expressions. | |
| EnterExpressionEvaluationContext Unevaluated( | |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); | |
| ExprResult AddrSpace = getDerived().TransformExpr(T->getAddrSpaceExpr()); | |
| AddrSpace = SemaRef.ActOnConstantExpression(AddrSpace); | |
| if (AddrSpace.isInvalid()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || pointeeType != T->getPointeeType() || | |
| AddrSpace.get() != T->getAddrSpaceExpr()) { | |
| Result = getDerived().RebuildDependentAddressSpaceType( | |
| pointeeType, AddrSpace.get(), T->getAttributeLoc()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| // Result might be dependent or not. | |
| if (isa<DependentAddressSpaceType>(Result)) { | |
| DependentAddressSpaceTypeLoc NewTL = | |
| TLB.push<DependentAddressSpaceTypeLoc>(Result); | |
| NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange()); | |
| NewTL.setAttrExprOperand(TL.getAttrExprOperand()); | |
| NewTL.setAttrNameLoc(TL.getAttrNameLoc()); | |
| } else { | |
| TLB.TypeWasModifiedSafely(Result); | |
| } | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB, | |
| VectorTypeLoc TL) { | |
| const VectorType *T = TL.getTypePtr(); | |
| QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); | |
| if (ElementType.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| ElementType != T->getElementType()) { | |
| Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(), | |
| T->getVectorKind()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result); | |
| NewTL.setNameLoc(TL.getNameLoc()); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB, | |
| ExtVectorTypeLoc TL) { | |
| const VectorType *T = TL.getTypePtr(); | |
| QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); | |
| if (ElementType.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| ElementType != T->getElementType()) { | |
| Result = getDerived().RebuildExtVectorType(ElementType, | |
| T->getNumElements(), | |
| /*FIXME*/ SourceLocation()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); | |
| NewTL.setNameLoc(TL.getNameLoc()); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam( | |
| ParmVarDecl *OldParm, int indexAdjustment, UnsignedOrNone NumExpansions, | |
| bool ExpectParameterPack) { | |
| TypeSourceInfo *OldTSI = OldParm->getTypeSourceInfo(); | |
| TypeSourceInfo *NewTSI = nullptr; | |
| if (NumExpansions && isa<PackExpansionType>(OldTSI->getType())) { | |
| // If we're substituting into a pack expansion type and we know the | |
| // length we want to expand to, just substitute for the pattern. | |
| TypeLoc OldTL = OldTSI->getTypeLoc(); | |
| PackExpansionTypeLoc OldExpansionTL = OldTL.castAs<PackExpansionTypeLoc>(); | |
| TypeLocBuilder TLB; | |
| TypeLoc NewTL = OldTSI->getTypeLoc(); | |
| TLB.reserve(NewTL.getFullDataSize()); | |
| QualType Result = getDerived().TransformType(TLB, | |
| OldExpansionTL.getPatternLoc()); | |
| if (Result.isNull()) | |
| return nullptr; | |
| Result = RebuildPackExpansionType(Result, | |
| OldExpansionTL.getPatternLoc().getSourceRange(), | |
| OldExpansionTL.getEllipsisLoc(), | |
| NumExpansions); | |
| if (Result.isNull()) | |
| return nullptr; | |
| PackExpansionTypeLoc NewExpansionTL | |
| = TLB.push<PackExpansionTypeLoc>(Result); | |
| NewExpansionTL.setEllipsisLoc(OldExpansionTL.getEllipsisLoc()); | |
| NewTSI = TLB.getTypeSourceInfo(SemaRef.Context, Result); | |
| } else | |
| NewTSI = getDerived().TransformType(OldTSI); | |
| if (!NewTSI) | |
| return nullptr; | |
| if (NewTSI == OldTSI && indexAdjustment == 0) | |
| return OldParm; | |
| ParmVarDecl *newParm = ParmVarDecl::Create( | |
| SemaRef.Context, OldParm->getDeclContext(), OldParm->getInnerLocStart(), | |
| OldParm->getLocation(), OldParm->getIdentifier(), NewTSI->getType(), | |
| NewTSI, OldParm->getStorageClass(), | |
| /* DefArg */ nullptr); | |
| newParm->setScopeInfo(OldParm->getFunctionScopeDepth(), | |
| OldParm->getFunctionScopeIndex() + indexAdjustment); | |
| getDerived().transformedLocalDecl(OldParm, {newParm}); | |
| return newParm; | |
| } | |
| template <typename Derived> | |
| bool TreeTransform<Derived>::TransformFunctionTypeParams( | |
| SourceLocation Loc, ArrayRef<ParmVarDecl *> Params, | |
| const QualType *ParamTypes, | |
| const FunctionProtoType::ExtParameterInfo *ParamInfos, | |
| SmallVectorImpl<QualType> &OutParamTypes, | |
| SmallVectorImpl<ParmVarDecl *> *PVars, | |
| Sema::ExtParameterInfoBuilder &PInfos, | |
| unsigned *LastParamTransformed) { | |
| int indexAdjustment = 0; | |
| unsigned NumParams = Params.size(); | |
| for (unsigned i = 0; i != NumParams; ++i) { | |
| if (LastParamTransformed) | |
| *LastParamTransformed = i; | |
| if (ParmVarDecl *OldParm = Params[i]) { | |
| assert(OldParm->getFunctionScopeIndex() == i); | |
| UnsignedOrNone NumExpansions = std::nullopt; | |
| ParmVarDecl *NewParm = nullptr; | |
| if (OldParm->isParameterPack()) { | |
| // We have a function parameter pack that may need to be expanded. | |
| SmallVector<UnexpandedParameterPack, 2> Unexpanded; | |
| // Find the parameter packs that could be expanded. | |
| TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc(); | |
| PackExpansionTypeLoc ExpansionTL = TL.castAs<PackExpansionTypeLoc>(); | |
| TypeLoc Pattern = ExpansionTL.getPatternLoc(); | |
| SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded); | |
| // Determine whether we should expand the parameter packs. | |
| bool ShouldExpand = false; | |
| bool RetainExpansion = false; | |
| UnsignedOrNone OrigNumExpansions = std::nullopt; | |
| if (Unexpanded.size() > 0) { | |
| OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions(); | |
| NumExpansions = OrigNumExpansions; | |
| if (getDerived().TryExpandParameterPacks( | |
| ExpansionTL.getEllipsisLoc(), Pattern.getSourceRange(), | |
| Unexpanded, /*FailOnPackProducingTemplates=*/true, | |
| ShouldExpand, RetainExpansion, NumExpansions)) { | |
| return true; | |
| } | |
| } else { | |
| #ifndef NDEBUG | |
| const AutoType *AT = | |
| Pattern.getType().getTypePtr()->getContainedAutoType(); | |
| assert((AT && (!AT->isDeduced() || AT->getDeducedType().isNull())) && | |
| "Could not find parameter packs or undeduced auto type!"); | |
| #endif | |
| } | |
| if (ShouldExpand) { | |
| // Expand the function parameter pack into multiple, separate | |
| // parameters. | |
| getDerived().ExpandingFunctionParameterPack(OldParm); | |
| for (unsigned I = 0; I != *NumExpansions; ++I) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); | |
| ParmVarDecl *NewParm | |
| = getDerived().TransformFunctionTypeParam(OldParm, | |
| indexAdjustment++, | |
| OrigNumExpansions, | |
| /*ExpectParameterPack=*/false); | |
| if (!NewParm) | |
| return true; | |
| if (ParamInfos) | |
| PInfos.set(OutParamTypes.size(), ParamInfos[i]); | |
| OutParamTypes.push_back(NewParm->getType()); | |
| if (PVars) | |
| PVars->push_back(NewParm); | |
| } | |
| // If we're supposed to retain a pack expansion, do so by temporarily | |
| // forgetting the partially-substituted parameter pack. | |
| if (RetainExpansion) { | |
| ForgetPartiallySubstitutedPackRAII Forget(getDerived()); | |
| ParmVarDecl *NewParm | |
| = getDerived().TransformFunctionTypeParam(OldParm, | |
| indexAdjustment++, | |
| OrigNumExpansions, | |
| /*ExpectParameterPack=*/false); | |
| if (!NewParm) | |
| return true; | |
| if (ParamInfos) | |
| PInfos.set(OutParamTypes.size(), ParamInfos[i]); | |
| OutParamTypes.push_back(NewParm->getType()); | |
| if (PVars) | |
| PVars->push_back(NewParm); | |
| } | |
| // The next parameter should have the same adjustment as the | |
| // last thing we pushed, but we post-incremented indexAdjustment | |
| // on every push. Also, if we push nothing, the adjustment should | |
| // go down by one. | |
| indexAdjustment--; | |
| // We're done with the pack expansion. | |
| continue; | |
| } | |
| // We'll substitute the parameter now without expanding the pack | |
| // expansion. | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); | |
| NewParm = getDerived().TransformFunctionTypeParam(OldParm, | |
| indexAdjustment, | |
| NumExpansions, | |
| /*ExpectParameterPack=*/true); | |
| assert(NewParm->isParameterPack() && | |
| "Parameter pack no longer a parameter pack after " | |
| "transformation."); | |
| } else { | |
| NewParm = getDerived().TransformFunctionTypeParam( | |
| OldParm, indexAdjustment, std::nullopt, | |
| /*ExpectParameterPack=*/false); | |
| } | |
| if (!NewParm) | |
| return true; | |
| if (ParamInfos) | |
| PInfos.set(OutParamTypes.size(), ParamInfos[i]); | |
| OutParamTypes.push_back(NewParm->getType()); | |
| if (PVars) | |
| PVars->push_back(NewParm); | |
| continue; | |
| } | |
| // Deal with the possibility that we don't have a parameter | |
| // declaration for this parameter. | |
| assert(ParamTypes); | |
| QualType OldType = ParamTypes[i]; | |
| bool IsPackExpansion = false; | |
| UnsignedOrNone NumExpansions = std::nullopt; | |
| QualType NewType; | |
| if (const PackExpansionType *Expansion | |
| = dyn_cast<PackExpansionType>(OldType)) { | |
| // We have a function parameter pack that may need to be expanded. | |
| QualType Pattern = Expansion->getPattern(); | |
| SmallVector<UnexpandedParameterPack, 2> Unexpanded; | |
| getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); | |
| // Determine whether we should expand the parameter packs. | |
| bool ShouldExpand = false; | |
| bool RetainExpansion = false; | |
| if (getDerived().TryExpandParameterPacks( | |
| Loc, SourceRange(), Unexpanded, | |
| /*FailOnPackProducingTemplates=*/true, ShouldExpand, | |
| RetainExpansion, NumExpansions)) { | |
| return true; | |
| } | |
| if (ShouldExpand) { | |
| // Expand the function parameter pack into multiple, separate | |
| // parameters. | |
| for (unsigned I = 0; I != *NumExpansions; ++I) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); | |
| QualType NewType = getDerived().TransformType(Pattern); | |
| if (NewType.isNull()) | |
| return true; | |
| if (NewType->containsUnexpandedParameterPack()) { | |
| NewType = getSema().getASTContext().getPackExpansionType( | |
| NewType, std::nullopt); | |
| if (NewType.isNull()) | |
| return true; | |
| } | |
| if (ParamInfos) | |
| PInfos.set(OutParamTypes.size(), ParamInfos[i]); | |
| OutParamTypes.push_back(NewType); | |
| if (PVars) | |
| PVars->push_back(nullptr); | |
| } | |
| // We're done with the pack expansion. | |
| continue; | |
| } | |
| // If we're supposed to retain a pack expansion, do so by temporarily | |
| // forgetting the partially-substituted parameter pack. | |
| if (RetainExpansion) { | |
| ForgetPartiallySubstitutedPackRAII Forget(getDerived()); | |
| QualType NewType = getDerived().TransformType(Pattern); | |
| if (NewType.isNull()) | |
| return true; | |
| if (ParamInfos) | |
| PInfos.set(OutParamTypes.size(), ParamInfos[i]); | |
| OutParamTypes.push_back(NewType); | |
| if (PVars) | |
| PVars->push_back(nullptr); | |
| } | |
| // We'll substitute the parameter now without expanding the pack | |
| // expansion. | |
| OldType = Expansion->getPattern(); | |
| IsPackExpansion = true; | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); | |
| NewType = getDerived().TransformType(OldType); | |
| } else { | |
| NewType = getDerived().TransformType(OldType); | |
| } | |
| if (NewType.isNull()) | |
| return true; | |
| if (IsPackExpansion) | |
| NewType = getSema().Context.getPackExpansionType(NewType, | |
| NumExpansions); | |
| if (ParamInfos) | |
| PInfos.set(OutParamTypes.size(), ParamInfos[i]); | |
| OutParamTypes.push_back(NewType); | |
| if (PVars) | |
| PVars->push_back(nullptr); | |
| } | |
| #ifndef NDEBUG | |
| if (PVars) { | |
| for (unsigned i = 0, e = PVars->size(); i != e; ++i) | |
| if (ParmVarDecl *parm = (*PVars)[i]) | |
| assert(parm->getFunctionScopeIndex() == i); | |
| } | |
| #endif | |
| return false; | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, | |
| FunctionProtoTypeLoc TL) { | |
| SmallVector<QualType, 4> ExceptionStorage; | |
| return getDerived().TransformFunctionProtoType( | |
| TLB, TL, nullptr, Qualifiers(), | |
| [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) { | |
| return getDerived().TransformExceptionSpec(TL.getBeginLoc(), ESI, | |
| ExceptionStorage, Changed); | |
| }); | |
| } | |
| template<typename Derived> template<typename Fn> | |
| QualType TreeTransform<Derived>::TransformFunctionProtoType( | |
| TypeLocBuilder &TLB, FunctionProtoTypeLoc TL, CXXRecordDecl *ThisContext, | |
| Qualifiers ThisTypeQuals, Fn TransformExceptionSpec) { | |
| // Transform the parameters and return type. | |
| // | |
| // We are required to instantiate the params and return type in source order. | |
| // When the function has a trailing return type, we instantiate the | |
| // parameters before the return type, since the return type can then refer | |
| // to the parameters themselves (via decltype, sizeof, etc.). | |
| // | |
| SmallVector<QualType, 4> ParamTypes; | |
| SmallVector<ParmVarDecl*, 4> ParamDecls; | |
| Sema::ExtParameterInfoBuilder ExtParamInfos; | |
| const FunctionProtoType *T = TL.getTypePtr(); | |
| QualType ResultType; | |
| if (T->hasTrailingReturn()) { | |
| if (getDerived().TransformFunctionTypeParams( | |
| TL.getBeginLoc(), TL.getParams(), | |
| TL.getTypePtr()->param_type_begin(), | |
| T->getExtParameterInfosOrNull(), | |
| ParamTypes, &ParamDecls, ExtParamInfos)) | |
| return QualType(); | |
| { | |
| // C++11 [expr.prim.general]p3: | |
| // If a declaration declares a member function or member function | |
| // template of a class X, the expression this is a prvalue of type | |
| // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq | |
| // and the end of the function-definition, member-declarator, or | |
| // declarator. | |
| auto *RD = dyn_cast<CXXRecordDecl>(SemaRef.getCurLexicalContext()); | |
| Sema::CXXThisScopeRAII ThisScope( | |
| SemaRef, !ThisContext && RD ? RD : ThisContext, ThisTypeQuals); | |
| ResultType = getDerived().TransformType(TLB, TL.getReturnLoc()); | |
| if (ResultType.isNull()) | |
| return QualType(); | |
| } | |
| } | |
| else { | |
| ResultType = getDerived().TransformType(TLB, TL.getReturnLoc()); | |
| if (ResultType.isNull()) | |
| return QualType(); | |
| if (getDerived().TransformFunctionTypeParams( | |
| TL.getBeginLoc(), TL.getParams(), | |
| TL.getTypePtr()->param_type_begin(), | |
| T->getExtParameterInfosOrNull(), | |
| ParamTypes, &ParamDecls, ExtParamInfos)) | |
| return QualType(); | |
| } | |
| FunctionProtoType::ExtProtoInfo EPI = T->getExtProtoInfo(); | |
| bool EPIChanged = false; | |
| if (TransformExceptionSpec(EPI.ExceptionSpec, EPIChanged)) | |
| return QualType(); | |
| // Handle extended parameter information. | |
| if (auto NewExtParamInfos = | |
| ExtParamInfos.getPointerOrNull(ParamTypes.size())) { | |
| if (!EPI.ExtParameterInfos || | |
| llvm::ArrayRef(EPI.ExtParameterInfos, TL.getNumParams()) != | |
| llvm::ArrayRef(NewExtParamInfos, ParamTypes.size())) { | |
| EPIChanged = true; | |
| } | |
| EPI.ExtParameterInfos = NewExtParamInfos; | |
| } else if (EPI.ExtParameterInfos) { | |
| EPIChanged = true; | |
| EPI.ExtParameterInfos = nullptr; | |
| } | |
| // Transform any function effects with unevaluated conditions. | |
| // Hold this set in a local for the rest of this function, since EPI | |
| // may need to hold a FunctionEffectsRef pointing into it. | |
| std::optional<FunctionEffectSet> NewFX; | |
| if (ArrayRef FXConds = EPI.FunctionEffects.conditions(); !FXConds.empty()) { | |
| NewFX.emplace(); | |
| EnterExpressionEvaluationContext Unevaluated( | |
| getSema(), Sema::ExpressionEvaluationContext::ConstantEvaluated); | |
| for (const FunctionEffectWithCondition &PrevEC : EPI.FunctionEffects) { | |
| FunctionEffectWithCondition NewEC = PrevEC; | |
| if (Expr *CondExpr = PrevEC.Cond.getCondition()) { | |
| ExprResult NewExpr = getDerived().TransformExpr(CondExpr); | |
| if (NewExpr.isInvalid()) | |
| return QualType(); | |
| std::optional<FunctionEffectMode> Mode = | |
| SemaRef.ActOnEffectExpression(NewExpr.get(), PrevEC.Effect.name()); | |
| if (!Mode) | |
| return QualType(); | |
| // The condition expression has been transformed, and re-evaluated. | |
| // It may or may not have become constant. | |
| switch (*Mode) { | |
| case FunctionEffectMode::True: | |
| NewEC.Cond = {}; | |
| break; | |
| case FunctionEffectMode::False: | |
| NewEC.Effect = FunctionEffect(PrevEC.Effect.oppositeKind()); | |
| NewEC.Cond = {}; | |
| break; | |
| case FunctionEffectMode::Dependent: | |
| NewEC.Cond = EffectConditionExpr(NewExpr.get()); | |
| break; | |
| case FunctionEffectMode::None: | |
| llvm_unreachable( | |
| "FunctionEffectMode::None shouldn't be possible here"); | |
| } | |
| } | |
| if (!SemaRef.diagnoseConflictingFunctionEffect(*NewFX, NewEC, | |
| TL.getBeginLoc())) { | |
| FunctionEffectSet::Conflicts Errs; | |
| NewFX->insert(NewEC, Errs); | |
| assert(Errs.empty()); | |
| } | |
| } | |
| EPI.FunctionEffects = *NewFX; | |
| EPIChanged = true; | |
| } | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType() || | |
| T->getParamTypes() != llvm::ArrayRef(ParamTypes) || EPIChanged) { | |
| Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result); | |
| NewTL.setLocalRangeBegin(TL.getLocalRangeBegin()); | |
| NewTL.setLParenLoc(TL.getLParenLoc()); | |
| NewTL.setRParenLoc(TL.getRParenLoc()); | |
| NewTL.setExceptionSpecRange(TL.getExceptionSpecRange()); | |
| NewTL.setLocalRangeEnd(TL.getLocalRangeEnd()); | |
| for (unsigned i = 0, e = NewTL.getNumParams(); i != e; ++i) | |
| NewTL.setParam(i, ParamDecls[i]); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| bool TreeTransform<Derived>::TransformExceptionSpec( | |
| SourceLocation Loc, FunctionProtoType::ExceptionSpecInfo &ESI, | |
| SmallVectorImpl<QualType> &Exceptions, bool &Changed) { | |
| assert(ESI.Type != EST_Uninstantiated && ESI.Type != EST_Unevaluated); | |
| // Instantiate a dynamic noexcept expression, if any. | |
| if (isComputedNoexcept(ESI.Type)) { | |
| // Update this scrope because ContextDecl in Sema will be used in | |
| // TransformExpr. | |
| auto *Method = dyn_cast_if_present<CXXMethodDecl>(ESI.SourceTemplate); | |
| Sema::CXXThisScopeRAII ThisScope( | |
| SemaRef, Method ? Method->getParent() : nullptr, | |
| Method ? Method->getMethodQualifiers() : Qualifiers{}, | |
| Method != nullptr); | |
| EnterExpressionEvaluationContext Unevaluated( | |
| getSema(), Sema::ExpressionEvaluationContext::ConstantEvaluated); | |
| ExprResult NoexceptExpr = getDerived().TransformExpr(ESI.NoexceptExpr); | |
| if (NoexceptExpr.isInvalid()) | |
| return true; | |
| ExceptionSpecificationType EST = ESI.Type; | |
| NoexceptExpr = | |
| getSema().ActOnNoexceptSpec(NoexceptExpr.get(), EST); | |
| if (NoexceptExpr.isInvalid()) | |
| return true; | |
| if (ESI.NoexceptExpr != NoexceptExpr.get() || EST != ESI.Type) | |
| Changed = true; | |
| ESI.NoexceptExpr = NoexceptExpr.get(); | |
| ESI.Type = EST; | |
| } | |
| if (ESI.Type != EST_Dynamic) | |
| return false; | |
| // Instantiate a dynamic exception specification's type. | |
| for (QualType T : ESI.Exceptions) { | |
| if (const PackExpansionType *PackExpansion = | |
| T->getAs<PackExpansionType>()) { | |
| Changed = true; | |
| // We have a pack expansion. Instantiate it. | |
| SmallVector<UnexpandedParameterPack, 2> Unexpanded; | |
| SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(), | |
| Unexpanded); | |
| assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); | |
| // Determine whether the set of unexpanded parameter packs can and | |
| // should | |
| // be expanded. | |
| bool Expand = false; | |
| bool RetainExpansion = false; | |
| UnsignedOrNone NumExpansions = PackExpansion->getNumExpansions(); | |
| // FIXME: Track the location of the ellipsis (and track source location | |
| // information for the types in the exception specification in general). | |
| if (getDerived().TryExpandParameterPacks( | |
| Loc, SourceRange(), Unexpanded, | |
| /*FailOnPackProducingTemplates=*/true, Expand, RetainExpansion, | |
| NumExpansions)) | |
| return true; | |
| if (!Expand) { | |
| // We can't expand this pack expansion into separate arguments yet; | |
| // just substitute into the pattern and create a new pack expansion | |
| // type. | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); | |
| QualType U = getDerived().TransformType(PackExpansion->getPattern()); | |
| if (U.isNull()) | |
| return true; | |
| U = SemaRef.Context.getPackExpansionType(U, NumExpansions); | |
| Exceptions.push_back(U); | |
| continue; | |
| } | |
| // Substitute into the pack expansion pattern for each slice of the | |
| // pack. | |
| for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), ArgIdx); | |
| QualType U = getDerived().TransformType(PackExpansion->getPattern()); | |
| if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc)) | |
| return true; | |
| Exceptions.push_back(U); | |
| } | |
| } else { | |
| QualType U = getDerived().TransformType(T); | |
| if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc)) | |
| return true; | |
| if (T != U) | |
| Changed = true; | |
| Exceptions.push_back(U); | |
| } | |
| } | |
| ESI.Exceptions = Exceptions; | |
| if (ESI.Exceptions.empty()) | |
| ESI.Type = EST_DynamicNone; | |
| return false; | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformFunctionNoProtoType( | |
| TypeLocBuilder &TLB, | |
| FunctionNoProtoTypeLoc TL) { | |
| const FunctionNoProtoType *T = TL.getTypePtr(); | |
| QualType ResultType = getDerived().TransformType(TLB, TL.getReturnLoc()); | |
| if (ResultType.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType()) | |
| Result = getDerived().RebuildFunctionNoProtoType(ResultType); | |
| FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result); | |
| NewTL.setLocalRangeBegin(TL.getLocalRangeBegin()); | |
| NewTL.setLParenLoc(TL.getLParenLoc()); | |
| NewTL.setRParenLoc(TL.getRParenLoc()); | |
| NewTL.setLocalRangeEnd(TL.getLocalRangeEnd()); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformUnresolvedUsingType( | |
| TypeLocBuilder &TLB, UnresolvedUsingTypeLoc TL) { | |
| const UnresolvedUsingType *T = TL.getTypePtr(); | |
| bool Changed = false; | |
| NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc(); | |
| if (NestedNameSpecifierLoc OldQualifierLoc = QualifierLoc) { | |
| QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc); | |
| if (!QualifierLoc) | |
| return QualType(); | |
| Changed |= QualifierLoc != OldQualifierLoc; | |
| } | |
| auto *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl()); | |
| if (!D) | |
| return QualType(); | |
| Changed |= D != T->getDecl(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || Changed) { | |
| Result = getDerived().RebuildUnresolvedUsingType( | |
| T->getKeyword(), QualifierLoc.getNestedNameSpecifier(), TL.getNameLoc(), | |
| D); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| if (isa<UsingType>(Result)) | |
| TLB.push<UsingTypeLoc>(Result).set(TL.getElaboratedKeywordLoc(), | |
| QualifierLoc, TL.getNameLoc()); | |
| else | |
| TLB.push<UnresolvedUsingTypeLoc>(Result).set(TL.getElaboratedKeywordLoc(), | |
| QualifierLoc, TL.getNameLoc()); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformUsingType(TypeLocBuilder &TLB, | |
| UsingTypeLoc TL) { | |
| const UsingType *T = TL.getTypePtr(); | |
| bool Changed = false; | |
| NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc(); | |
| if (NestedNameSpecifierLoc OldQualifierLoc = QualifierLoc) { | |
| QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc); | |
| if (!QualifierLoc) | |
| return QualType(); | |
| Changed |= QualifierLoc != OldQualifierLoc; | |
| } | |
| auto *D = cast_or_null<UsingShadowDecl>( | |
| getDerived().TransformDecl(TL.getNameLoc(), T->getDecl())); | |
| if (!D) | |
| return QualType(); | |
| Changed |= D != T->getDecl(); | |
| QualType UnderlyingType = getDerived().TransformType(T->desugar()); | |
| if (UnderlyingType.isNull()) | |
| return QualType(); | |
| Changed |= UnderlyingType != T->desugar(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || Changed) { | |
| Result = getDerived().RebuildUsingType( | |
| T->getKeyword(), QualifierLoc.getNestedNameSpecifier(), D, | |
| UnderlyingType); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| TLB.push<UsingTypeLoc>(Result).set(TL.getElaboratedKeywordLoc(), QualifierLoc, | |
| TL.getNameLoc()); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB, | |
| TypedefTypeLoc TL) { | |
| const TypedefType *T = TL.getTypePtr(); | |
| bool Changed = false; | |
| NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc(); | |
| if (NestedNameSpecifierLoc OldQualifierLoc = QualifierLoc) { | |
| QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc); | |
| if (!QualifierLoc) | |
| return QualType(); | |
| Changed |= QualifierLoc != OldQualifierLoc; | |
| } | |
| auto *Typedef = cast_or_null<TypedefNameDecl>( | |
| getDerived().TransformDecl(TL.getNameLoc(), T->getDecl())); | |
| if (!Typedef) | |
| return QualType(); | |
| Changed |= Typedef != T->getDecl(); | |
| // FIXME: Transform the UnderlyingType if different from decl. | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || Changed) { | |
| Result = getDerived().RebuildTypedefType( | |
| T->getKeyword(), QualifierLoc.getNestedNameSpecifier(), Typedef); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| TLB.push<TypedefTypeLoc>(Result).set(TL.getElaboratedKeywordLoc(), | |
| QualifierLoc, TL.getNameLoc()); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, | |
| TypeOfExprTypeLoc TL) { | |
| // typeof expressions are not potentially evaluated contexts | |
| EnterExpressionEvaluationContext Unevaluated( | |
| SemaRef, Sema::ExpressionEvaluationContext::Unevaluated, | |
| Sema::ReuseLambdaContextDecl); | |
| ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr()); | |
| if (E.isInvalid()) | |
| return QualType(); | |
| E = SemaRef.HandleExprEvaluationContextForTypeof(E.get()); | |
| if (E.isInvalid()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| TypeOfKind Kind = Result->castAs<TypeOfExprType>()->getKind(); | |
| if (getDerived().AlwaysRebuild() || E.get() != TL.getUnderlyingExpr()) { | |
| Result = | |
| getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc(), Kind); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result); | |
| NewTL.setTypeofLoc(TL.getTypeofLoc()); | |
| NewTL.setLParenLoc(TL.getLParenLoc()); | |
| NewTL.setRParenLoc(TL.getRParenLoc()); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB, | |
| TypeOfTypeLoc TL) { | |
| TypeSourceInfo* Old_Under_TI = TL.getUnmodifiedTInfo(); | |
| TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI); | |
| if (!New_Under_TI) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| TypeOfKind Kind = Result->castAs<TypeOfType>()->getKind(); | |
| if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) { | |
| Result = getDerived().RebuildTypeOfType(New_Under_TI->getType(), Kind); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result); | |
| NewTL.setTypeofLoc(TL.getTypeofLoc()); | |
| NewTL.setLParenLoc(TL.getLParenLoc()); | |
| NewTL.setRParenLoc(TL.getRParenLoc()); | |
| NewTL.setUnmodifiedTInfo(New_Under_TI); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB, | |
| DecltypeTypeLoc TL) { | |
| const DecltypeType *T = TL.getTypePtr(); | |
| // decltype expressions are not potentially evaluated contexts | |
| EnterExpressionEvaluationContext Unevaluated( | |
| SemaRef, Sema::ExpressionEvaluationContext::Unevaluated, nullptr, | |
| Sema::ExpressionEvaluationContextRecord::EK_Decltype); | |
| ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); | |
| if (E.isInvalid()) | |
| return QualType(); | |
| E = getSema().ActOnDecltypeExpression(E.get()); | |
| if (E.isInvalid()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| E.get() != T->getUnderlyingExpr()) { | |
| Result = getDerived().RebuildDecltypeType(E.get(), TL.getDecltypeLoc()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| else E.get(); | |
| DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result); | |
| NewTL.setDecltypeLoc(TL.getDecltypeLoc()); | |
| NewTL.setRParenLoc(TL.getRParenLoc()); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformPackIndexingType(TypeLocBuilder &TLB, | |
| PackIndexingTypeLoc TL) { | |
| // Transform the index | |
| ExprResult IndexExpr; | |
| { | |
| EnterExpressionEvaluationContext ConstantContext( | |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); | |
| IndexExpr = getDerived().TransformExpr(TL.getIndexExpr()); | |
| if (IndexExpr.isInvalid()) | |
| return QualType(); | |
| } | |
| QualType Pattern = TL.getPattern(); | |
| const PackIndexingType *PIT = TL.getTypePtr(); | |
| SmallVector<QualType, 5> SubtitutedTypes; | |
| llvm::ArrayRef<QualType> Types = PIT->getExpansions(); | |
| bool NotYetExpanded = Types.empty(); | |
| bool FullySubstituted = true; | |
| if (Types.empty() && !PIT->expandsToEmptyPack()) | |
| Types = llvm::ArrayRef<QualType>(&Pattern, 1); | |
| for (QualType T : Types) { | |
| if (!T->containsUnexpandedParameterPack()) { | |
| QualType Transformed = getDerived().TransformType(T); | |
| if (Transformed.isNull()) | |
| return QualType(); | |
| SubtitutedTypes.push_back(Transformed); | |
| continue; | |
| } | |
| SmallVector<UnexpandedParameterPack, 2> Unexpanded; | |
| getSema().collectUnexpandedParameterPacks(T, Unexpanded); | |
| assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); | |
| // Determine whether the set of unexpanded parameter packs can and should | |
| // be expanded. | |
| bool ShouldExpand = true; | |
| bool RetainExpansion = false; | |
| UnsignedOrNone NumExpansions = std::nullopt; | |
| if (getDerived().TryExpandParameterPacks( | |
| TL.getEllipsisLoc(), SourceRange(), Unexpanded, | |
| /*FailOnPackProducingTemplates=*/true, ShouldExpand, | |
| RetainExpansion, NumExpansions)) | |
| return QualType(); | |
| if (!ShouldExpand) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); | |
| // FIXME: should we keep TypeLoc for individual expansions in | |
| // PackIndexingTypeLoc? | |
| TypeSourceInfo *TI = | |
| SemaRef.getASTContext().getTrivialTypeSourceInfo(T, TL.getBeginLoc()); | |
| QualType Pack = getDerived().TransformType(TLB, TI->getTypeLoc()); | |
| if (Pack.isNull()) | |
| return QualType(); | |
| if (NotYetExpanded) { | |
| FullySubstituted = false; | |
| QualType Out = getDerived().RebuildPackIndexingType( | |
| Pack, IndexExpr.get(), TL.getBeginLoc(), FullySubstituted); | |
| if (Out.isNull()) | |
| return QualType(); | |
| PackIndexingTypeLoc Loc = TLB.push<PackIndexingTypeLoc>(Out); | |
| Loc.setEllipsisLoc(TL.getEllipsisLoc()); | |
| return Out; | |
| } | |
| SubtitutedTypes.push_back(Pack); | |
| continue; | |
| } | |
| for (unsigned I = 0; I != *NumExpansions; ++I) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); | |
| QualType Out = getDerived().TransformType(T); | |
| if (Out.isNull()) | |
| return QualType(); | |
| SubtitutedTypes.push_back(Out); | |
| FullySubstituted &= !Out->containsUnexpandedParameterPack(); | |
| } | |
| // If we're supposed to retain a pack expansion, do so by temporarily | |
| // forgetting the partially-substituted parameter pack. | |
| if (RetainExpansion) { | |
| FullySubstituted = false; | |
| ForgetPartiallySubstitutedPackRAII Forget(getDerived()); | |
| QualType Out = getDerived().TransformType(T); | |
| if (Out.isNull()) | |
| return QualType(); | |
| SubtitutedTypes.push_back(Out); | |
| } | |
| } | |
| // A pack indexing type can appear in a larger pack expansion, | |
| // e.g. `Pack...[pack_of_indexes]...` | |
| // so we need to temporarily disable substitution of pack elements | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); | |
| QualType Result = getDerived().TransformType(TLB, TL.getPatternLoc()); | |
| QualType Out = getDerived().RebuildPackIndexingType( | |
| Result, IndexExpr.get(), TL.getBeginLoc(), FullySubstituted, | |
| SubtitutedTypes); | |
| if (Out.isNull()) | |
| return Out; | |
| PackIndexingTypeLoc Loc = TLB.push<PackIndexingTypeLoc>(Out); | |
| Loc.setEllipsisLoc(TL.getEllipsisLoc()); | |
| return Out; | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformUnaryTransformType( | |
| TypeLocBuilder &TLB, | |
| UnaryTransformTypeLoc TL) { | |
| QualType Result = TL.getType(); | |
| TypeSourceInfo *NewBaseTSI = TL.getUnderlyingTInfo(); | |
| if (Result->isDependentType()) { | |
| const UnaryTransformType *T = TL.getTypePtr(); | |
| NewBaseTSI = getDerived().TransformType(TL.getUnderlyingTInfo()); | |
| if (!NewBaseTSI) | |
| return QualType(); | |
| QualType NewBase = NewBaseTSI->getType(); | |
| Result = getDerived().RebuildUnaryTransformType(NewBase, | |
| T->getUTTKind(), | |
| TL.getKWLoc()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result); | |
| NewTL.setKWLoc(TL.getKWLoc()); | |
| NewTL.setParensRange(TL.getParensRange()); | |
| NewTL.setUnderlyingTInfo(NewBaseTSI); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformDeducedTemplateSpecializationType( | |
| TypeLocBuilder &TLB, DeducedTemplateSpecializationTypeLoc TL) { | |
| const DeducedTemplateSpecializationType *T = TL.getTypePtr(); | |
| NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc(); | |
| TemplateName TemplateName = getDerived().TransformTemplateName( | |
| QualifierLoc, /*TemplateKELoc=*/SourceLocation(), T->getTemplateName(), | |
| TL.getTemplateNameLoc()); | |
| if (TemplateName.isNull()) | |
| return QualType(); | |
| QualType OldDeduced = T->getDeducedType(); | |
| QualType NewDeduced; | |
| if (!OldDeduced.isNull()) { | |
| NewDeduced = getDerived().TransformType(OldDeduced); | |
| if (NewDeduced.isNull()) | |
| return QualType(); | |
| } | |
| QualType Result = getDerived().RebuildDeducedTemplateSpecializationType( | |
| NewDeduced.isNull() ? DeducedKind::Undeduced : DeducedKind::Deduced, | |
| NewDeduced, T->getKeyword(), TemplateName); | |
| if (Result.isNull()) | |
| return QualType(); | |
| auto NewTL = TLB.push<DeducedTemplateSpecializationTypeLoc>(Result); | |
| NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); | |
| NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); | |
| NewTL.setQualifierLoc(QualifierLoc); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformTagType(TypeLocBuilder &TLB, | |
| TagTypeLoc TL) { | |
| const TagType *T = TL.getTypePtr(); | |
| NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc(); | |
| if (QualifierLoc) { | |
| QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc); | |
| if (!QualifierLoc) | |
| return QualType(); | |
| } | |
| auto *TD = cast_or_null<TagDecl>( | |
| getDerived().TransformDecl(TL.getNameLoc(), T->getDecl())); | |
| if (!TD) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || QualifierLoc != TL.getQualifierLoc() || | |
| TD != T->getDecl()) { | |
| if (T->isCanonicalUnqualified()) | |
| Result = getDerived().RebuildCanonicalTagType(TD); | |
| else | |
| Result = getDerived().RebuildTagType( | |
| T->getKeyword(), QualifierLoc.getNestedNameSpecifier(), TD); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| TagTypeLoc NewTL = TLB.push<TagTypeLoc>(Result); | |
| NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); | |
| NewTL.setQualifierLoc(QualifierLoc); | |
| NewTL.setNameLoc(TL.getNameLoc()); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB, | |
| EnumTypeLoc TL) { | |
| return getDerived().TransformTagType(TLB, TL); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB, | |
| RecordTypeLoc TL) { | |
| return getDerived().TransformTagType(TLB, TL); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformInjectedClassNameType( | |
| TypeLocBuilder &TLB, | |
| InjectedClassNameTypeLoc TL) { | |
| return getDerived().TransformTagType(TLB, TL); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformTemplateTypeParmType( | |
| TypeLocBuilder &TLB, | |
| TemplateTypeParmTypeLoc TL) { | |
| return getDerived().TransformTemplateTypeParmType( | |
| TLB, TL, | |
| /*SuppressObjCLifetime=*/false); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformTemplateTypeParmType( | |
| TypeLocBuilder &TLB, TemplateTypeParmTypeLoc TL, bool) { | |
| return TransformTypeSpecType(TLB, TL); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( | |
| TypeLocBuilder &TLB, | |
| SubstTemplateTypeParmTypeLoc TL) { | |
| const SubstTemplateTypeParmType *T = TL.getTypePtr(); | |
| Decl *NewReplaced = | |
| getDerived().TransformDecl(TL.getNameLoc(), T->getAssociatedDecl()); | |
| // Substitute into the replacement type, which itself might involve something | |
| // that needs to be transformed. This only tends to occur with default | |
| // template arguments of template template parameters. | |
| TemporaryBase Rebase(*this, TL.getNameLoc(), DeclarationName()); | |
| QualType Replacement = getDerived().TransformType(T->getReplacementType()); | |
| if (Replacement.isNull()) | |
| return QualType(); | |
| QualType Result = SemaRef.Context.getSubstTemplateTypeParmType( | |
| Replacement, NewReplaced, T->getIndex(), T->getPackIndex(), | |
| T->getFinal()); | |
| // Propagate type-source information. | |
| SubstTemplateTypeParmTypeLoc NewTL | |
| = TLB.push<SubstTemplateTypeParmTypeLoc>(Result); | |
| NewTL.setNameLoc(TL.getNameLoc()); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformSubstBuiltinTemplatePackType( | |
| TypeLocBuilder &TLB, SubstBuiltinTemplatePackTypeLoc TL) { | |
| return TransformTypeSpecType(TLB, TL); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType( | |
| TypeLocBuilder &TLB, | |
| SubstTemplateTypeParmPackTypeLoc TL) { | |
| return getDerived().TransformSubstTemplateTypeParmPackType( | |
| TLB, TL, /*SuppressObjCLifetime=*/false); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType( | |
| TypeLocBuilder &TLB, SubstTemplateTypeParmPackTypeLoc TL, bool) { | |
| return TransformTypeSpecType(TLB, TL); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformAtomicType(TypeLocBuilder &TLB, | |
| AtomicTypeLoc TL) { | |
| QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc()); | |
| if (ValueType.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| ValueType != TL.getValueLoc().getType()) { | |
| Result = getDerived().RebuildAtomicType(ValueType, TL.getKWLoc()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| AtomicTypeLoc NewTL = TLB.push<AtomicTypeLoc>(Result); | |
| NewTL.setKWLoc(TL.getKWLoc()); | |
| NewTL.setLParenLoc(TL.getLParenLoc()); | |
| NewTL.setRParenLoc(TL.getRParenLoc()); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB, | |
| PipeTypeLoc TL) { | |
| QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc()); | |
| if (ValueType.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || ValueType != TL.getValueLoc().getType()) { | |
| const PipeType *PT = Result->castAs<PipeType>(); | |
| bool isReadPipe = PT->isReadOnly(); | |
| Result = getDerived().RebuildPipeType(ValueType, TL.getKWLoc(), isReadPipe); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| PipeTypeLoc NewTL = TLB.push<PipeTypeLoc>(Result); | |
| NewTL.setKWLoc(TL.getKWLoc()); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformBitIntType(TypeLocBuilder &TLB, | |
| BitIntTypeLoc TL) { | |
| const BitIntType *EIT = TL.getTypePtr(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild()) { | |
| Result = getDerived().RebuildBitIntType(EIT->isUnsigned(), | |
| EIT->getNumBits(), TL.getNameLoc()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(Result); | |
| NewTL.setNameLoc(TL.getNameLoc()); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformDependentBitIntType( | |
| TypeLocBuilder &TLB, DependentBitIntTypeLoc TL) { | |
| const DependentBitIntType *EIT = TL.getTypePtr(); | |
| EnterExpressionEvaluationContext Unevaluated( | |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); | |
| ExprResult BitsExpr = getDerived().TransformExpr(EIT->getNumBitsExpr()); | |
| BitsExpr = SemaRef.ActOnConstantExpression(BitsExpr); | |
| if (BitsExpr.isInvalid()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || BitsExpr.get() != EIT->getNumBitsExpr()) { | |
| Result = getDerived().RebuildDependentBitIntType( | |
| EIT->isUnsigned(), BitsExpr.get(), TL.getNameLoc()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| if (isa<DependentBitIntType>(Result)) { | |
| DependentBitIntTypeLoc NewTL = TLB.push<DependentBitIntTypeLoc>(Result); | |
| NewTL.setNameLoc(TL.getNameLoc()); | |
| } else { | |
| BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(Result); | |
| NewTL.setNameLoc(TL.getNameLoc()); | |
| } | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformPredefinedSugarType( | |
| TypeLocBuilder &TLB, PredefinedSugarTypeLoc TL) { | |
| llvm_unreachable("This type does not need to be transformed."); | |
| } | |
| /// Simple iterator that traverses the template arguments in a | |
| /// container that provides a \c getArgLoc() member function. | |
| /// | |
| /// This iterator is intended to be used with the iterator form of | |
| /// \c TreeTransform<Derived>::TransformTemplateArguments(). | |
| template<typename ArgLocContainer> | |
| class TemplateArgumentLocContainerIterator { | |
| ArgLocContainer *Container; | |
| unsigned Index; | |
| public: | |
| typedef TemplateArgumentLoc value_type; | |
| typedef TemplateArgumentLoc reference; | |
| typedef int difference_type; | |
| typedef std::input_iterator_tag iterator_category; | |
| class pointer { | |
| TemplateArgumentLoc Arg; | |
| public: | |
| explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { } | |
| const TemplateArgumentLoc *operator->() const { | |
| return &Arg; | |
| } | |
| }; | |
| TemplateArgumentLocContainerIterator() {} | |
| TemplateArgumentLocContainerIterator(ArgLocContainer &Container, | |
| unsigned Index) | |
| : Container(&Container), Index(Index) { } | |
| TemplateArgumentLocContainerIterator &operator++() { | |
| ++Index; | |
| return *this; | |
| } | |
| TemplateArgumentLocContainerIterator operator++(int) { | |
| TemplateArgumentLocContainerIterator Old(*this); | |
| ++(*this); | |
| return Old; | |
| } | |
| TemplateArgumentLoc operator*() const { | |
| return Container->getArgLoc(Index); | |
| } | |
| pointer operator->() const { | |
| return pointer(Container->getArgLoc(Index)); | |
| } | |
| friend bool operator==(const TemplateArgumentLocContainerIterator &X, | |
| const TemplateArgumentLocContainerIterator &Y) { | |
| return X.Container == Y.Container && X.Index == Y.Index; | |
| } | |
| friend bool operator!=(const TemplateArgumentLocContainerIterator &X, | |
| const TemplateArgumentLocContainerIterator &Y) { | |
| return !(X == Y); | |
| } | |
| }; | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB, | |
| AutoTypeLoc TL) { | |
| const AutoType *T = TL.getTypePtr(); | |
| QualType OldDeduced = T->getDeducedType(); | |
| QualType NewDeduced; | |
| if (!OldDeduced.isNull()) { | |
| NewDeduced = getDerived().TransformType(OldDeduced); | |
| if (NewDeduced.isNull()) | |
| return QualType(); | |
| } | |
| TemplateName NewCD; | |
| TemplateArgumentListInfo NewTemplateArgs; | |
| NestedNameSpecifierLoc NewNestedNameSpec; | |
| if (T->isConstrained()) { | |
| assert(TL.getConceptReference()); | |
| NewCD = getDerived().TransformConceptTemplateName( | |
| T->getTypeConstraintConcept(), TL.getConceptNameLoc()); | |
| if (NewCD.isNull()) | |
| return QualType(); | |
| NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); | |
| NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); | |
| typedef TemplateArgumentLocContainerIterator<AutoTypeLoc> ArgIterator; | |
| if (getDerived().TransformTemplateArguments( | |
| ArgIterator(TL, 0), ArgIterator(TL, TL.getNumArgs()), | |
| NewTemplateArgs)) | |
| return QualType(); | |
| if (TL.getNestedNameSpecifierLoc()) { | |
| NewNestedNameSpec | |
| = getDerived().TransformNestedNameSpecifierLoc( | |
| TL.getNestedNameSpecifierLoc()); | |
| if (!NewNestedNameSpec) | |
| return QualType(); | |
| } | |
| } | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced || | |
| T->isDependentType() || T->isConstrained()) { | |
| // FIXME: Maybe don't rebuild if all template arguments are the same. | |
| llvm::SmallVector<TemplateArgument, 4> NewArgList; | |
| NewArgList.reserve(NewTemplateArgs.size()); | |
| for (const auto &ArgLoc : NewTemplateArgs.arguments()) | |
| NewArgList.push_back(ArgLoc.getArgument()); | |
| Result = getDerived().RebuildAutoType( | |
| NewDeduced.isNull() ? DeducedKind::Undeduced : DeducedKind::Deduced, | |
| NewDeduced, T->getKeyword(), NewCD, NewArgList); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result); | |
| NewTL.setNameLoc(TL.getNameLoc()); | |
| NewTL.setRParenLoc(TL.getRParenLoc()); | |
| NewTL.setConceptReference(nullptr); | |
| if (T->isConstrained()) { | |
| DeclarationName ConceptName = | |
| SemaRef.Context | |
| .getNameForTemplate(TL.getTypePtr()->getTypeConstraintConcept(), | |
| TL.getConceptNameLoc()) | |
| .getName(); | |
| DeclarationNameInfo DNI = | |
| DeclarationNameInfo(ConceptName, TL.getConceptNameLoc(), ConceptName); | |
| auto *CR = ConceptReference::Create( | |
| SemaRef.Context, NewNestedNameSpec, TL.getTemplateKWLoc(), DNI, | |
| TL.getFoundDecl(), TL.getTypePtr()->getTypeConstraintConcept(), | |
| ASTTemplateArgumentListInfo::Create(SemaRef.Context, NewTemplateArgs)); | |
| NewTL.setConceptReference(CR); | |
| } | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformTemplateSpecializationType( | |
| TypeLocBuilder &TLB, TemplateSpecializationTypeLoc TL) { | |
| return getDerived().TransformTemplateSpecializationType( | |
| TLB, TL, /*ObjectType=*/QualType(), /*FirstQualifierInScope=*/nullptr, | |
| /*AllowInjectedClassName=*/false); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformTemplateSpecializationType( | |
| TypeLocBuilder &TLB, TemplateSpecializationTypeLoc TL, QualType ObjectType, | |
| NamedDecl *FirstQualifierInScope, bool AllowInjectedClassName) { | |
| const TemplateSpecializationType *T = TL.getTypePtr(); | |
| NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc(); | |
| TemplateName Template = getDerived().TransformTemplateName( | |
| QualifierLoc, TL.getTemplateKeywordLoc(), T->getTemplateName(), | |
| TL.getTemplateNameLoc(), ObjectType, FirstQualifierInScope, | |
| AllowInjectedClassName); | |
| if (Template.isNull()) | |
| return QualType(); | |
| TemplateArgumentListInfo NewTemplateArgs; | |
| NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); | |
| NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); | |
| typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc> | |
| ArgIterator; | |
| if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), | |
| ArgIterator(TL, TL.getNumArgs()), | |
| NewTemplateArgs)) | |
| return QualType(); | |
| // This needs to be rebuilt if either the arguments changed, or if the | |
| // original template changed. If the template changed, and even if the | |
| // arguments didn't change, these arguments might not correspond to their | |
| // respective parameters, therefore needing conversions. | |
| QualType Result = getDerived().RebuildTemplateSpecializationType( | |
| TL.getTypePtr()->getKeyword(), Template, TL.getTemplateNameLoc(), | |
| NewTemplateArgs); | |
| if (!Result.isNull()) { | |
| TLB.push<TemplateSpecializationTypeLoc>(Result).set( | |
| TL.getElaboratedKeywordLoc(), QualifierLoc, TL.getTemplateKeywordLoc(), | |
| TL.getTemplateNameLoc(), NewTemplateArgs); | |
| } | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformAttributedType(TypeLocBuilder &TLB, | |
| AttributedTypeLoc TL) { | |
| const AttributedType *oldType = TL.getTypePtr(); | |
| QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc()); | |
| if (modifiedType.isNull()) | |
| return QualType(); | |
| // HLSL: re-validate matrix-layout markers after substitution. If the | |
| // post-substitution type is no longer a matrix, diagnose now. | |
| if (SemaRef.getLangOpts().HLSL && | |
| SemaRef.HLSL().diagnoseMatrixLayoutInstantiation( | |
| oldType->getAttrKind(), modifiedType, | |
| TL.getAttr() ? TL.getAttr()->getLocation() | |
| : TL.getModifiedLoc().getBeginLoc())) | |
| return QualType(); | |
| // oldAttr can be null if we started with a QualType rather than a TypeLoc. | |
| const Attr *oldAttr = TL.getAttr(); | |
| const Attr *newAttr = oldAttr ? getDerived().TransformAttr(oldAttr) : nullptr; | |
| if (oldAttr && !newAttr) | |
| return QualType(); | |
| QualType result = TL.getType(); | |
| // FIXME: dependent operand expressions? | |
| if (getDerived().AlwaysRebuild() || | |
| modifiedType != oldType->getModifiedType()) { | |
| // If the equivalent type is equal to the modified type, we don't want to | |
| // transform it as well because: | |
| // | |
| // 1. The transformation would yield the same result and is therefore | |
| // superfluous, and | |
| // | |
| // 2. Transforming the same type twice can cause problems, e.g. if it | |
| // is a FunctionProtoType, we may end up instantiating the function | |
| // parameters twice, which causes an assertion since the parameters | |
| // are already bound to their counterparts in the template for this | |
| // instantiation. | |
| // | |
| QualType equivalentType = modifiedType; | |
| if (TL.getModifiedLoc().getType() != TL.getEquivalentTypeLoc().getType()) { | |
| TypeLocBuilder AuxiliaryTLB; | |
| AuxiliaryTLB.reserve(TL.getFullDataSize()); | |
| equivalentType = | |
| getDerived().TransformType(AuxiliaryTLB, TL.getEquivalentTypeLoc()); | |
| if (equivalentType.isNull()) | |
| return QualType(); | |
| } | |
| if (SemaRef.getLangOpts().HLSL) { | |
| if (oldType->getAttrKind() == attr::HLSLRowMajor) | |
| equivalentType = SemaRef.Context.getMatrixTypeWithLayout( | |
| equivalentType, MatrixType::LayoutKind::RowMajor); | |
| else if (oldType->getAttrKind() == attr::HLSLColumnMajor) | |
| equivalentType = SemaRef.Context.getMatrixTypeWithLayout( | |
| equivalentType, MatrixType::LayoutKind::ColumnMajor); | |
| } | |
| // Check whether we can add nullability; it is only represented as | |
| // type sugar, and therefore cannot be diagnosed in any other way. | |
| if (auto nullability = oldType->getImmediateNullability()) { | |
| if (!modifiedType->canHaveNullability()) { | |
| SemaRef.Diag((TL.getAttr() ? TL.getAttr()->getLocation() | |
| : TL.getModifiedLoc().getBeginLoc()), | |
| diag::err_nullability_nonpointer) | |
| << DiagNullabilityKind(*nullability, false) << modifiedType; | |
| return QualType(); | |
| } | |
| } | |
| result = SemaRef.Context.getAttributedType(TL.getAttrKind(), | |
| modifiedType, | |
| equivalentType, | |
| TL.getAttr()); | |
| } | |
| AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result); | |
| newTL.setAttr(newAttr); | |
| return result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformCountAttributedType( | |
| TypeLocBuilder &TLB, CountAttributedTypeLoc TL) { | |
| const CountAttributedType *OldTy = TL.getTypePtr(); | |
| QualType InnerTy = getDerived().TransformType(TLB, TL.getInnerLoc()); | |
| if (InnerTy.isNull()) | |
| return QualType(); | |
| Expr *OldCount = TL.getCountExpr(); | |
| Expr *NewCount = nullptr; | |
| if (OldCount) { | |
| ExprResult CountResult = getDerived().TransformExpr(OldCount); | |
| if (CountResult.isInvalid()) | |
| return QualType(); | |
| NewCount = CountResult.get(); | |
| } | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || InnerTy != OldTy->desugar() || | |
| OldCount != NewCount) { | |
| // Currently, CountAttributedType can only wrap incomplete array types. | |
| Result = SemaRef.BuildCountAttributedArrayOrPointerType( | |
| InnerTy, NewCount, OldTy->isCountInBytes(), OldTy->isOrNull()); | |
| } | |
| TLB.push<CountAttributedTypeLoc>(Result); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformLateParsedAttrType(TypeLocBuilder &TLB, | |
| LateParsedAttrTypeLoc TL) { | |
| const LateParsedAttrType *OldTy = TL.getTypePtr(); | |
| QualType InnerTy = getDerived().TransformType(TLB, TL.getInnerLoc()); | |
| if (InnerTy.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || InnerTy != OldTy->getWrappedType()) { | |
| Result = SemaRef.Context.getLateParsedAttrType( | |
| InnerTy, OldTy->getLateParsedAttribute()); | |
| } | |
| LateParsedAttrTypeLoc newTL = TLB.push<LateParsedAttrTypeLoc>(Result); | |
| newTL.setAttrNameLoc(TL.getAttrNameLoc()); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformBTFTagAttributedType( | |
| TypeLocBuilder &TLB, BTFTagAttributedTypeLoc TL) { | |
| // The BTFTagAttributedType is available for C only. | |
| llvm_unreachable("Unexpected TreeTransform for BTFTagAttributedType"); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformOverflowBehaviorType( | |
| TypeLocBuilder &TLB, OverflowBehaviorTypeLoc TL) { | |
| const OverflowBehaviorType *OldTy = TL.getTypePtr(); | |
| QualType InnerTy = getDerived().TransformType(TLB, TL.getWrappedLoc()); | |
| if (InnerTy.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || InnerTy != OldTy->getUnderlyingType()) { | |
| Result = SemaRef.Context.getOverflowBehaviorType(OldTy->getBehaviorKind(), | |
| InnerTy); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| OverflowBehaviorTypeLoc NewTL = TLB.push<OverflowBehaviorTypeLoc>(Result); | |
| NewTL.initializeLocal(SemaRef.Context, TL.getAttrLoc()); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformHLSLAttributedResourceType( | |
| TypeLocBuilder &TLB, HLSLAttributedResourceTypeLoc TL) { | |
| const HLSLAttributedResourceType *oldType = TL.getTypePtr(); | |
| QualType WrappedTy = getDerived().TransformType(TLB, TL.getWrappedLoc()); | |
| if (WrappedTy.isNull()) | |
| return QualType(); | |
| QualType ContainedTy = QualType(); | |
| QualType OldContainedTy = oldType->getContainedType(); | |
| TypeSourceInfo *ContainedTSI = nullptr; | |
| if (!OldContainedTy.isNull()) { | |
| TypeSourceInfo *oldContainedTSI = TL.getContainedTypeSourceInfo(); | |
| if (!oldContainedTSI) | |
| oldContainedTSI = getSema().getASTContext().getTrivialTypeSourceInfo( | |
| OldContainedTy, SourceLocation()); | |
| ContainedTSI = getDerived().TransformType(oldContainedTSI); | |
| if (!ContainedTSI) | |
| return QualType(); | |
| ContainedTy = ContainedTSI->getType(); | |
| } | |
| HLSLAttributedResourceType::Attributes Attrs = oldType->getAttrs(); | |
| if (Attrs.SampleCountExpr) { | |
| ExprResult SampleCountResult = | |
| getDerived().TransformExpr(Attrs.SampleCountExpr); | |
| if (SampleCountResult.isInvalid()) | |
| return QualType(); | |
| Attrs.SampleCountExpr = SampleCountResult.get(); | |
| } | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || WrappedTy != oldType->getWrappedType() || | |
| ContainedTy != oldType->getContainedType() || | |
| Attrs.SampleCountExpr != oldType->getSampleCountExpr()) { | |
| Result = SemaRef.Context.getHLSLAttributedResourceType(WrappedTy, | |
| ContainedTy, Attrs); | |
| } | |
| HLSLAttributedResourceTypeLoc NewTL = | |
| TLB.push<HLSLAttributedResourceTypeLoc>(Result); | |
| NewTL.setSourceRange(TL.getLocalSourceRange()); | |
| NewTL.setContainedTypeSourceInfo(ContainedTSI); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformHLSLInlineSpirvType( | |
| TypeLocBuilder &TLB, HLSLInlineSpirvTypeLoc TL) { | |
| // No transformations needed. | |
| return TL.getType(); | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB, | |
| ParenTypeLoc TL) { | |
| QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc()); | |
| if (Inner.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| Inner != TL.getInnerLoc().getType()) { | |
| Result = getDerived().RebuildParenType(Inner); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result); | |
| NewTL.setLParenLoc(TL.getLParenLoc()); | |
| NewTL.setRParenLoc(TL.getRParenLoc()); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformMacroQualifiedType(TypeLocBuilder &TLB, | |
| MacroQualifiedTypeLoc TL) { | |
| QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc()); | |
| if (Inner.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || Inner != TL.getInnerLoc().getType()) { | |
| Result = | |
| getDerived().RebuildMacroQualifiedType(Inner, TL.getMacroIdentifier()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| MacroQualifiedTypeLoc NewTL = TLB.push<MacroQualifiedTypeLoc>(Result); | |
| NewTL.setExpansionLoc(TL.getExpansionLoc()); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformDependentNameType( | |
| TypeLocBuilder &TLB, DependentNameTypeLoc TL) { | |
| return TransformDependentNameType(TLB, TL, false); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::TransformDependentNameType( | |
| TypeLocBuilder &TLB, DependentNameTypeLoc TL, bool DeducedTSTContext, | |
| QualType ObjectType, NamedDecl *UnqualLookup) { | |
| const DependentNameType *T = TL.getTypePtr(); | |
| NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc(); | |
| if (QualifierLoc) { | |
| QualifierLoc = getDerived().TransformNestedNameSpecifierLoc( | |
| QualifierLoc, ObjectType, UnqualLookup); | |
| if (!QualifierLoc) | |
| return QualType(); | |
| } else { | |
| assert((ObjectType.isNull() && !UnqualLookup) && | |
| "must be transformed by TransformNestedNameSpecifierLoc"); | |
| } | |
| QualType Result | |
| = getDerived().RebuildDependentNameType(T->getKeyword(), | |
| TL.getElaboratedKeywordLoc(), | |
| QualifierLoc, | |
| T->getIdentifier(), | |
| TL.getNameLoc(), | |
| DeducedTSTContext); | |
| if (Result.isNull()) | |
| return QualType(); | |
| if (isa<TagType>(Result)) { | |
| auto NewTL = TLB.push<TagTypeLoc>(Result); | |
| NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); | |
| NewTL.setQualifierLoc(QualifierLoc); | |
| NewTL.setNameLoc(TL.getNameLoc()); | |
| } else if (isa<DeducedTemplateSpecializationType>(Result)) { | |
| auto NewTL = TLB.push<DeducedTemplateSpecializationTypeLoc>(Result); | |
| NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); | |
| NewTL.setTemplateNameLoc(TL.getNameLoc()); | |
| NewTL.setQualifierLoc(QualifierLoc); | |
| } else if (isa<TypedefType>(Result)) { | |
| TLB.push<TypedefTypeLoc>(Result).set(TL.getElaboratedKeywordLoc(), | |
| QualifierLoc, TL.getNameLoc()); | |
| } else if (isa<UnresolvedUsingType>(Result)) { | |
| auto NewTL = TLB.push<UnresolvedUsingTypeLoc>(Result); | |
| NewTL.set(TL.getElaboratedKeywordLoc(), QualifierLoc, TL.getNameLoc()); | |
| } else { | |
| auto NewTL = TLB.push<DependentNameTypeLoc>(Result); | |
| NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); | |
| NewTL.setQualifierLoc(QualifierLoc); | |
| NewTL.setNameLoc(TL.getNameLoc()); | |
| } | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::TransformPackExpansionType(TypeLocBuilder &TLB, | |
| PackExpansionTypeLoc TL) { | |
| QualType Pattern | |
| = getDerived().TransformType(TLB, TL.getPatternLoc()); | |
| if (Pattern.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| Pattern != TL.getPatternLoc().getType()) { | |
| Result = getDerived().RebuildPackExpansionType(Pattern, | |
| TL.getPatternLoc().getSourceRange(), | |
| TL.getEllipsisLoc(), | |
| TL.getTypePtr()->getNumExpansions()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| PackExpansionTypeLoc NewT = TLB.push<PackExpansionTypeLoc>(Result); | |
| NewT.setEllipsisLoc(TL.getEllipsisLoc()); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB, | |
| ObjCInterfaceTypeLoc TL) { | |
| // ObjCInterfaceType is never dependent. | |
| TLB.pushFullCopy(TL); | |
| return TL.getType(); | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformObjCTypeParamType(TypeLocBuilder &TLB, | |
| ObjCTypeParamTypeLoc TL) { | |
| const ObjCTypeParamType *T = TL.getTypePtr(); | |
| ObjCTypeParamDecl *OTP = cast_or_null<ObjCTypeParamDecl>( | |
| getDerived().TransformDecl(T->getDecl()->getLocation(), T->getDecl())); | |
| if (!OTP) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| OTP != T->getDecl()) { | |
| Result = getDerived().RebuildObjCTypeParamType( | |
| OTP, TL.getProtocolLAngleLoc(), | |
| llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()), | |
| TL.getProtocolLocs(), TL.getProtocolRAngleLoc()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| ObjCTypeParamTypeLoc NewTL = TLB.push<ObjCTypeParamTypeLoc>(Result); | |
| if (TL.getNumProtocols()) { | |
| NewTL.setProtocolLAngleLoc(TL.getProtocolLAngleLoc()); | |
| for (unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i) | |
| NewTL.setProtocolLoc(i, TL.getProtocolLoc(i)); | |
| NewTL.setProtocolRAngleLoc(TL.getProtocolRAngleLoc()); | |
| } | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB, | |
| ObjCObjectTypeLoc TL) { | |
| // Transform base type. | |
| QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc()); | |
| if (BaseType.isNull()) | |
| return QualType(); | |
| bool AnyChanged = BaseType != TL.getBaseLoc().getType(); | |
| // Transform type arguments. | |
| SmallVector<TypeSourceInfo *, 4> NewTypeArgInfos; | |
| for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) { | |
| TypeSourceInfo *TypeArgInfo = TL.getTypeArgTInfo(i); | |
| TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc(); | |
| QualType TypeArg = TypeArgInfo->getType(); | |
| if (auto PackExpansionLoc = TypeArgLoc.getAs<PackExpansionTypeLoc>()) { | |
| AnyChanged = true; | |
| // We have a pack expansion. Instantiate it. | |
| const auto *PackExpansion = PackExpansionLoc.getType() | |
| ->castAs<PackExpansionType>(); | |
| SmallVector<UnexpandedParameterPack, 2> Unexpanded; | |
| SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(), | |
| Unexpanded); | |
| assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); | |
| // Determine whether the set of unexpanded parameter packs can | |
| // and should be expanded. | |
| TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc(); | |
| bool Expand = false; | |
| bool RetainExpansion = false; | |
| UnsignedOrNone NumExpansions = PackExpansion->getNumExpansions(); | |
| if (getDerived().TryExpandParameterPacks( | |
| PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(), | |
| Unexpanded, /*FailOnPackProducingTemplates=*/true, Expand, | |
| RetainExpansion, NumExpansions)) | |
| return QualType(); | |
| if (!Expand) { | |
| // We can't expand this pack expansion into separate arguments yet; | |
| // just substitute into the pattern and create a new pack expansion | |
| // type. | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); | |
| TypeLocBuilder TypeArgBuilder; | |
| TypeArgBuilder.reserve(PatternLoc.getFullDataSize()); | |
| QualType NewPatternType = getDerived().TransformType(TypeArgBuilder, | |
| PatternLoc); | |
| if (NewPatternType.isNull()) | |
| return QualType(); | |
| QualType NewExpansionType = SemaRef.Context.getPackExpansionType( | |
| NewPatternType, NumExpansions); | |
| auto NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(NewExpansionType); | |
| NewExpansionLoc.setEllipsisLoc(PackExpansionLoc.getEllipsisLoc()); | |
| NewTypeArgInfos.push_back( | |
| TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewExpansionType)); | |
| continue; | |
| } | |
| // Substitute into the pack expansion pattern for each slice of the | |
| // pack. | |
| for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), ArgIdx); | |
| TypeLocBuilder TypeArgBuilder; | |
| TypeArgBuilder.reserve(PatternLoc.getFullDataSize()); | |
| QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder, | |
| PatternLoc); | |
| if (NewTypeArg.isNull()) | |
| return QualType(); | |
| NewTypeArgInfos.push_back( | |
| TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg)); | |
| } | |
| continue; | |
| } | |
| TypeLocBuilder TypeArgBuilder; | |
| TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize()); | |
| QualType NewTypeArg = | |
| getDerived().TransformType(TypeArgBuilder, TypeArgLoc); | |
| if (NewTypeArg.isNull()) | |
| return QualType(); | |
| // If nothing changed, just keep the old TypeSourceInfo. | |
| if (NewTypeArg == TypeArg) { | |
| NewTypeArgInfos.push_back(TypeArgInfo); | |
| continue; | |
| } | |
| NewTypeArgInfos.push_back( | |
| TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg)); | |
| AnyChanged = true; | |
| } | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || AnyChanged) { | |
| // Rebuild the type. | |
| Result = getDerived().RebuildObjCObjectType( | |
| BaseType, TL.getBeginLoc(), TL.getTypeArgsLAngleLoc(), NewTypeArgInfos, | |
| TL.getTypeArgsRAngleLoc(), TL.getProtocolLAngleLoc(), | |
| llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()), | |
| TL.getProtocolLocs(), TL.getProtocolRAngleLoc()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| ObjCObjectTypeLoc NewT = TLB.push<ObjCObjectTypeLoc>(Result); | |
| NewT.setHasBaseTypeAsWritten(true); | |
| NewT.setTypeArgsLAngleLoc(TL.getTypeArgsLAngleLoc()); | |
| for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) | |
| NewT.setTypeArgTInfo(i, NewTypeArgInfos[i]); | |
| NewT.setTypeArgsRAngleLoc(TL.getTypeArgsRAngleLoc()); | |
| NewT.setProtocolLAngleLoc(TL.getProtocolLAngleLoc()); | |
| for (unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i) | |
| NewT.setProtocolLoc(i, TL.getProtocolLoc(i)); | |
| NewT.setProtocolRAngleLoc(TL.getProtocolRAngleLoc()); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB, | |
| ObjCObjectPointerTypeLoc TL) { | |
| QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); | |
| if (PointeeType.isNull()) | |
| return QualType(); | |
| QualType Result = TL.getType(); | |
| if (getDerived().AlwaysRebuild() || | |
| PointeeType != TL.getPointeeLoc().getType()) { | |
| Result = getDerived().RebuildObjCObjectPointerType(PointeeType, | |
| TL.getStarLoc()); | |
| if (Result.isNull()) | |
| return QualType(); | |
| } | |
| ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result); | |
| NewT.setStarLoc(TL.getStarLoc()); | |
| return Result; | |
| } | |
| //===----------------------------------------------------------------------===// | |
| // Statement transformation | |
| //===----------------------------------------------------------------------===// | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformNullStmt(NullStmt *S) { | |
| return S; | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) { | |
| return getDerived().TransformCompoundStmt(S, false); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, | |
| bool IsStmtExpr) { | |
| Sema::CompoundScopeRAII CompoundScope(getSema()); | |
| Sema::FPFeaturesStateRAII FPSave(getSema()); | |
| if (S->hasStoredFPFeatures()) | |
| getSema().resetFPOptions( | |
| S->getStoredFPFeatures().applyOverrides(getSema().getLangOpts())); | |
| bool SubStmtInvalid = false; | |
| bool SubStmtChanged = false; | |
| SmallVector<Stmt*, 8> Statements; | |
| for (auto *B : S->body()) { | |
| StmtResult Result = getDerived().TransformStmt( | |
| B, IsStmtExpr && B == S->body_back() ? StmtDiscardKind::StmtExprResult | |
| : StmtDiscardKind::Discarded); | |
| if (Result.isInvalid()) { | |
| // Immediately fail if this was a DeclStmt, since it's very | |
| // likely that this will cause problems for future statements. | |
| if (isa<DeclStmt>(B)) | |
| return StmtError(); | |
| // Otherwise, just keep processing substatements and fail later. | |
| SubStmtInvalid = true; | |
| continue; | |
| } | |
| SubStmtChanged = SubStmtChanged || Result.get() != B; | |
| Statements.push_back(Result.getAs<Stmt>()); | |
| } | |
| if (SubStmtInvalid) | |
| return StmtError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| !SubStmtChanged) | |
| return S; | |
| return getDerived().RebuildCompoundStmt(S->getLBracLoc(), | |
| Statements, | |
| S->getRBracLoc(), | |
| IsStmtExpr); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) { | |
| ExprResult LHS, RHS; | |
| { | |
| EnterExpressionEvaluationContext Unevaluated( | |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); | |
| // Transform the left-hand case value. | |
| LHS = getDerived().TransformExpr(S->getLHS()); | |
| LHS = SemaRef.ActOnCaseExpr(S->getCaseLoc(), LHS); | |
| if (LHS.isInvalid()) | |
| return StmtError(); | |
| // Transform the right-hand case value (for the GNU case-range extension). | |
| RHS = getDerived().TransformExpr(S->getRHS()); | |
| RHS = SemaRef.ActOnCaseExpr(S->getCaseLoc(), RHS); | |
| if (RHS.isInvalid()) | |
| return StmtError(); | |
| } | |
| // Build the case statement. | |
| // Case statements are always rebuilt so that they will attached to their | |
| // transformed switch statement. | |
| StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(), | |
| LHS.get(), | |
| S->getEllipsisLoc(), | |
| RHS.get(), | |
| S->getColonLoc()); | |
| if (Case.isInvalid()) | |
| return StmtError(); | |
| // Transform the statement following the case | |
| StmtResult SubStmt = | |
| getDerived().TransformStmt(S->getSubStmt()); | |
| if (SubStmt.isInvalid()) | |
| return StmtError(); | |
| // Attach the body to the case statement | |
| return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get()); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) { | |
| // Transform the statement following the default case | |
| StmtResult SubStmt = | |
| getDerived().TransformStmt(S->getSubStmt()); | |
| if (SubStmt.isInvalid()) | |
| return StmtError(); | |
| // Default statements are always rebuilt | |
| return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(), | |
| SubStmt.get()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S, StmtDiscardKind SDK) { | |
| StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK); | |
| if (SubStmt.isInvalid()) | |
| return StmtError(); | |
| Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(), | |
| S->getDecl()); | |
| if (!LD) | |
| return StmtError(); | |
| // If we're transforming "in-place" (we're not creating new local | |
| // declarations), assume we're replacing the old label statement | |
| // and clear out the reference to it. | |
| if (LD == S->getDecl()) | |
| S->getDecl()->setStmt(nullptr); | |
| // FIXME: Pass the real colon location in. | |
| return getDerived().RebuildLabelStmt(S->getIdentLoc(), | |
| cast<LabelDecl>(LD), SourceLocation(), | |
| SubStmt.get()); | |
| } | |
| template <typename Derived> | |
| const Attr *TreeTransform<Derived>::TransformAttr(const Attr *R) { | |
| if (!R) | |
| return R; | |
| switch (R->getKind()) { | |
| // Transform attributes by calling TransformXXXAttr. | |
| #define ATTR(X) \ | |
| case attr::X: \ | |
| return getDerived().Transform##X##Attr(cast<X##Attr>(R)); | |
| #include "clang/Basic/AttrList.inc" | |
| } | |
| return R; | |
| } | |
| template <typename Derived> | |
| const Attr *TreeTransform<Derived>::TransformStmtAttr(const Stmt *OrigS, | |
| const Stmt *InstS, | |
| const Attr *R) { | |
| if (!R) | |
| return R; | |
| switch (R->getKind()) { | |
| // Transform attributes by calling TransformStmtXXXAttr. | |
| #define ATTR(X) \ | |
| case attr::X: \ | |
| return getDerived().TransformStmt##X##Attr(OrigS, InstS, cast<X##Attr>(R)); | |
| #include "clang/Basic/AttrList.inc" | |
| } | |
| return TransformAttr(R); | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformAttributedStmt(AttributedStmt *S, | |
| StmtDiscardKind SDK) { | |
| StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK); | |
| if (SubStmt.isInvalid()) | |
| return StmtError(); | |
| bool AttrsChanged = false; | |
| SmallVector<const Attr *, 1> Attrs; | |
| // Visit attributes and keep track if any are transformed. | |
| for (const auto *I : S->getAttrs()) { | |
| const Attr *R = | |
| getDerived().TransformStmtAttr(S->getSubStmt(), SubStmt.get(), I); | |
| AttrsChanged |= (I != R); | |
| if (R) | |
| Attrs.push_back(R); | |
| } | |
| if (SubStmt.get() == S->getSubStmt() && !AttrsChanged) | |
| return S; | |
| // If transforming the attributes failed for all of the attributes in the | |
| // statement, don't make an AttributedStmt without attributes. | |
| if (Attrs.empty()) | |
| return SubStmt; | |
| return getDerived().RebuildAttributedStmt(S->getAttrLoc(), Attrs, | |
| SubStmt.get()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { | |
| // Transform the initialization statement | |
| StmtResult Init = getDerived().TransformStmt(S->getInit()); | |
| if (Init.isInvalid()) | |
| return StmtError(); | |
| Sema::ConditionResult Cond; | |
| if (!S->isConsteval()) { | |
| // Transform the condition | |
| Cond = getDerived().TransformCondition( | |
| S->getIfLoc(), S->getConditionVariable(), S->getCond(), | |
| S->isConstexpr() ? Sema::ConditionKind::ConstexprIf | |
| : Sema::ConditionKind::Boolean); | |
| if (Cond.isInvalid()) | |
| return StmtError(); | |
| } | |
| // If this is a constexpr if, determine which arm we should instantiate. | |
| std::optional<bool> ConstexprConditionValue; | |
| if (S->isConstexpr()) | |
| ConstexprConditionValue = Cond.getKnownValue(); | |
| // Transform the "then" branch. | |
| StmtResult Then; | |
| if (!ConstexprConditionValue || *ConstexprConditionValue) { | |
| EnterExpressionEvaluationContext Ctx( | |
| getSema(), Sema::ExpressionEvaluationContext::ImmediateFunctionContext, | |
| nullptr, Sema::ExpressionEvaluationContextRecord::EK_Other, | |
| S->isNonNegatedConsteval()); | |
| Then = getDerived().TransformStmt(S->getThen()); | |
| if (Then.isInvalid()) | |
| return StmtError(); | |
| } else { | |
| // Discarded branch is replaced with empty CompoundStmt so we can keep | |
| // proper source location for start and end of original branch, so | |
| // subsequent transformations like CoverageMapping work properly | |
| Then = new (getSema().Context) | |
| CompoundStmt(S->getThen()->getBeginLoc(), S->getThen()->getEndLoc()); | |
| } | |
| // Transform the "else" branch. | |
| StmtResult Else; | |
| if (!ConstexprConditionValue || !*ConstexprConditionValue) { | |
| EnterExpressionEvaluationContext Ctx( | |
| getSema(), Sema::ExpressionEvaluationContext::ImmediateFunctionContext, | |
| nullptr, Sema::ExpressionEvaluationContextRecord::EK_Other, | |
| S->isNegatedConsteval()); | |
| Else = getDerived().TransformStmt(S->getElse()); | |
| if (Else.isInvalid()) | |
| return StmtError(); | |
| } else if (S->getElse() && ConstexprConditionValue && | |
| *ConstexprConditionValue) { | |
| // Same thing here as with <then> branch, we are discarding it, we can't | |
| // replace it with NULL nor NullStmt as we need to keep for source location | |
| // range, for CoverageMapping | |
| Else = new (getSema().Context) | |
| CompoundStmt(S->getElse()->getBeginLoc(), S->getElse()->getEndLoc()); | |
| } | |
| if (!getDerived().AlwaysRebuild() && | |
| Init.get() == S->getInit() && | |
| Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) && | |
| Then.get() == S->getThen() && | |
| Else.get() == S->getElse()) | |
| return S; | |
| return getDerived().RebuildIfStmt( | |
| S->getIfLoc(), S->getStatementKind(), S->getLParenLoc(), Cond, | |
| S->getRParenLoc(), Init.get(), Then.get(), S->getElseLoc(), Else.get()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { | |
| // Transform the initialization statement | |
| StmtResult Init = getDerived().TransformStmt(S->getInit()); | |
| if (Init.isInvalid()) | |
| return StmtError(); | |
| // Transform the condition. | |
| Sema::ConditionResult Cond = getDerived().TransformCondition( | |
| S->getSwitchLoc(), S->getConditionVariable(), S->getCond(), | |
| Sema::ConditionKind::Switch); | |
| if (Cond.isInvalid()) | |
| return StmtError(); | |
| // Rebuild the switch statement. | |
| StmtResult Switch = | |
| getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), S->getLParenLoc(), | |
| Init.get(), Cond, S->getRParenLoc()); | |
| if (Switch.isInvalid()) | |
| return StmtError(); | |
| // Transform the body of the switch statement. | |
| StmtResult Body = getDerived().TransformStmt(S->getBody()); | |
| // Complete the switch statement. | |
| return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(), | |
| Body.get()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { | |
| // Transform the condition | |
| Sema::ConditionResult Cond = getDerived().TransformCondition( | |
| S->getWhileLoc(), S->getConditionVariable(), S->getCond(), | |
| Sema::ConditionKind::Boolean); | |
| if (Cond.isInvalid()) | |
| return StmtError(); | |
| // OpenACC Restricts a while-loop inside of certain construct/clause | |
| // combinations, so diagnose that here in OpenACC mode. | |
| SemaOpenACC::LoopInConstructRAII LCR{SemaRef.OpenACC()}; | |
| SemaRef.OpenACC().ActOnWhileStmt(S->getBeginLoc()); | |
| // Transform the body | |
| StmtResult Body = getDerived().TransformStmt(S->getBody()); | |
| if (Body.isInvalid()) | |
| return StmtError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) && | |
| Body.get() == S->getBody()) | |
| return Owned(S); | |
| return getDerived().RebuildWhileStmt(S->getWhileLoc(), S->getLParenLoc(), | |
| Cond, S->getRParenLoc(), Body.get()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { | |
| // OpenACC Restricts a do-loop inside of certain construct/clause | |
| // combinations, so diagnose that here in OpenACC mode. | |
| SemaOpenACC::LoopInConstructRAII LCR{SemaRef.OpenACC()}; | |
| SemaRef.OpenACC().ActOnDoStmt(S->getBeginLoc()); | |
| // Transform the body | |
| StmtResult Body = getDerived().TransformStmt(S->getBody()); | |
| if (Body.isInvalid()) | |
| return StmtError(); | |
| // Transform the condition | |
| ExprResult Cond = getDerived().TransformExpr(S->getCond()); | |
| if (Cond.isInvalid()) | |
| return StmtError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| Cond.get() == S->getCond() && | |
| Body.get() == S->getBody()) | |
| return S; | |
| return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(), | |
| /*FIXME:*/S->getWhileLoc(), Cond.get(), | |
| S->getRParenLoc()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformForStmt(ForStmt *S) { | |
| if (getSema().getLangOpts().getOpenMPVersion()) | |
| getSema().OpenMP().startOpenMPLoop(); | |
| // Transform the initialization statement | |
| StmtResult Init = getDerived().TransformStmt(S->getInit()); | |
| if (Init.isInvalid()) | |
| return StmtError(); | |
| // In OpenMP loop region loop control variable must be captured and be | |
| // private. Perform analysis of first part (if any). | |
| if (getSema().getLangOpts().getOpenMPVersion() && Init.isUsable()) | |
| getSema().OpenMP().ActOnOpenMPLoopInitialization(S->getForLoc(), | |
| Init.get()); | |
| // Transform the condition | |
| Sema::ConditionResult Cond = getDerived().TransformCondition( | |
| S->getForLoc(), S->getConditionVariable(), S->getCond(), | |
| Sema::ConditionKind::Boolean); | |
| if (Cond.isInvalid()) | |
| return StmtError(); | |
| // Transform the increment | |
| ExprResult Inc = getDerived().TransformExpr(S->getInc()); | |
| if (Inc.isInvalid()) | |
| return StmtError(); | |
| Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(Inc.get())); | |
| if (S->getInc() && !FullInc.get()) | |
| return StmtError(); | |
| // OpenACC Restricts a for-loop inside of certain construct/clause | |
| // combinations, so diagnose that here in OpenACC mode. | |
| SemaOpenACC::LoopInConstructRAII LCR{SemaRef.OpenACC()}; | |
| SemaRef.OpenACC().ActOnForStmtBegin( | |
| S->getBeginLoc(), S->getInit(), Init.get(), S->getCond(), | |
| Cond.get().second, S->getInc(), Inc.get()); | |
| // Transform the body | |
| StmtResult Body = getDerived().TransformStmt(S->getBody()); | |
| if (Body.isInvalid()) | |
| return StmtError(); | |
| SemaRef.OpenACC().ActOnForStmtEnd(S->getBeginLoc(), Body); | |
| if (!getDerived().AlwaysRebuild() && | |
| Init.get() == S->getInit() && | |
| Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) && | |
| Inc.get() == S->getInc() && | |
| Body.get() == S->getBody()) | |
| return S; | |
| return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(), | |
| Init.get(), Cond, FullInc, | |
| S->getRParenLoc(), Body.get()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) { | |
| Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(), | |
| S->getLabel()); | |
| if (!LD) | |
| return StmtError(); | |
| // Goto statements must always be rebuilt, to resolve the label. | |
| return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(), | |
| cast<LabelDecl>(LD)); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { | |
| ExprResult Target = getDerived().TransformExpr(S->getTarget()); | |
| if (Target.isInvalid()) | |
| return StmtError(); | |
| Target = SemaRef.MaybeCreateExprWithCleanups(Target.get()); | |
| if (!getDerived().AlwaysRebuild() && | |
| Target.get() == S->getTarget()) | |
| return S; | |
| return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(), | |
| Target.get()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { | |
| if (!S->hasLabelTarget()) | |
| return S; | |
| Decl *LD = getDerived().TransformDecl(S->getLabelDecl()->getLocation(), | |
| S->getLabelDecl()); | |
| if (!LD) | |
| return StmtError(); | |
| return new (SemaRef.Context) | |
| ContinueStmt(S->getKwLoc(), S->getLabelLoc(), cast<LabelDecl>(LD)); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { | |
| if (!S->hasLabelTarget()) | |
| return S; | |
| Decl *LD = getDerived().TransformDecl(S->getLabelDecl()->getLocation(), | |
| S->getLabelDecl()); | |
| if (!LD) | |
| return StmtError(); | |
| return new (SemaRef.Context) | |
| BreakStmt(S->getKwLoc(), S->getLabelLoc(), cast<LabelDecl>(LD)); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformDeferStmt(DeferStmt *S) { | |
| StmtResult Result = getDerived().TransformStmt(S->getBody()); | |
| if (!Result.isUsable()) | |
| return StmtError(); | |
| return DeferStmt::Create(getSema().Context, S->getDeferLoc(), Result.get()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) { | |
| ExprResult Result = getDerived().TransformInitializer(S->getRetValue(), | |
| /*NotCopyInit*/false); | |
| if (Result.isInvalid()) | |
| return StmtError(); | |
| // FIXME: We always rebuild the return statement because there is no way | |
| // to tell whether the return type of the function has changed. | |
| return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { | |
| bool DeclChanged = false; | |
| SmallVector<Decl *, 4> Decls; | |
| LambdaScopeInfo *LSI = getSema().getCurLambda(); | |
| for (auto *D : S->decls()) { | |
| Decl *Transformed = getDerived().TransformDefinition(D->getLocation(), D); | |
| if (!Transformed) | |
| return StmtError(); | |
| if (Transformed != D) | |
| DeclChanged = true; | |
| if (LSI) { | |
| if (auto *TD = dyn_cast<TypeDecl>(Transformed)) { | |
| if (auto *TN = dyn_cast<TypedefNameDecl>(TD)) { | |
| LSI->ContainsUnexpandedParameterPack |= | |
| TN->getUnderlyingType()->containsUnexpandedParameterPack(); | |
| } else { | |
| LSI->ContainsUnexpandedParameterPack |= | |
| getSema() | |
| .getASTContext() | |
| .getTypeDeclType(TD) | |
| ->containsUnexpandedParameterPack(); | |
| } | |
| } | |
| if (auto *VD = dyn_cast<VarDecl>(Transformed)) | |
| LSI->ContainsUnexpandedParameterPack |= | |
| VD->getType()->containsUnexpandedParameterPack(); | |
| } | |
| Decls.push_back(Transformed); | |
| } | |
| if (!getDerived().AlwaysRebuild() && !DeclChanged) | |
| return S; | |
| return getDerived().RebuildDeclStmt(Decls, S->getBeginLoc(), S->getEndLoc()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) { | |
| SmallVector<Expr*, 8> Constraints; | |
| SmallVector<Expr*, 8> Exprs; | |
| SmallVector<IdentifierInfo *, 4> Names; | |
| SmallVector<Expr*, 8> Clobbers; | |
| bool ExprsChanged = false; | |
| auto RebuildString = [&](Expr *E) { | |
| ExprResult Result = getDerived().TransformExpr(E); | |
| if (!Result.isUsable()) | |
| return Result; | |
| if (Result.get() != E) { | |
| ExprsChanged = true; | |
| Result = SemaRef.ActOnGCCAsmStmtString(Result.get(), /*ForLabel=*/false); | |
| } | |
| return Result; | |
| }; | |
| // Go through the outputs. | |
| for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) { | |
| Names.push_back(S->getOutputIdentifier(I)); | |
| ExprResult Result = RebuildString(S->getOutputConstraintExpr(I)); | |
| if (Result.isInvalid()) | |
| return StmtError(); | |
| Constraints.push_back(Result.get()); | |
| // Transform the output expr. | |
| Expr *OutputExpr = S->getOutputExpr(I); | |
| Result = getDerived().TransformExpr(OutputExpr); | |
| if (Result.isInvalid()) | |
| return StmtError(); | |
| ExprsChanged |= Result.get() != OutputExpr; | |
| Exprs.push_back(Result.get()); | |
| } | |
| // Go through the inputs. | |
| for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) { | |
| Names.push_back(S->getInputIdentifier(I)); | |
| ExprResult Result = RebuildString(S->getInputConstraintExpr(I)); | |
| if (Result.isInvalid()) | |
| return StmtError(); | |
| Constraints.push_back(Result.get()); | |
| // Transform the input expr. | |
| Expr *InputExpr = S->getInputExpr(I); | |
| Result = getDerived().TransformExpr(InputExpr); | |
| if (Result.isInvalid()) | |
| return StmtError(); | |
| ExprsChanged |= Result.get() != InputExpr; | |
| Exprs.push_back(Result.get()); | |
| } | |
| // Go through the Labels. | |
| for (unsigned I = 0, E = S->getNumLabels(); I != E; ++I) { | |
| Names.push_back(S->getLabelIdentifier(I)); | |
| ExprResult Result = getDerived().TransformExpr(S->getLabelExpr(I)); | |
| if (Result.isInvalid()) | |
| return StmtError(); | |
| ExprsChanged |= Result.get() != S->getLabelExpr(I); | |
| Exprs.push_back(Result.get()); | |
| } | |
| // Go through the clobbers. | |
| for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I) { | |
| ExprResult Result = RebuildString(S->getClobberExpr(I)); | |
| if (Result.isInvalid()) | |
| return StmtError(); | |
| Clobbers.push_back(Result.get()); | |
| } | |
| ExprResult AsmString = RebuildString(S->getAsmStringExpr()); | |
| if (AsmString.isInvalid()) | |
| return StmtError(); | |
| if (!getDerived().AlwaysRebuild() && !ExprsChanged) | |
| return S; | |
| return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(), | |
| S->isVolatile(), S->getNumOutputs(), | |
| S->getNumInputs(), Names.data(), | |
| Constraints, Exprs, AsmString.get(), | |
| Clobbers, S->getNumLabels(), | |
| S->getRParenLoc()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) { | |
| ArrayRef<Token> AsmToks = llvm::ArrayRef(S->getAsmToks(), S->getNumAsmToks()); | |
| bool HadError = false, HadChange = false; | |
| ArrayRef<Expr*> SrcExprs = S->getAllExprs(); | |
| SmallVector<Expr*, 8> TransformedExprs; | |
| TransformedExprs.reserve(SrcExprs.size()); | |
| for (unsigned i = 0, e = SrcExprs.size(); i != e; ++i) { | |
| ExprResult Result = getDerived().TransformExpr(SrcExprs[i]); | |
| if (!Result.isUsable()) { | |
| HadError = true; | |
| } else { | |
| HadChange |= (Result.get() != SrcExprs[i]); | |
| TransformedExprs.push_back(Result.get()); | |
| } | |
| } | |
| if (HadError) return StmtError(); | |
| if (!HadChange && !getDerived().AlwaysRebuild()) | |
| return Owned(S); | |
| return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(), | |
| AsmToks, S->getAsmString(), | |
| S->getNumOutputs(), S->getNumInputs(), | |
| S->getAllConstraints(), S->getClobbers(), | |
| TransformedExprs, S->getEndLoc()); | |
| } | |
| // C++ Coroutines | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) { | |
| auto *ScopeInfo = SemaRef.getCurFunction(); | |
| auto *FD = cast<FunctionDecl>(SemaRef.CurContext); | |
| assert(FD && ScopeInfo && !ScopeInfo->CoroutinePromise && | |
| ScopeInfo->NeedsCoroutineSuspends && | |
| ScopeInfo->CoroutineSuspends.first == nullptr && | |
| ScopeInfo->CoroutineSuspends.second == nullptr && | |
| "expected clean scope info"); | |
| // Set that we have (possibly-invalid) suspend points before we do anything | |
| // that may fail. | |
| ScopeInfo->setNeedsCoroutineSuspends(false); | |
| // We re-build the coroutine promise object (and the coroutine parameters its | |
| // type and constructor depend on) based on the types used in our current | |
| // function. We must do so, and set it on the current FunctionScopeInfo, | |
| // before attempting to transform the other parts of the coroutine body | |
| // statement, such as the implicit suspend statements (because those | |
| // statements reference the FunctionScopeInfo::CoroutinePromise). | |
| if (!SemaRef.buildCoroutineParameterMoves(FD->getLocation())) | |
| return StmtError(); | |
| auto *Promise = SemaRef.buildCoroutinePromise(FD->getLocation()); | |
| if (!Promise) | |
| return StmtError(); | |
| getDerived().transformedLocalDecl(S->getPromiseDecl(), {Promise}); | |
| ScopeInfo->CoroutinePromise = Promise; | |
| // Transform the implicit coroutine statements constructed using dependent | |
| // types during the previous parse: initial and final suspensions, the return | |
| // object, and others. We also transform the coroutine function's body. | |
| StmtResult InitSuspend = getDerived().TransformStmt(S->getInitSuspendStmt()); | |
| if (InitSuspend.isInvalid()) | |
| return StmtError(); | |
| StmtResult FinalSuspend = | |
| getDerived().TransformStmt(S->getFinalSuspendStmt()); | |
| if (FinalSuspend.isInvalid() || | |
| !SemaRef.checkFinalSuspendNoThrow(FinalSuspend.get())) | |
| return StmtError(); | |
| ScopeInfo->setCoroutineSuspends(InitSuspend.get(), FinalSuspend.get()); | |
| assert(isa<Expr>(InitSuspend.get()) && isa<Expr>(FinalSuspend.get())); | |
| StmtResult BodyRes = getDerived().TransformStmt(S->getBody()); | |
| if (BodyRes.isInvalid()) | |
| return StmtError(); | |
| CoroutineStmtBuilder Builder(SemaRef, *FD, *ScopeInfo, BodyRes.get()); | |
| if (Builder.isInvalid()) | |
| return StmtError(); | |
| Expr *ReturnObject = S->getReturnValueInit(); | |
| assert(ReturnObject && "the return object is expected to be valid"); | |
| ExprResult Res = getDerived().TransformInitializer(ReturnObject, | |
| /*NoCopyInit*/ false); | |
| if (Res.isInvalid()) | |
| return StmtError(); | |
| Builder.ReturnValue = Res.get(); | |
| // If during the previous parse the coroutine still had a dependent promise | |
| // statement, we may need to build some implicit coroutine statements | |
| // (such as exception and fallthrough handlers) for the first time. | |
| if (S->hasDependentPromiseType()) { | |
| // We can only build these statements, however, if the current promise type | |
| // is not dependent. | |
| if (!Promise->getType()->isDependentType()) { | |
| assert(!S->getFallthroughHandler() && !S->getExceptionHandler() && | |
| !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() && | |
| "these nodes should not have been built yet"); | |
| if (!Builder.buildDependentStatements()) | |
| return StmtError(); | |
| } | |
| } else { | |
| if (auto *OnFallthrough = S->getFallthroughHandler()) { | |
| StmtResult Res = getDerived().TransformStmt(OnFallthrough); | |
| if (Res.isInvalid()) | |
| return StmtError(); | |
| Builder.OnFallthrough = Res.get(); | |
| } | |
| if (auto *OnException = S->getExceptionHandler()) { | |
| StmtResult Res = getDerived().TransformStmt(OnException); | |
| if (Res.isInvalid()) | |
| return StmtError(); | |
| Builder.OnException = Res.get(); | |
| } | |
| if (auto *OnAllocFailure = S->getReturnStmtOnAllocFailure()) { | |
| StmtResult Res = getDerived().TransformStmt(OnAllocFailure); | |
| if (Res.isInvalid()) | |
| return StmtError(); | |
| Builder.ReturnStmtOnAllocFailure = Res.get(); | |
| } | |
| // Transform any additional statements we may have already built | |
| assert(S->getAllocate() && S->getDeallocate() && | |
| "allocation and deallocation calls must already be built"); | |
| ExprResult AllocRes = getDerived().TransformExpr(S->getAllocate()); | |
| if (AllocRes.isInvalid()) | |
| return StmtError(); | |
| Builder.Allocate = AllocRes.get(); | |
| ExprResult DeallocRes = getDerived().TransformExpr(S->getDeallocate()); | |
| if (DeallocRes.isInvalid()) | |
| return StmtError(); | |
| Builder.Deallocate = DeallocRes.get(); | |
| if (auto *ResultDecl = S->getResultDecl()) { | |
| StmtResult Res = getDerived().TransformStmt(ResultDecl); | |
| if (Res.isInvalid()) | |
| return StmtError(); | |
| Builder.ResultDecl = Res.get(); | |
| } | |
| if (auto *ReturnStmt = S->getReturnStmt()) { | |
| StmtResult Res = getDerived().TransformStmt(ReturnStmt); | |
| if (Res.isInvalid()) | |
| return StmtError(); | |
| Builder.ReturnStmt = Res.get(); | |
| } | |
| } | |
| return getDerived().RebuildCoroutineBodyStmt(Builder); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformCoreturnStmt(CoreturnStmt *S) { | |
| ExprResult Result = getDerived().TransformInitializer(S->getOperand(), | |
| /*NotCopyInit*/false); | |
| if (Result.isInvalid()) | |
| return StmtError(); | |
| // Always rebuild; we don't know if this needs to be injected into a new | |
| // context or if the promise type has changed. | |
| return getDerived().RebuildCoreturnStmt(S->getKeywordLoc(), Result.get(), | |
| S->isImplicit()); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *E) { | |
| ExprResult Operand = getDerived().TransformInitializer(E->getOperand(), | |
| /*NotCopyInit*/ false); | |
| if (Operand.isInvalid()) | |
| return ExprError(); | |
| // Rebuild the common-expr from the operand rather than transforming it | |
| // separately. | |
| // FIXME: getCurScope() should not be used during template instantiation. | |
| // We should pick up the set of unqualified lookup results for operator | |
| // co_await during the initial parse. | |
| ExprResult Lookup = getSema().BuildOperatorCoawaitLookupExpr( | |
| getSema().getCurScope(), E->getKeywordLoc()); | |
| // Always rebuild; we don't know if this needs to be injected into a new | |
| // context or if the promise type has changed. | |
| return getDerived().RebuildCoawaitExpr( | |
| E->getKeywordLoc(), Operand.get(), | |
| cast<UnresolvedLookupExpr>(Lookup.get()), E->isImplicit()); | |
| } | |
| template <typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformDependentCoawaitExpr(DependentCoawaitExpr *E) { | |
| ExprResult OperandResult = getDerived().TransformInitializer(E->getOperand(), | |
| /*NotCopyInit*/ false); | |
| if (OperandResult.isInvalid()) | |
| return ExprError(); | |
| ExprResult LookupResult = getDerived().TransformUnresolvedLookupExpr( | |
| E->getOperatorCoawaitLookup()); | |
| if (LookupResult.isInvalid()) | |
| return ExprError(); | |
| // Always rebuild; we don't know if this needs to be injected into a new | |
| // context or if the promise type has changed. | |
| return getDerived().RebuildDependentCoawaitExpr( | |
| E->getKeywordLoc(), OperandResult.get(), | |
| cast<UnresolvedLookupExpr>(LookupResult.get())); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCoyieldExpr(CoyieldExpr *E) { | |
| ExprResult Result = getDerived().TransformInitializer(E->getOperand(), | |
| /*NotCopyInit*/false); | |
| if (Result.isInvalid()) | |
| return ExprError(); | |
| // Always rebuild; we don't know if this needs to be injected into a new | |
| // context or if the promise type has changed. | |
| return getDerived().RebuildCoyieldExpr(E->getKeywordLoc(), Result.get()); | |
| } | |
| // Objective-C Statements. | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { | |
| // Transform the body of the @try. | |
| StmtResult TryBody = getDerived().TransformStmt(S->getTryBody()); | |
| if (TryBody.isInvalid()) | |
| return StmtError(); | |
| // Transform the @catch statements (if present). | |
| bool AnyCatchChanged = false; | |
| SmallVector<Stmt*, 8> CatchStmts; | |
| for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) { | |
| StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I)); | |
| if (Catch.isInvalid()) | |
| return StmtError(); | |
| if (Catch.get() != S->getCatchStmt(I)) | |
| AnyCatchChanged = true; | |
| CatchStmts.push_back(Catch.get()); | |
| } | |
| // Transform the @finally statement (if present). | |
| StmtResult Finally; | |
| if (S->getFinallyStmt()) { | |
| Finally = getDerived().TransformStmt(S->getFinallyStmt()); | |
| if (Finally.isInvalid()) | |
| return StmtError(); | |
| } | |
| // If nothing changed, just retain this statement. | |
| if (!getDerived().AlwaysRebuild() && | |
| TryBody.get() == S->getTryBody() && | |
| !AnyCatchChanged && | |
| Finally.get() == S->getFinallyStmt()) | |
| return S; | |
| // Build a new statement. | |
| return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(), | |
| CatchStmts, Finally.get()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { | |
| // Transform the @catch parameter, if there is one. | |
| VarDecl *Var = nullptr; | |
| if (VarDecl *FromVar = S->getCatchParamDecl()) { | |
| TypeSourceInfo *TSInfo = nullptr; | |
| if (FromVar->getTypeSourceInfo()) { | |
| TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo()); | |
| if (!TSInfo) | |
| return StmtError(); | |
| } | |
| QualType T; | |
| if (TSInfo) | |
| T = TSInfo->getType(); | |
| else { | |
| T = getDerived().TransformType(FromVar->getType()); | |
| if (T.isNull()) | |
| return StmtError(); | |
| } | |
| Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T); | |
| if (!Var) | |
| return StmtError(); | |
| } | |
| StmtResult Body = getDerived().TransformStmt(S->getCatchBody()); | |
| if (Body.isInvalid()) | |
| return StmtError(); | |
| return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(), | |
| S->getRParenLoc(), | |
| Var, Body.get()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { | |
| // Transform the body. | |
| StmtResult Body = getDerived().TransformStmt(S->getFinallyBody()); | |
| if (Body.isInvalid()) | |
| return StmtError(); | |
| // If nothing changed, just retain this statement. | |
| if (!getDerived().AlwaysRebuild() && | |
| Body.get() == S->getFinallyBody()) | |
| return S; | |
| // Build a new statement. | |
| return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(), | |
| Body.get()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { | |
| ExprResult Operand; | |
| if (S->getThrowExpr()) { | |
| Operand = getDerived().TransformExpr(S->getThrowExpr()); | |
| if (Operand.isInvalid()) | |
| return StmtError(); | |
| } | |
| if (!getDerived().AlwaysRebuild() && | |
| Operand.get() == S->getThrowExpr()) | |
| return S; | |
| return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformObjCAtSynchronizedStmt( | |
| ObjCAtSynchronizedStmt *S) { | |
| // Transform the object we are locking. | |
| ExprResult Object = getDerived().TransformExpr(S->getSynchExpr()); | |
| if (Object.isInvalid()) | |
| return StmtError(); | |
| Object = | |
| getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(), | |
| Object.get()); | |
| if (Object.isInvalid()) | |
| return StmtError(); | |
| // Transform the body. | |
| StmtResult Body = getDerived().TransformStmt(S->getSynchBody()); | |
| if (Body.isInvalid()) | |
| return StmtError(); | |
| // If nothing change, just retain the current statement. | |
| if (!getDerived().AlwaysRebuild() && | |
| Object.get() == S->getSynchExpr() && | |
| Body.get() == S->getSynchBody()) | |
| return S; | |
| // Build a new statement. | |
| return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(), | |
| Object.get(), Body.get()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt( | |
| ObjCAutoreleasePoolStmt *S) { | |
| // Transform the body. | |
| StmtResult Body = getDerived().TransformStmt(S->getSubStmt()); | |
| if (Body.isInvalid()) | |
| return StmtError(); | |
| // If nothing changed, just retain this statement. | |
| if (!getDerived().AlwaysRebuild() && | |
| Body.get() == S->getSubStmt()) | |
| return S; | |
| // Build a new statement. | |
| return getDerived().RebuildObjCAutoreleasePoolStmt( | |
| S->getAtLoc(), Body.get()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformObjCForCollectionStmt( | |
| ObjCForCollectionStmt *S) { | |
| // Transform the element statement. | |
| StmtResult Element = getDerived().TransformStmt( | |
| S->getElement(), StmtDiscardKind::NotDiscarded); | |
| if (Element.isInvalid()) | |
| return StmtError(); | |
| // Transform the collection expression. | |
| ExprResult Collection = getDerived().TransformExpr(S->getCollection()); | |
| if (Collection.isInvalid()) | |
| return StmtError(); | |
| // Transform the body. | |
| StmtResult Body = getDerived().TransformStmt(S->getBody()); | |
| if (Body.isInvalid()) | |
| return StmtError(); | |
| // If nothing changed, just retain this statement. | |
| if (!getDerived().AlwaysRebuild() && | |
| Element.get() == S->getElement() && | |
| Collection.get() == S->getCollection() && | |
| Body.get() == S->getBody()) | |
| return S; | |
| // Build a new statement. | |
| return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(), | |
| Element.get(), | |
| Collection.get(), | |
| S->getRParenLoc(), | |
| Body.get()); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { | |
| // Transform the exception declaration, if any. | |
| VarDecl *Var = nullptr; | |
| if (VarDecl *ExceptionDecl = S->getExceptionDecl()) { | |
| TypeSourceInfo *T = | |
| getDerived().TransformType(ExceptionDecl->getTypeSourceInfo()); | |
| if (!T) | |
| return StmtError(); | |
| Var = getDerived().RebuildExceptionDecl( | |
| ExceptionDecl, T, ExceptionDecl->getInnerLocStart(), | |
| ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier()); | |
| if (!Var || Var->isInvalidDecl()) | |
| return StmtError(); | |
| } | |
| // Transform the actual exception handler. | |
| StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock()); | |
| if (Handler.isInvalid()) | |
| return StmtError(); | |
| if (!getDerived().AlwaysRebuild() && !Var && | |
| Handler.get() == S->getHandlerBlock()) | |
| return S; | |
| return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get()); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) { | |
| // Transform the try block itself. | |
| StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock()); | |
| if (TryBlock.isInvalid()) | |
| return StmtError(); | |
| // Transform the handlers. | |
| bool HandlerChanged = false; | |
| SmallVector<Stmt *, 8> Handlers; | |
| for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) { | |
| StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(I)); | |
| if (Handler.isInvalid()) | |
| return StmtError(); | |
| HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); | |
| Handlers.push_back(Handler.getAs<Stmt>()); | |
| } | |
| getSema().DiagnoseExceptionUse(S->getTryLoc(), /* IsTry= */ true); | |
| if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() && | |
| !HandlerChanged) | |
| return S; | |
| return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(), | |
| Handlers); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) { | |
| EnterExpressionEvaluationContext ForRangeInitContext( | |
| getSema(), Sema::ExpressionEvaluationContext::PotentiallyEvaluated, | |
| /*LambdaContextDecl=*/nullptr, | |
| Sema::ExpressionEvaluationContextRecord::EK_Other, | |
| getSema().getLangOpts().CPlusPlus23); | |
| // P2718R0 - Lifetime extension in range-based for loops. | |
| if (getSema().getLangOpts().CPlusPlus23) { | |
| auto &LastRecord = getSema().currentEvaluationContext(); | |
| LastRecord.InLifetimeExtendingContext = true; | |
| LastRecord.RebuildDefaultArgOrDefaultInit = true; | |
| } | |
| StmtResult Init = | |
| S->getInit() ? getDerived().TransformStmt(S->getInit()) : StmtResult(); | |
| if (Init.isInvalid()) | |
| return StmtError(); | |
| StmtResult Range = getDerived().TransformStmt(S->getRangeStmt()); | |
| if (Range.isInvalid()) | |
| return StmtError(); | |
| // Before c++23, ForRangeLifetimeExtendTemps should be empty. | |
| assert(getSema().getLangOpts().CPlusPlus23 || | |
| getSema().ExprEvalContexts.back().ForRangeLifetimeExtendTemps.empty()); | |
| auto ForRangeLifetimeExtendTemps = | |
| getSema().ExprEvalContexts.back().ForRangeLifetimeExtendTemps; | |
| StmtResult Begin = getDerived().TransformStmt(S->getBeginStmt()); | |
| if (Begin.isInvalid()) | |
| return StmtError(); | |
| StmtResult End = getDerived().TransformStmt(S->getEndStmt()); | |
| if (End.isInvalid()) | |
| return StmtError(); | |
| ExprResult Cond = getDerived().TransformExpr(S->getCond()); | |
| if (Cond.isInvalid()) | |
| return StmtError(); | |
| if (Cond.get()) | |
| Cond = SemaRef.CheckBooleanCondition(S->getColonLoc(), Cond.get()); | |
| if (Cond.isInvalid()) | |
| return StmtError(); | |
| if (Cond.get()) | |
| Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.get()); | |
| ExprResult Inc = getDerived().TransformExpr(S->getInc()); | |
| if (Inc.isInvalid()) | |
| return StmtError(); | |
| if (Inc.get()) | |
| Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.get()); | |
| StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt()); | |
| if (LoopVar.isInvalid()) | |
| return StmtError(); | |
| StmtResult NewStmt = S; | |
| if (getDerived().AlwaysRebuild() || | |
| Init.get() != S->getInit() || | |
| Range.get() != S->getRangeStmt() || | |
| Begin.get() != S->getBeginStmt() || | |
| End.get() != S->getEndStmt() || | |
| Cond.get() != S->getCond() || | |
| Inc.get() != S->getInc() || | |
| LoopVar.get() != S->getLoopVarStmt()) { | |
| NewStmt = getDerived().RebuildCXXForRangeStmt( | |
| S->getForLoc(), S->getCoawaitLoc(), Init.get(), S->getColonLoc(), | |
| Range.get(), Begin.get(), End.get(), Cond.get(), Inc.get(), | |
| LoopVar.get(), S->getRParenLoc(), ForRangeLifetimeExtendTemps); | |
| if (NewStmt.isInvalid() && LoopVar.get() != S->getLoopVarStmt()) { | |
| // Might not have attached any initializer to the loop variable. | |
| getSema().ActOnInitializerError( | |
| cast<DeclStmt>(LoopVar.get())->getSingleDecl()); | |
| return StmtError(); | |
| } | |
| } | |
| // OpenACC Restricts a while-loop inside of certain construct/clause | |
| // combinations, so diagnose that here in OpenACC mode. | |
| SemaOpenACC::LoopInConstructRAII LCR{SemaRef.OpenACC()}; | |
| SemaRef.OpenACC().ActOnRangeForStmtBegin(S->getBeginLoc(), S, NewStmt.get()); | |
| StmtResult Body = getDerived().TransformStmt(S->getBody()); | |
| if (Body.isInvalid()) | |
| return StmtError(); | |
| SemaRef.OpenACC().ActOnForStmtEnd(S->getBeginLoc(), Body); | |
| // Body has changed but we didn't rebuild the for-range statement. Rebuild | |
| // it now so we have a new statement to attach the body to. | |
| if (Body.get() != S->getBody() && NewStmt.get() == S) { | |
| NewStmt = getDerived().RebuildCXXForRangeStmt( | |
| S->getForLoc(), S->getCoawaitLoc(), Init.get(), S->getColonLoc(), | |
| Range.get(), Begin.get(), End.get(), Cond.get(), Inc.get(), | |
| LoopVar.get(), S->getRParenLoc(), ForRangeLifetimeExtendTemps); | |
| if (NewStmt.isInvalid()) | |
| return StmtError(); | |
| } | |
| if (NewStmt.get() == S) | |
| return S; | |
| return FinishCXXForRangeStmt(NewStmt.get(), Body.get()); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformCXXExpansionStmtPattern( | |
| CXXExpansionStmtPattern *S) { | |
| assert(SemaRef.CurContext->isExpansionStmt()); | |
| Decl *ESD = | |
| getDerived().TransformDecl(S->getDecl()->getLocation(), S->getDecl()); | |
| if (!ESD || ESD->isInvalidDecl()) | |
| return StmtError(); | |
| CXXExpansionStmtDecl *NewESD = cast<CXXExpansionStmtDecl>(ESD); | |
| // This is required because some parts of an expansion statement (e.g. the | |
| // init-statement) are not in a dependent context and must thus be transformed | |
| // in the parent context. | |
| auto TransformStmtInParentContext = [&](Stmt *SubStmt) -> StmtResult { | |
| Sema::ContextRAII CtxGuard(SemaRef, SemaRef.CurContext->getParent(), | |
| /*NewThis=*/false); | |
| return getDerived().TransformStmt(SubStmt); | |
| }; | |
| Stmt *Init = S->getInit(); | |
| if (Init) { | |
| StmtResult SR = TransformStmtInParentContext(Init); | |
| if (SR.isInvalid()) | |
| return StmtError(); | |
| Init = SR.get(); | |
| } | |
| // Collect lifetime-extended temporaries in case this ends up being a | |
| // destructuring or iterating expansion statement. | |
| // | |
| // CWG 3140: Additionally, for iterating expansions statements, we need to | |
| // apply lifetime extension to the initializer of the range. | |
| ExprResult ExpansionInitializer; | |
| StmtResult Range; | |
| SmallVector<MaterializeTemporaryExpr *, 8> LifetimeExtendTemps; | |
| if (S->isDependent() || S->isIterating()) { | |
| EnterExpressionEvaluationContext ExprEvalCtx( | |
| SemaRef, SemaRef.currentEvaluationContext().Context); | |
| SemaRef.currentEvaluationContext().InLifetimeExtendingContext = true; | |
| SemaRef.currentEvaluationContext().RebuildDefaultArgOrDefaultInit = true; | |
| if (S->isDependent()) { | |
| // The expansion initializer should not be in the context of the expansion | |
| // statement because it isn't instantiated when the expansion statement is | |
| // expanded. | |
| Sema::ContextRAII CtxGuard(SemaRef, SemaRef.CurContext->getParent(), | |
| /*NewThis=*/false); | |
| ExpansionInitializer = | |
| getDerived().TransformExpr(S->getExpansionInitializer()); | |
| if (ExpansionInitializer.isInvalid()) | |
| return StmtError(); | |
| } else if (S->isIterating()) { | |
| Range = TransformStmtInParentContext(S->getRangeVarStmt()); | |
| if (Range.isInvalid()) | |
| return StmtError(); | |
| } | |
| ExpansionInitializer = | |
| SemaRef.MaybeCreateExprWithCleanups(ExpansionInitializer); | |
| LifetimeExtendTemps = | |
| SemaRef.currentEvaluationContext().ForRangeLifetimeExtendTemps; | |
| } | |
| CXXExpansionStmtPattern *NewPattern = nullptr; | |
| if (S->isEnumerating()) { | |
| StmtResult ExpansionVar = | |
| getDerived().TransformStmt(S->getExpansionVarStmt()); | |
| if (ExpansionVar.isInvalid()) | |
| return StmtError(); | |
| NewPattern = CXXExpansionStmtPattern::CreateEnumerating( | |
| SemaRef.Context, NewESD, Init, ExpansionVar.getAs<DeclStmt>(), | |
| S->getLParenLoc(), S->getColonLoc(), S->getRParenLoc()); | |
| } else if (S->isIterating()) { | |
| StmtResult Begin = TransformStmtInParentContext(S->getBeginVarStmt()); | |
| StmtResult Iter = TransformStmtInParentContext(S->getIterVarStmt()); | |
| if (Begin.isInvalid() || Iter.isInvalid()) | |
| return StmtError(); | |
| // The expansion variable is part of the pattern only and never ends | |
| // up in the instantiations, so keep it in the expansion statement's | |
| // DeclContext. | |
| StmtResult ExpansionVar = | |
| getDerived().TransformStmt(S->getExpansionVarStmt()); | |
| if (ExpansionVar.isInvalid()) | |
| return StmtError(); | |
| NewPattern = CXXExpansionStmtPattern::CreateIterating( | |
| SemaRef.Context, NewESD, Init, ExpansionVar.getAs<DeclStmt>(), | |
| Range.getAs<DeclStmt>(), Begin.getAs<DeclStmt>(), | |
| Iter.getAs<DeclStmt>(), S->getLParenLoc(), S->getColonLoc(), | |
| S->getRParenLoc()); | |
| SemaRef.ApplyForRangeOrExpansionStatementLifetimeExtension( | |
| NewPattern->getRangeVar(), LifetimeExtendTemps); | |
| } else if (S->isDependent()) { | |
| StmtResult ExpansionVar = | |
| getDerived().TransformStmt(S->getExpansionVarStmt()); | |
| if (ExpansionVar.isInvalid()) | |
| return StmtError(); | |
| StmtResult Res = SemaRef.BuildNonEnumeratingCXXExpansionStmtPattern( | |
| NewESD, Init, ExpansionVar.getAs<DeclStmt>(), | |
| ExpansionInitializer.get(), S->getLParenLoc(), S->getColonLoc(), | |
| S->getRParenLoc(), LifetimeExtendTemps); | |
| if (Res.isInvalid()) | |
| return StmtError(); | |
| NewPattern = cast<CXXExpansionStmtPattern>(Res.get()); | |
| } else { | |
| // The only time we instantiate an expansion statement is if its expansion | |
| // size is dependent (otherwise, we only instantiate the expansions and | |
| // leave the underlying CXXExpansionStmtPattern as-is). Since destructuring | |
| // expansion statements never have a dependent size, we should never get | |
| // here. | |
| llvm_unreachable("destructuring pattern should never be instantiated"); | |
| } | |
| StmtResult Body = getDerived().TransformStmt(S->getBody()); | |
| if (Body.isInvalid()) | |
| return StmtError(); | |
| return SemaRef.FinishCXXExpansionStmt(NewPattern, Body.get()); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformCXXExpansionStmtInstantiation( | |
| CXXExpansionStmtInstantiation *S) { | |
| bool SubStmtChanged = false; | |
| auto TransformStmts = [&](SmallVectorImpl<Stmt *> &NewStmts, | |
| ArrayRef<Stmt *> OldStmts) { | |
| for (Stmt *OldDS : OldStmts) { | |
| StmtResult NewDS = getDerived().TransformStmt(OldDS); | |
| if (NewDS.isInvalid()) | |
| return true; | |
| SubStmtChanged |= NewDS.get() != OldDS; | |
| NewStmts.push_back(NewDS.get()); | |
| } | |
| return false; | |
| }; | |
| Decl *ESD = | |
| getDerived().TransformDecl(S->getParent()->getLocation(), S->getParent()); | |
| if (!ESD || ESD->isInvalidDecl()) | |
| return StmtError(); | |
| CXXExpansionStmtDecl *NewESD = cast<CXXExpansionStmtDecl>(ESD); | |
| SmallVector<Stmt *> PreambleStmts; | |
| SmallVector<Stmt *> Instantiations; | |
| // Apply lifetime extension to the preamble statements if this was a | |
| // destructuring expansion statement. | |
| { | |
| EnterExpressionEvaluationContext ExprEvalCtx( | |
| SemaRef, SemaRef.currentEvaluationContext().Context); | |
| SemaRef.currentEvaluationContext().InLifetimeExtendingContext = true; | |
| SemaRef.currentEvaluationContext().RebuildDefaultArgOrDefaultInit = true; | |
| if (TransformStmts(PreambleStmts, S->getPreambleStmts())) | |
| return StmtError(); | |
| if (S->shouldApplyLifetimeExtensionToPreamble()) { | |
| auto *VD = | |
| cast<VarDecl>(cast<DeclStmt>(PreambleStmts.front())->getSingleDecl()); | |
| SemaRef.ApplyForRangeOrExpansionStatementLifetimeExtension( | |
| VD, SemaRef.currentEvaluationContext().ForRangeLifetimeExtendTemps); | |
| } | |
| } | |
| if (TransformStmts(Instantiations, S->getInstantiations())) | |
| return StmtError(); | |
| if (!getDerived().AlwaysRebuild() && !SubStmtChanged) | |
| return S; | |
| return CXXExpansionStmtInstantiation::Create( | |
| SemaRef.Context, NewESD, Instantiations, PreambleStmts, | |
| S->shouldApplyLifetimeExtensionToPreamble()); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformCXXExpansionSelectExpr( | |
| CXXExpansionSelectExpr *E) { | |
| ExprResult Range = getDerived().TransformExpr(E->getRangeExpr()); | |
| ExprResult Idx = getDerived().TransformExpr(E->getIndexExpr()); | |
| if (Range.isInvalid() || Idx.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && Range.get() == E->getRangeExpr() && | |
| Idx.get() == E->getIndexExpr()) | |
| return E; | |
| return SemaRef.BuildCXXExpansionSelectExpr(Range.getAs<InitListExpr>(), | |
| Idx.get()); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformMSDependentExistsStmt( | |
| MSDependentExistsStmt *S) { | |
| // Transform the nested-name-specifier, if any. | |
| NestedNameSpecifierLoc QualifierLoc; | |
| if (S->getQualifierLoc()) { | |
| QualifierLoc | |
| = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc()); | |
| if (!QualifierLoc) | |
| return StmtError(); | |
| } | |
| // Transform the declaration name. | |
| DeclarationNameInfo NameInfo = S->getNameInfo(); | |
| if (NameInfo.getName()) { | |
| NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); | |
| if (!NameInfo.getName()) | |
| return StmtError(); | |
| } | |
| // Check whether anything changed. | |
| if (!getDerived().AlwaysRebuild() && | |
| QualifierLoc == S->getQualifierLoc() && | |
| NameInfo.getName() == S->getNameInfo().getName()) | |
| return S; | |
| // Determine whether this name exists, if we can. | |
| CXXScopeSpec SS; | |
| SS.Adopt(QualifierLoc); | |
| bool Dependent = false; | |
| switch (getSema().CheckMicrosoftIfExistsSymbol(/*S=*/nullptr, SS, NameInfo)) { | |
| case IfExistsResult::Exists: | |
| if (S->isIfExists()) | |
| break; | |
| return new (getSema().Context) NullStmt(S->getKeywordLoc()); | |
| case IfExistsResult::DoesNotExist: | |
| if (S->isIfNotExists()) | |
| break; | |
| return new (getSema().Context) NullStmt(S->getKeywordLoc()); | |
| case IfExistsResult::Dependent: | |
| Dependent = true; | |
| break; | |
| case IfExistsResult::Error: | |
| return StmtError(); | |
| } | |
| // We need to continue with the instantiation, so do so now. | |
| StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt()); | |
| if (SubStmt.isInvalid()) | |
| return StmtError(); | |
| // If we have resolved the name, just transform to the substatement. | |
| if (!Dependent) | |
| return SubStmt; | |
| // The name is still dependent, so build a dependent expression again. | |
| return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(), | |
| S->isIfExists(), | |
| QualifierLoc, | |
| NameInfo, | |
| SubStmt.get()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *E) { | |
| NestedNameSpecifierLoc QualifierLoc; | |
| if (E->getQualifierLoc()) { | |
| QualifierLoc | |
| = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); | |
| if (!QualifierLoc) | |
| return ExprError(); | |
| } | |
| MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>( | |
| getDerived().TransformDecl(E->getMemberLoc(), E->getPropertyDecl())); | |
| if (!PD) | |
| return ExprError(); | |
| ExprResult Base = getDerived().TransformExpr(E->getBaseExpr()); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| return new (SemaRef.getASTContext()) | |
| MSPropertyRefExpr(Base.get(), PD, E->isArrow(), | |
| SemaRef.getASTContext().PseudoObjectTy, VK_LValue, | |
| QualifierLoc, E->getMemberLoc()); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformMSPropertySubscriptExpr( | |
| MSPropertySubscriptExpr *E) { | |
| auto BaseRes = getDerived().TransformExpr(E->getBase()); | |
| if (BaseRes.isInvalid()) | |
| return ExprError(); | |
| auto IdxRes = getDerived().TransformExpr(E->getIdx()); | |
| if (IdxRes.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| BaseRes.get() == E->getBase() && | |
| IdxRes.get() == E->getIdx()) | |
| return E; | |
| return getDerived().RebuildArraySubscriptExpr( | |
| BaseRes.get(), SourceLocation(), IdxRes.get(), E->getRBracketLoc()); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) { | |
| StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock()); | |
| if (TryBlock.isInvalid()) | |
| return StmtError(); | |
| StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler()); | |
| if (Handler.isInvalid()) | |
| return StmtError(); | |
| if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() && | |
| Handler.get() == S->getHandler()) | |
| return S; | |
| return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(), | |
| TryBlock.get(), Handler.get()); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) { | |
| StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock()); | |
| if (Block.isInvalid()) | |
| return StmtError(); | |
| return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.get()); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) { | |
| ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr()); | |
| if (FilterExpr.isInvalid()) | |
| return StmtError(); | |
| StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock()); | |
| if (Block.isInvalid()) | |
| return StmtError(); | |
| return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(), | |
| Block.get()); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformSEHHandler(Stmt *Handler) { | |
| if (isa<SEHFinallyStmt>(Handler)) | |
| return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler)); | |
| else | |
| return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler)); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformSEHLeaveStmt(SEHLeaveStmt *S) { | |
| return S; | |
| } | |
| //===----------------------------------------------------------------------===// | |
| // OpenMP directive transformation | |
| //===----------------------------------------------------------------------===// | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPCanonicalLoop(OMPCanonicalLoop *L) { | |
| // OMPCanonicalLoops are eliminated during transformation, since they will be | |
| // recomputed by semantic analysis of the associated OMPLoopBasedDirective | |
| // after transformation. | |
| return getDerived().TransformStmt(L->getLoopStmt()); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective( | |
| OMPExecutableDirective *D) { | |
| // Transform the clauses | |
| llvm::SmallVector<OMPClause *, 16> TClauses; | |
| ArrayRef<OMPClause *> Clauses = D->clauses(); | |
| TClauses.reserve(Clauses.size()); | |
| for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end(); | |
| I != E; ++I) { | |
| if (*I) { | |
| getDerived().getSema().OpenMP().StartOpenMPClause((*I)->getClauseKind()); | |
| OMPClause *Clause = getDerived().TransformOMPClause(*I); | |
| getDerived().getSema().OpenMP().EndOpenMPClause(); | |
| if (Clause) | |
| TClauses.push_back(Clause); | |
| } else { | |
| TClauses.push_back(nullptr); | |
| } | |
| } | |
| StmtResult AssociatedStmt; | |
| if (D->hasAssociatedStmt() && D->getAssociatedStmt()) { | |
| getDerived().getSema().OpenMP().ActOnOpenMPRegionStart( | |
| D->getDirectiveKind(), | |
| /*CurScope=*/nullptr); | |
| StmtResult Body; | |
| { | |
| Sema::CompoundScopeRAII CompoundScope(getSema()); | |
| Stmt *CS; | |
| if (D->getDirectiveKind() == OMPD_atomic || | |
| D->getDirectiveKind() == OMPD_critical || | |
| D->getDirectiveKind() == OMPD_section || | |
| D->getDirectiveKind() == OMPD_master) | |
| CS = D->getAssociatedStmt(); | |
| else | |
| CS = D->getRawStmt(); | |
| Body = getDerived().TransformStmt(CS); | |
| if (Body.isUsable() && isOpenMPLoopDirective(D->getDirectiveKind()) && | |
| getSema().getLangOpts().OpenMPIRBuilder) | |
| Body = getDerived().RebuildOMPCanonicalLoop(Body.get()); | |
| } | |
| AssociatedStmt = | |
| getDerived().getSema().OpenMP().ActOnOpenMPRegionEnd(Body, TClauses); | |
| if (AssociatedStmt.isInvalid()) { | |
| return StmtError(); | |
| } | |
| } | |
| if (TClauses.size() != Clauses.size()) { | |
| return StmtError(); | |
| } | |
| // Transform directive name for 'omp critical' directive. | |
| DeclarationNameInfo DirName; | |
| if (D->getDirectiveKind() == OMPD_critical) { | |
| DirName = cast<OMPCriticalDirective>(D)->getDirectiveName(); | |
| DirName = getDerived().TransformDeclarationNameInfo(DirName); | |
| } | |
| OpenMPDirectiveKind CancelRegion = OMPD_unknown; | |
| if (D->getDirectiveKind() == OMPD_cancellation_point) { | |
| CancelRegion = cast<OMPCancellationPointDirective>(D)->getCancelRegion(); | |
| } else if (D->getDirectiveKind() == OMPD_cancel) { | |
| CancelRegion = cast<OMPCancelDirective>(D)->getCancelRegion(); | |
| } | |
| return getDerived().RebuildOMPExecutableDirective( | |
| D->getDirectiveKind(), DirName, CancelRegion, TClauses, | |
| AssociatedStmt.get(), D->getBeginLoc(), D->getEndLoc()); | |
| } | |
| /// This is mostly the same as above, but allows 'informational' class | |
| /// directives when rebuilding the stmt. It still takes an | |
| /// OMPExecutableDirective-type argument because we're reusing that as the | |
| /// superclass for the 'assume' directive at present, instead of defining a | |
| /// mostly-identical OMPInformationalDirective parent class. | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPInformationalDirective( | |
| OMPExecutableDirective *D) { | |
| // Transform the clauses | |
| llvm::SmallVector<OMPClause *, 16> TClauses; | |
| ArrayRef<OMPClause *> Clauses = D->clauses(); | |
| TClauses.reserve(Clauses.size()); | |
| for (OMPClause *C : Clauses) { | |
| if (C) { | |
| getDerived().getSema().OpenMP().StartOpenMPClause(C->getClauseKind()); | |
| OMPClause *Clause = getDerived().TransformOMPClause(C); | |
| getDerived().getSema().OpenMP().EndOpenMPClause(); | |
| if (Clause) | |
| TClauses.push_back(Clause); | |
| } else { | |
| TClauses.push_back(nullptr); | |
| } | |
| } | |
| StmtResult AssociatedStmt; | |
| if (D->hasAssociatedStmt() && D->getAssociatedStmt()) { | |
| getDerived().getSema().OpenMP().ActOnOpenMPRegionStart( | |
| D->getDirectiveKind(), | |
| /*CurScope=*/nullptr); | |
| StmtResult Body; | |
| { | |
| Sema::CompoundScopeRAII CompoundScope(getSema()); | |
| assert(D->getDirectiveKind() == OMPD_assume && | |
| "Unexpected informational directive"); | |
| Stmt *CS = D->getAssociatedStmt(); | |
| Body = getDerived().TransformStmt(CS); | |
| } | |
| AssociatedStmt = | |
| getDerived().getSema().OpenMP().ActOnOpenMPRegionEnd(Body, TClauses); | |
| if (AssociatedStmt.isInvalid()) | |
| return StmtError(); | |
| } | |
| if (TClauses.size() != Clauses.size()) | |
| return StmtError(); | |
| DeclarationNameInfo DirName; | |
| return getDerived().RebuildOMPInformationalDirective( | |
| D->getDirectiveKind(), DirName, TClauses, AssociatedStmt.get(), | |
| D->getBeginLoc(), D->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPMetaDirective(OMPMetaDirective *D) { | |
| // TODO: Fix This | |
| llvm::omp::Version OMPVersion = | |
| getDerived().getSema().getLangOpts().getOpenMPVersion(); | |
| SemaRef.Diag(D->getBeginLoc(), diag::err_omp_instantiation_not_supported) | |
| << getOpenMPDirectiveName(D->getDirectiveKind(), OMPVersion); | |
| return StmtError(); | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_parallel, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_simd, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPTileDirective(OMPTileDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPStripeDirective(OMPStripeDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPUnrollDirective(OMPUnrollDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPReverseDirective(OMPReverseDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPInterchangeDirective( | |
| OMPInterchangeDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPSplitDirective(OMPSplitDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPFlattenDirective(OMPFlattenDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPFuseDirective(OMPFuseDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPForDirective(OMPForDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_for, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPForSimdDirective(OMPForSimdDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_for_simd, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_sections, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_section, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPScopeDirective(OMPScopeDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_scope, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_single, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPMasterDirective(OMPMasterDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_master, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPCriticalDirective(OMPCriticalDirective *D) { | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_critical, D->getDirectiveName(), nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective( | |
| OMPParallelForDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_parallel_for, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPParallelForSimdDirective( | |
| OMPParallelForSimdDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_parallel_for_simd, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPParallelMasterDirective( | |
| OMPParallelMasterDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_parallel_master, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPParallelMaskedDirective( | |
| OMPParallelMaskedDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_parallel_masked, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective( | |
| OMPParallelSectionsDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_parallel_sections, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_task, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTaskyieldDirective( | |
| OMPTaskyieldDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_taskyield, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_barrier, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_taskwait, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPAssumeDirective(OMPAssumeDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_assume, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPInformationalDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPErrorDirective(OMPErrorDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_error, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective( | |
| OMPTaskgroupDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_taskgroup, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_flush, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPDepobjDirective(OMPDepobjDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_depobj, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPScanDirective(OMPScanDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_scan, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPOrderedStandaloneDirective( | |
| OMPOrderedStandaloneDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_ordered_standalone, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPOrderedBlockAssocDirective( | |
| OMPOrderedBlockAssocDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_ordered_blockassoc, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPAtomicDirective(OMPAtomicDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_atomic, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPTargetDirective(OMPTargetDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_target, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTargetDataDirective( | |
| OMPTargetDataDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_target_data, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTargetEnterDataDirective( | |
| OMPTargetEnterDataDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_target_enter_data, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTargetExitDataDirective( | |
| OMPTargetExitDataDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_target_exit_data, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTargetParallelDirective( | |
| OMPTargetParallelDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_target_parallel, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForDirective( | |
| OMPTargetParallelForDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_target_parallel_for, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTargetUpdateDirective( | |
| OMPTargetUpdateDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_target_update, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPTeamsDirective(OMPTeamsDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_teams, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPCancellationPointDirective( | |
| OMPCancellationPointDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_cancellation_point, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPCancelDirective(OMPCancelDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_cancel, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPTaskLoopDirective(OMPTaskLoopDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_taskloop, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTaskLoopSimdDirective( | |
| OMPTaskLoopSimdDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_taskloop_simd, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopDirective( | |
| OMPMasterTaskLoopDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_master_taskloop, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPMaskedTaskLoopDirective( | |
| OMPMaskedTaskLoopDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_masked_taskloop, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopSimdDirective( | |
| OMPMasterTaskLoopSimdDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_master_taskloop_simd, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPMaskedTaskLoopSimdDirective( | |
| OMPMaskedTaskLoopSimdDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_masked_taskloop_simd, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopDirective( | |
| OMPParallelMasterTaskLoopDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_parallel_master_taskloop, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPParallelMaskedTaskLoopDirective( | |
| OMPParallelMaskedTaskLoopDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_parallel_masked_taskloop, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopSimdDirective( | |
| OMPParallelMasterTaskLoopSimdDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_parallel_master_taskloop_simd, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPParallelMaskedTaskLoopSimdDirective( | |
| OMPParallelMaskedTaskLoopSimdDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_parallel_masked_taskloop_simd, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPDistributeDirective( | |
| OMPDistributeDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_distribute, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPDistributeParallelForDirective( | |
| OMPDistributeParallelForDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_distribute_parallel_for, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPDistributeParallelForSimdDirective( | |
| OMPDistributeParallelForSimdDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_distribute_parallel_for_simd, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPDistributeSimdDirective( | |
| OMPDistributeSimdDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_distribute_simd, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForSimdDirective( | |
| OMPTargetParallelForSimdDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_target_parallel_for_simd, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTargetSimdDirective( | |
| OMPTargetSimdDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_target_simd, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeDirective( | |
| OMPTeamsDistributeDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_teams_distribute, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeSimdDirective( | |
| OMPTeamsDistributeSimdDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_teams_distribute_simd, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForSimdDirective( | |
| OMPTeamsDistributeParallelForSimdDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_teams_distribute_parallel_for_simd, DirName, nullptr, | |
| D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForDirective( | |
| OMPTeamsDistributeParallelForDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_teams_distribute_parallel_for, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDirective( | |
| OMPTargetTeamsDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_target_teams, DirName, nullptr, D->getBeginLoc()); | |
| auto Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDistributeDirective( | |
| OMPTargetTeamsDistributeDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_target_teams_distribute, DirName, nullptr, D->getBeginLoc()); | |
| auto Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPTargetTeamsDistributeParallelForDirective( | |
| OMPTargetTeamsDistributeParallelForDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_target_teams_distribute_parallel_for, DirName, nullptr, | |
| D->getBeginLoc()); | |
| auto Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>:: | |
| TransformOMPTargetTeamsDistributeParallelForSimdDirective( | |
| OMPTargetTeamsDistributeParallelForSimdDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_target_teams_distribute_parallel_for_simd, DirName, nullptr, | |
| D->getBeginLoc()); | |
| auto Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPTargetTeamsDistributeSimdDirective( | |
| OMPTargetTeamsDistributeSimdDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_target_teams_distribute_simd, DirName, nullptr, D->getBeginLoc()); | |
| auto Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPInteropDirective(OMPInteropDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_interop, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPDispatchDirective(OMPDispatchDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_dispatch, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPMaskedDirective(OMPMaskedDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_masked, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPGenericLoopDirective( | |
| OMPGenericLoopDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_loop, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTeamsGenericLoopDirective( | |
| OMPTeamsGenericLoopDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_teams_loop, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsGenericLoopDirective( | |
| OMPTargetTeamsGenericLoopDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_target_teams_loop, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOMPParallelGenericLoopDirective( | |
| OMPParallelGenericLoopDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_parallel_loop, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOMPTargetParallelGenericLoopDirective( | |
| OMPTargetParallelGenericLoopDirective *D) { | |
| DeclarationNameInfo DirName; | |
| getDerived().getSema().OpenMP().StartOpenMPDSABlock( | |
| OMPD_target_parallel_loop, DirName, nullptr, D->getBeginLoc()); | |
| StmtResult Res = getDerived().TransformOMPExecutableDirective(D); | |
| getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get()); | |
| return Res; | |
| } | |
| //===----------------------------------------------------------------------===// | |
| // OpenMP clause transformation | |
| //===----------------------------------------------------------------------===// | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *C) { | |
| ExprResult Cond = getDerived().TransformExpr(C->getCondition()); | |
| if (Cond.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPIfClause( | |
| C->getNameModifier(), Cond.get(), C->getBeginLoc(), C->getLParenLoc(), | |
| C->getNameModifierLoc(), C->getColonLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *C) { | |
| ExprResult Cond = getDerived().TransformExpr(C->getCondition()); | |
| if (Cond.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPFinalClause(Cond.get(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *C) { | |
| llvm::SmallVector<Expr *, 3> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| Expr *DimsModifierExpr = C->getDimsModifierExpr(); | |
| if (DimsModifierExpr) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(DimsModifierExpr)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| DimsModifierExpr = EVar.get(); | |
| } | |
| return getDerived().RebuildOMPNumThreadsClause( | |
| Vars, C->getPrescriptivenessModifier(), | |
| C->getPrescriptivenessModifierLoc(), C->getDimsModifier(), | |
| DimsModifierExpr, C->getDimsModifierLoc(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *C) { | |
| ExprResult E = getDerived().TransformExpr(C->getSafelen()); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPSafelenClause( | |
| E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPAllocatorClause(OMPAllocatorClause *C) { | |
| ExprResult E = getDerived().TransformExpr(C->getAllocator()); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPAllocatorClause( | |
| E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPSimdlenClause(OMPSimdlenClause *C) { | |
| ExprResult E = getDerived().TransformExpr(C->getSimdlen()); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPSimdlenClause( | |
| E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPSizesClause(OMPSizesClause *C) { | |
| SmallVector<Expr *, 4> TransformedSizes; | |
| TransformedSizes.reserve(C->getNumSizes()); | |
| bool Changed = false; | |
| for (Expr *E : C->getSizesRefs()) { | |
| if (!E) { | |
| TransformedSizes.push_back(nullptr); | |
| continue; | |
| } | |
| ExprResult T = getDerived().TransformExpr(E); | |
| if (T.isInvalid()) | |
| return nullptr; | |
| if (E != T.get()) | |
| Changed = true; | |
| TransformedSizes.push_back(T.get()); | |
| } | |
| if (!Changed && !getDerived().AlwaysRebuild()) | |
| return C; | |
| return RebuildOMPSizesClause(TransformedSizes, C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPCountsClause(OMPCountsClause *C) { | |
| SmallVector<Expr *, 4> TransformedCounts; | |
| TransformedCounts.reserve(C->getNumCounts()); | |
| for (Expr *E : C->getCountsRefs()) { | |
| if (!E) { | |
| TransformedCounts.push_back(nullptr); | |
| continue; | |
| } | |
| ExprResult T = getDerived().TransformExpr(E); | |
| if (T.isInvalid()) | |
| return nullptr; | |
| TransformedCounts.push_back(T.get()); | |
| } | |
| return RebuildOMPCountsClause(TransformedCounts, C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc(), | |
| C->getOmpFillIndex(), C->getOmpFillLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPPermutationClause(OMPPermutationClause *C) { | |
| SmallVector<Expr *> TransformedArgs; | |
| TransformedArgs.reserve(C->getNumLoops()); | |
| bool Changed = false; | |
| for (Expr *E : C->getArgsRefs()) { | |
| if (!E) { | |
| TransformedArgs.push_back(nullptr); | |
| continue; | |
| } | |
| ExprResult T = getDerived().TransformExpr(E); | |
| if (T.isInvalid()) | |
| return nullptr; | |
| if (E != T.get()) | |
| Changed = true; | |
| TransformedArgs.push_back(T.get()); | |
| } | |
| if (!Changed && !getDerived().AlwaysRebuild()) | |
| return C; | |
| return RebuildOMPPermutationClause(TransformedArgs, C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPFullClause(OMPFullClause *C) { | |
| if (!getDerived().AlwaysRebuild()) | |
| return C; | |
| return RebuildOMPFullClause(C->getBeginLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPPartialClause(OMPPartialClause *C) { | |
| ExprResult T = getDerived().TransformExpr(C->getFactor()); | |
| if (T.isInvalid()) | |
| return nullptr; | |
| Expr *Factor = T.get(); | |
| bool Changed = Factor != C->getFactor(); | |
| if (!Changed && !getDerived().AlwaysRebuild()) | |
| return C; | |
| return RebuildOMPPartialClause(Factor, C->getBeginLoc(), C->getLParenLoc(), | |
| C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPDepthClause(OMPDepthClause *C) { | |
| ExprResult T = getDerived().TransformExpr(C->getDepth()); | |
| if (T.isInvalid()) | |
| return nullptr; | |
| Expr *Depth = T.get(); | |
| bool Changed = Depth != C->getDepth(); | |
| if (!Changed && !getDerived().AlwaysRebuild()) | |
| return C; | |
| return RebuildOMPDepthClause(Depth, C->getBeginLoc(), C->getLParenLoc(), | |
| C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPLoopRangeClause(OMPLoopRangeClause *C) { | |
| ExprResult F = getDerived().TransformExpr(C->getFirst()); | |
| if (F.isInvalid()) | |
| return nullptr; | |
| ExprResult Cn = getDerived().TransformExpr(C->getCount()); | |
| if (Cn.isInvalid()) | |
| return nullptr; | |
| Expr *First = F.get(); | |
| Expr *Count = Cn.get(); | |
| bool Changed = (First != C->getFirst()) || (Count != C->getCount()); | |
| // If no changes and AlwaysRebuild() is false, return the original clause | |
| if (!Changed && !getDerived().AlwaysRebuild()) | |
| return C; | |
| return RebuildOMPLoopRangeClause(First, Count, C->getBeginLoc(), | |
| C->getLParenLoc(), C->getFirstLoc(), | |
| C->getCountLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) { | |
| ExprResult E = getDerived().TransformExpr(C->getNumForLoops()); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPCollapseClause( | |
| E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *C) { | |
| return getDerived().RebuildOMPDefaultClause( | |
| C->getDefaultKind(), C->getDefaultKindKwLoc(), C->getDefaultVC(), | |
| C->getDefaultVCLoc(), C->getBeginLoc(), C->getLParenLoc(), | |
| C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPThreadsetClause(OMPThreadsetClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPTransparentClause(OMPTransparentClause *C) { | |
| Expr *Impex = C->getImpexType(); | |
| ExprResult TransformedImpex = getDerived().TransformExpr(Impex); | |
| if (TransformedImpex.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPTransparentClause( | |
| TransformedImpex.get(), C->getBeginLoc(), C->getLParenLoc(), | |
| C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *C) { | |
| return getDerived().RebuildOMPProcBindClause( | |
| C->getProcBindKind(), C->getProcBindKindKwLoc(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPScheduleClause(OMPScheduleClause *C) { | |
| ExprResult E = getDerived().TransformExpr(C->getChunkSize()); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPScheduleClause( | |
| C->getFirstScheduleModifier(), C->getSecondScheduleModifier(), | |
| C->getScheduleKind(), E.get(), C->getBeginLoc(), C->getLParenLoc(), | |
| C->getFirstScheduleModifierLoc(), C->getSecondScheduleModifierLoc(), | |
| C->getScheduleKindLoc(), C->getCommaLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPOrderedClause(OMPOrderedClause *C) { | |
| ExprResult E; | |
| if (auto *Num = C->getNumForLoops()) { | |
| E = getDerived().TransformExpr(Num); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| } | |
| return getDerived().RebuildOMPOrderedClause(C->getBeginLoc(), C->getEndLoc(), | |
| C->getLParenLoc(), E.get()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPDetachClause(OMPDetachClause *C) { | |
| ExprResult E; | |
| if (Expr *Evt = C->getEventHandler()) { | |
| E = getDerived().TransformExpr(Evt); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| } | |
| return getDerived().RebuildOMPDetachClause(E.get(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPNowaitClause(OMPNowaitClause *C) { | |
| ExprResult Cond; | |
| if (auto *Condition = C->getCondition()) { | |
| Cond = getDerived().TransformExpr(Condition); | |
| if (Cond.isInvalid()) | |
| return nullptr; | |
| } | |
| return getDerived().RebuildOMPNowaitClause(Cond.get(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPUntiedClause(OMPUntiedClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPMergeableClause(OMPMergeableClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPReadClause(OMPReadClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPWriteClause(OMPWriteClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPUpdateClause(OMPUpdateClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPUpdateDependObjectsClause( | |
| OMPUpdateDependObjectsClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPCaptureClause(OMPCaptureClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPCompareClause(OMPCompareClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPFailClause(OMPFailClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPAbsentClause(OMPAbsentClause *C) { | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPHoldsClause(OMPHoldsClause *C) { | |
| ExprResult E = getDerived().TransformExpr(C->getExpr()); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPHoldsClause(E.get(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPContainsClause(OMPContainsClause *C) { | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPNoOpenMPClause(OMPNoOpenMPClause *C) { | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPNoOpenMPRoutinesClause( | |
| OMPNoOpenMPRoutinesClause *C) { | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPNoOpenMPConstructsClause( | |
| OMPNoOpenMPConstructsClause *C) { | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPNoParallelismClause( | |
| OMPNoParallelismClause *C) { | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPAcqRelClause(OMPAcqRelClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPAcquireClause(OMPAcquireClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPReleaseClause(OMPReleaseClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPRelaxedClause(OMPRelaxedClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPWeakClause(OMPWeakClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPThreadsClause(OMPThreadsClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPSIMDClause(OMPSIMDClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPNogroupClause(OMPNogroupClause *C) { | |
| // No need to rebuild this clause, no template-dependent parameters. | |
| return C; | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPInitClause(OMPInitClause *C) { | |
| ExprResult IVR = getDerived().TransformExpr(C->getInteropVar()); | |
| if (IVR.isInvalid()) | |
| return nullptr; | |
| OMPInteropInfo InteropInfo(C->getIsTarget(), C->getIsTargetSync()); | |
| for (OMPInitClause::PrefView P : C->prefs()) { | |
| Expr *NewFr = nullptr; | |
| if (P.Fr) { | |
| ExprResult ER = getDerived().TransformExpr(P.Fr); | |
| if (ER.isInvalid()) | |
| return nullptr; | |
| NewFr = ER.get(); | |
| } | |
| SmallVector<Expr *, 2> NewAttrs; | |
| NewAttrs.reserve(P.Attrs.size()); | |
| for (Expr *A : P.Attrs) { | |
| ExprResult ER = getDerived().TransformExpr(A); | |
| if (ER.isInvalid()) | |
| return nullptr; | |
| NewAttrs.push_back(ER.get()); | |
| } | |
| InteropInfo.Prefs.emplace_back(NewFr, std::move(NewAttrs)); | |
| } | |
| InteropInfo.HasPreferAttrs = C->hasPreferAttrs(); | |
| return getDerived().RebuildOMPInitClause(IVR.get(), InteropInfo, | |
| C->getBeginLoc(), C->getLParenLoc(), | |
| C->getVarLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPUseClause(OMPUseClause *C) { | |
| ExprResult ER = getDerived().TransformExpr(C->getInteropVar()); | |
| if (ER.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPUseClause(ER.get(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getVarLoc(), | |
| C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPDestroyClause(OMPDestroyClause *C) { | |
| ExprResult ER; | |
| if (Expr *IV = C->getInteropVar()) { | |
| ER = getDerived().TransformExpr(IV); | |
| if (ER.isInvalid()) | |
| return nullptr; | |
| } | |
| return getDerived().RebuildOMPDestroyClause(ER.get(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getVarLoc(), | |
| C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPNovariantsClause(OMPNovariantsClause *C) { | |
| ExprResult Cond = getDerived().TransformExpr(C->getCondition()); | |
| if (Cond.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPNovariantsClause( | |
| Cond.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPNocontextClause(OMPNocontextClause *C) { | |
| ExprResult Cond = getDerived().TransformExpr(C->getCondition()); | |
| if (Cond.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPNocontextClause( | |
| Cond.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPFilterClause(OMPFilterClause *C) { | |
| ExprResult ThreadID = getDerived().TransformExpr(C->getThreadID()); | |
| if (ThreadID.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPFilterClause(ThreadID.get(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPAlignClause(OMPAlignClause *C) { | |
| ExprResult E = getDerived().TransformExpr(C->getAlignment()); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPAlignClause(E.get(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPUnifiedAddressClause( | |
| OMPUnifiedAddressClause *C) { | |
| llvm_unreachable("unified_address clause cannot appear in dependent context"); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPUnifiedSharedMemoryClause( | |
| OMPUnifiedSharedMemoryClause *C) { | |
| llvm_unreachable( | |
| "unified_shared_memory clause cannot appear in dependent context"); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPReverseOffloadClause( | |
| OMPReverseOffloadClause *C) { | |
| llvm_unreachable("reverse_offload clause cannot appear in dependent context"); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPDynamicAllocatorsClause( | |
| OMPDynamicAllocatorsClause *C) { | |
| llvm_unreachable( | |
| "dynamic_allocators clause cannot appear in dependent context"); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPAtomicDefaultMemOrderClause( | |
| OMPAtomicDefaultMemOrderClause *C) { | |
| llvm_unreachable( | |
| "atomic_default_mem_order clause cannot appear in dependent context"); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPSelfMapsClause(OMPSelfMapsClause *C) { | |
| llvm_unreachable("self_maps clause cannot appear in dependent context"); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPAtClause(OMPAtClause *C) { | |
| return getDerived().RebuildOMPAtClause(C->getAtKind(), C->getAtKindKwLoc(), | |
| C->getBeginLoc(), C->getLParenLoc(), | |
| C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPSeverityClause(OMPSeverityClause *C) { | |
| return getDerived().RebuildOMPSeverityClause( | |
| C->getSeverityKind(), C->getSeverityKindKwLoc(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPMessageClause(OMPMessageClause *C) { | |
| ExprResult E = getDerived().TransformExpr(C->getMessageString()); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPMessageClause( | |
| E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| return getDerived().RebuildOMPPrivateClause( | |
| Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPFirstprivateClause( | |
| OMPFirstprivateClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| return getDerived().RebuildOMPFirstprivateClause( | |
| Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| return getDerived().RebuildOMPLastprivateClause( | |
| Vars, C->getKind(), C->getKindLoc(), C->getColonLoc(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| return getDerived().RebuildOMPSharedClause(Vars, C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPReductionClause(OMPReductionClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| CXXScopeSpec ReductionIdScopeSpec; | |
| ReductionIdScopeSpec.Adopt(C->getQualifierLoc()); | |
| DeclarationNameInfo NameInfo = C->getNameInfo(); | |
| if (NameInfo.getName()) { | |
| NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); | |
| if (!NameInfo.getName()) | |
| return nullptr; | |
| } | |
| // Build a list of all UDR decls with the same names ranged by the Scopes. | |
| // The Scope boundary is a duplication of the previous decl. | |
| llvm::SmallVector<Expr *, 16> UnresolvedReductions; | |
| for (auto *E : C->reduction_ops()) { | |
| // Transform all the decls. | |
| if (E) { | |
| auto *ULE = cast<UnresolvedLookupExpr>(E); | |
| UnresolvedSet<8> Decls; | |
| for (auto *D : ULE->decls()) { | |
| NamedDecl *InstD = | |
| cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D)); | |
| Decls.addDecl(InstD, InstD->getAccess()); | |
| } | |
| UnresolvedReductions.push_back(UnresolvedLookupExpr::Create( | |
| SemaRef.Context, /*NamingClass=*/nullptr, | |
| ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), NameInfo, | |
| /*ADL=*/true, Decls.begin(), Decls.end(), | |
| /*KnownDependent=*/false, /*KnownInstantiationDependent=*/false)); | |
| } else | |
| UnresolvedReductions.push_back(nullptr); | |
| } | |
| return getDerived().RebuildOMPReductionClause( | |
| Vars, C->getModifier(), C->getOriginalSharingModifier(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getModifierLoc(), C->getColonLoc(), C->getEndLoc(), | |
| ReductionIdScopeSpec, NameInfo, UnresolvedReductions); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPTaskReductionClause( | |
| OMPTaskReductionClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| CXXScopeSpec ReductionIdScopeSpec; | |
| ReductionIdScopeSpec.Adopt(C->getQualifierLoc()); | |
| DeclarationNameInfo NameInfo = C->getNameInfo(); | |
| if (NameInfo.getName()) { | |
| NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); | |
| if (!NameInfo.getName()) | |
| return nullptr; | |
| } | |
| // Build a list of all UDR decls with the same names ranged by the Scopes. | |
| // The Scope boundary is a duplication of the previous decl. | |
| llvm::SmallVector<Expr *, 16> UnresolvedReductions; | |
| for (auto *E : C->reduction_ops()) { | |
| // Transform all the decls. | |
| if (E) { | |
| auto *ULE = cast<UnresolvedLookupExpr>(E); | |
| UnresolvedSet<8> Decls; | |
| for (auto *D : ULE->decls()) { | |
| NamedDecl *InstD = | |
| cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D)); | |
| Decls.addDecl(InstD, InstD->getAccess()); | |
| } | |
| UnresolvedReductions.push_back(UnresolvedLookupExpr::Create( | |
| SemaRef.Context, /*NamingClass=*/nullptr, | |
| ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), NameInfo, | |
| /*ADL=*/true, Decls.begin(), Decls.end(), | |
| /*KnownDependent=*/false, /*KnownInstantiationDependent=*/false)); | |
| } else | |
| UnresolvedReductions.push_back(nullptr); | |
| } | |
| return getDerived().RebuildOMPTaskReductionClause( | |
| Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(), | |
| C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPInReductionClause(OMPInReductionClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| CXXScopeSpec ReductionIdScopeSpec; | |
| ReductionIdScopeSpec.Adopt(C->getQualifierLoc()); | |
| DeclarationNameInfo NameInfo = C->getNameInfo(); | |
| if (NameInfo.getName()) { | |
| NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); | |
| if (!NameInfo.getName()) | |
| return nullptr; | |
| } | |
| // Build a list of all UDR decls with the same names ranged by the Scopes. | |
| // The Scope boundary is a duplication of the previous decl. | |
| llvm::SmallVector<Expr *, 16> UnresolvedReductions; | |
| for (auto *E : C->reduction_ops()) { | |
| // Transform all the decls. | |
| if (E) { | |
| auto *ULE = cast<UnresolvedLookupExpr>(E); | |
| UnresolvedSet<8> Decls; | |
| for (auto *D : ULE->decls()) { | |
| NamedDecl *InstD = | |
| cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D)); | |
| Decls.addDecl(InstD, InstD->getAccess()); | |
| } | |
| UnresolvedReductions.push_back(UnresolvedLookupExpr::Create( | |
| SemaRef.Context, /*NamingClass=*/nullptr, | |
| ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), NameInfo, | |
| /*ADL=*/true, Decls.begin(), Decls.end(), | |
| /*KnownDependent=*/false, /*KnownInstantiationDependent=*/false)); | |
| } else | |
| UnresolvedReductions.push_back(nullptr); | |
| } | |
| return getDerived().RebuildOMPInReductionClause( | |
| Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(), | |
| C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPLinearClause(OMPLinearClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| ExprResult Step = getDerived().TransformExpr(C->getStep()); | |
| if (Step.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPLinearClause( | |
| Vars, Step.get(), C->getBeginLoc(), C->getLParenLoc(), C->getModifier(), | |
| C->getModifierLoc(), C->getColonLoc(), C->getStepModifierLoc(), | |
| C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPAlignedClause(OMPAlignedClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| ExprResult Alignment = getDerived().TransformExpr(C->getAlignment()); | |
| if (Alignment.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPAlignedClause( | |
| Vars, Alignment.get(), C->getBeginLoc(), C->getLParenLoc(), | |
| C->getColonLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPCopyinClause(OMPCopyinClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| return getDerived().RebuildOMPCopyinClause(Vars, C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPCopyprivateClause(OMPCopyprivateClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| return getDerived().RebuildOMPCopyprivateClause( | |
| Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPFlushClause(OMPFlushClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| return getDerived().RebuildOMPFlushClause(Vars, C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPDepobjClause(OMPDepobjClause *C) { | |
| ExprResult E = getDerived().TransformExpr(C->getDepobj()); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPDepobjClause(E.get(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPDependClause(OMPDependClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Expr *DepModifier = C->getModifier(); | |
| if (DepModifier) { | |
| ExprResult DepModRes = getDerived().TransformExpr(DepModifier); | |
| if (DepModRes.isInvalid()) | |
| return nullptr; | |
| DepModifier = DepModRes.get(); | |
| } | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| return getDerived().RebuildOMPDependClause( | |
| {C->getDependencyKind(), C->getDependencyLoc(), C->getColonLoc(), | |
| C->getOmpAllMemoryLoc()}, | |
| DepModifier, Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPDeviceClause(OMPDeviceClause *C) { | |
| ExprResult E = getDerived().TransformExpr(C->getDevice()); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPDeviceClause( | |
| C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(), | |
| C->getModifierLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived, class T> | |
| bool transformOMPMappableExprListClause( | |
| TreeTransform<Derived> &TT, OMPMappableExprListClause<T> *C, | |
| llvm::SmallVectorImpl<Expr *> &Vars, CXXScopeSpec &MapperIdScopeSpec, | |
| DeclarationNameInfo &MapperIdInfo, | |
| llvm::SmallVectorImpl<Expr *> &UnresolvedMappers) { | |
| // Transform expressions in the list. | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = TT.getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return true; | |
| Vars.push_back(EVar.get()); | |
| } | |
| // Transform mapper scope specifier and identifier. | |
| NestedNameSpecifierLoc QualifierLoc; | |
| if (C->getMapperQualifierLoc()) { | |
| QualifierLoc = TT.getDerived().TransformNestedNameSpecifierLoc( | |
| C->getMapperQualifierLoc()); | |
| if (!QualifierLoc) | |
| return true; | |
| } | |
| MapperIdScopeSpec.Adopt(QualifierLoc); | |
| MapperIdInfo = C->getMapperIdInfo(); | |
| if (MapperIdInfo.getName()) { | |
| MapperIdInfo = TT.getDerived().TransformDeclarationNameInfo(MapperIdInfo); | |
| if (!MapperIdInfo.getName()) | |
| return true; | |
| } | |
| // Build a list of all candidate OMPDeclareMapperDecls, which is provided by | |
| // the previous user-defined mapper lookup in dependent environment. | |
| for (auto *E : C->mapperlists()) { | |
| // Transform all the decls. | |
| if (E) { | |
| auto *ULE = cast<UnresolvedLookupExpr>(E); | |
| UnresolvedSet<8> Decls; | |
| for (auto *D : ULE->decls()) { | |
| NamedDecl *InstD = | |
| cast<NamedDecl>(TT.getDerived().TransformDecl(E->getExprLoc(), D)); | |
| Decls.addDecl(InstD, InstD->getAccess()); | |
| } | |
| UnresolvedMappers.push_back(UnresolvedLookupExpr::Create( | |
| TT.getSema().Context, /*NamingClass=*/nullptr, | |
| MapperIdScopeSpec.getWithLocInContext(TT.getSema().Context), | |
| MapperIdInfo, /*ADL=*/true, Decls.begin(), Decls.end(), | |
| /*KnownDependent=*/false, /*KnownInstantiationDependent=*/false)); | |
| } else { | |
| UnresolvedMappers.push_back(nullptr); | |
| } | |
| } | |
| return false; | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPMapClause(OMPMapClause *C) { | |
| OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Expr *IteratorModifier = C->getIteratorModifier(); | |
| if (IteratorModifier) { | |
| ExprResult MapModRes = getDerived().TransformExpr(IteratorModifier); | |
| if (MapModRes.isInvalid()) | |
| return nullptr; | |
| IteratorModifier = MapModRes.get(); | |
| } | |
| CXXScopeSpec MapperIdScopeSpec; | |
| DeclarationNameInfo MapperIdInfo; | |
| llvm::SmallVector<Expr *, 16> UnresolvedMappers; | |
| if (transformOMPMappableExprListClause<Derived, OMPMapClause>( | |
| *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers)) | |
| return nullptr; | |
| return getDerived().RebuildOMPMapClause( | |
| IteratorModifier, C->getMapTypeModifiers(), C->getMapTypeModifiersLoc(), | |
| MapperIdScopeSpec, MapperIdInfo, C->getMapType(), C->isImplicitMapType(), | |
| C->getMapLoc(), C->getColonLoc(), Vars, Locs, UnresolvedMappers); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPAllocateClause(OMPAllocateClause *C) { | |
| Expr *Allocator = C->getAllocator(); | |
| if (Allocator) { | |
| ExprResult AllocatorRes = getDerived().TransformExpr(Allocator); | |
| if (AllocatorRes.isInvalid()) | |
| return nullptr; | |
| Allocator = AllocatorRes.get(); | |
| } | |
| Expr *Alignment = C->getAlignment(); | |
| if (Alignment) { | |
| ExprResult AlignmentRes = getDerived().TransformExpr(Alignment); | |
| if (AlignmentRes.isInvalid()) | |
| return nullptr; | |
| Alignment = AlignmentRes.get(); | |
| } | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| return getDerived().RebuildOMPAllocateClause( | |
| Allocator, Alignment, C->getFirstAllocateModifier(), | |
| C->getFirstAllocateModifierLoc(), C->getSecondAllocateModifier(), | |
| C->getSecondAllocateModifierLoc(), Vars, C->getBeginLoc(), | |
| C->getLParenLoc(), C->getColonLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPNumTeamsClause(OMPNumTeamsClause *C) { | |
| llvm::SmallVector<Expr *, 3> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| Expr *ModifierExpr = C->getModifierExpr(); | |
| if (ModifierExpr) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(ModifierExpr)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| ModifierExpr = EVar.get(); | |
| } | |
| return getDerived().RebuildOMPNumTeamsClause( | |
| Vars, C->getModifier(), ModifierExpr, C->getModifierLoc(), | |
| OMPC_NUMTEAMS_unknown, nullptr, SourceLocation(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPThreadLimitClause(OMPThreadLimitClause *C) { | |
| llvm::SmallVector<Expr *, 3> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| Expr *ModifierExpr = C->getModifierExpr(); | |
| if (ModifierExpr) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(ModifierExpr)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| ModifierExpr = EVar.get(); | |
| } | |
| return getDerived().RebuildOMPThreadLimitClause( | |
| Vars, C->getModifier(), ModifierExpr, C->getModifierLoc(), | |
| C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPPriorityClause(OMPPriorityClause *C) { | |
| ExprResult E = getDerived().TransformExpr(C->getPriority()); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPPriorityClause( | |
| E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPGrainsizeClause(OMPGrainsizeClause *C) { | |
| ExprResult E = getDerived().TransformExpr(C->getGrainsize()); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPGrainsizeClause( | |
| C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(), | |
| C->getModifierLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPNumTasksClause(OMPNumTasksClause *C) { | |
| ExprResult E = getDerived().TransformExpr(C->getNumTasks()); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPNumTasksClause( | |
| C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(), | |
| C->getModifierLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPHintClause(OMPHintClause *C) { | |
| ExprResult E = getDerived().TransformExpr(C->getHint()); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPHintClause(E.get(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPDistScheduleClause( | |
| OMPDistScheduleClause *C) { | |
| ExprResult E = getDerived().TransformExpr(C->getChunkSize()); | |
| if (E.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPDistScheduleClause( | |
| C->getDistScheduleKind(), E.get(), C->getBeginLoc(), C->getLParenLoc(), | |
| C->getDistScheduleKindLoc(), C->getCommaLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPDefaultmapClause(OMPDefaultmapClause *C) { | |
| // Rebuild Defaultmap Clause since we need to invoke the checking of | |
| // defaultmap(none:variable-category) after template initialization. | |
| return getDerived().RebuildOMPDefaultmapClause(C->getDefaultmapModifier(), | |
| C->getDefaultmapKind(), | |
| C->getBeginLoc(), | |
| C->getLParenLoc(), | |
| C->getDefaultmapModifierLoc(), | |
| C->getDefaultmapKindLoc(), | |
| C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPToClause(OMPToClause *C) { | |
| OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Expr *IteratorModifier = C->getIteratorModifier(); | |
| if (IteratorModifier) { | |
| ExprResult MapModRes = getDerived().TransformExpr(IteratorModifier); | |
| if (MapModRes.isInvalid()) | |
| return nullptr; | |
| IteratorModifier = MapModRes.get(); | |
| } | |
| CXXScopeSpec MapperIdScopeSpec; | |
| DeclarationNameInfo MapperIdInfo; | |
| llvm::SmallVector<Expr *, 16> UnresolvedMappers; | |
| if (transformOMPMappableExprListClause<Derived, OMPToClause>( | |
| *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers)) | |
| return nullptr; | |
| return getDerived().RebuildOMPToClause( | |
| C->getMotionModifiers(), C->getMotionModifiersLoc(), IteratorModifier, | |
| MapperIdScopeSpec, MapperIdInfo, C->getColonLoc(), Vars, Locs, | |
| UnresolvedMappers); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPFromClause(OMPFromClause *C) { | |
| OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Expr *IteratorModifier = C->getIteratorModifier(); | |
| if (IteratorModifier) { | |
| ExprResult MapModRes = getDerived().TransformExpr(IteratorModifier); | |
| if (MapModRes.isInvalid()) | |
| return nullptr; | |
| IteratorModifier = MapModRes.get(); | |
| } | |
| CXXScopeSpec MapperIdScopeSpec; | |
| DeclarationNameInfo MapperIdInfo; | |
| llvm::SmallVector<Expr *, 16> UnresolvedMappers; | |
| if (transformOMPMappableExprListClause<Derived, OMPFromClause>( | |
| *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers)) | |
| return nullptr; | |
| return getDerived().RebuildOMPFromClause( | |
| C->getMotionModifiers(), C->getMotionModifiersLoc(), IteratorModifier, | |
| MapperIdScopeSpec, MapperIdInfo, C->getColonLoc(), Vars, Locs, | |
| UnresolvedMappers); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPUseDevicePtrClause( | |
| OMPUseDevicePtrClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| return getDerived().RebuildOMPUseDevicePtrClause( | |
| Vars, Locs, C->getFallbackModifier(), C->getFallbackModifierLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPUseDeviceAddrClause( | |
| OMPUseDeviceAddrClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| return getDerived().RebuildOMPUseDeviceAddrClause(Vars, Locs); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| return getDerived().RebuildOMPIsDevicePtrClause(Vars, Locs); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPHasDeviceAddrClause( | |
| OMPHasDeviceAddrClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| return getDerived().RebuildOMPHasDeviceAddrClause(Vars, Locs); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPNontemporalClause(OMPNontemporalClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| return getDerived().RebuildOMPNontemporalClause( | |
| Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPInclusiveClause(OMPInclusiveClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| return getDerived().RebuildOMPInclusiveClause( | |
| Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPExclusiveClause(OMPExclusiveClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| return getDerived().RebuildOMPExclusiveClause( | |
| Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPUsesAllocatorsClause( | |
| OMPUsesAllocatorsClause *C) { | |
| SmallVector<SemaOpenMP::UsesAllocatorsData, 16> Data; | |
| Data.reserve(C->getNumberOfAllocators()); | |
| for (unsigned I = 0, E = C->getNumberOfAllocators(); I < E; ++I) { | |
| OMPUsesAllocatorsClause::Data D = C->getAllocatorData(I); | |
| ExprResult Allocator = getDerived().TransformExpr(D.Allocator); | |
| if (Allocator.isInvalid()) | |
| continue; | |
| ExprResult AllocatorTraits; | |
| if (Expr *AT = D.AllocatorTraits) { | |
| AllocatorTraits = getDerived().TransformExpr(AT); | |
| if (AllocatorTraits.isInvalid()) | |
| continue; | |
| } | |
| SemaOpenMP::UsesAllocatorsData &NewD = Data.emplace_back(); | |
| NewD.Allocator = Allocator.get(); | |
| NewD.AllocatorTraits = AllocatorTraits.get(); | |
| NewD.LParenLoc = D.LParenLoc; | |
| NewD.RParenLoc = D.RParenLoc; | |
| } | |
| return getDerived().RebuildOMPUsesAllocatorsClause( | |
| Data, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPAffinityClause(OMPAffinityClause *C) { | |
| SmallVector<Expr *, 4> Locators; | |
| Locators.reserve(C->varlist_size()); | |
| ExprResult ModifierRes; | |
| if (Expr *Modifier = C->getModifier()) { | |
| ModifierRes = getDerived().TransformExpr(Modifier); | |
| if (ModifierRes.isInvalid()) | |
| return nullptr; | |
| } | |
| for (Expr *E : C->varlist()) { | |
| ExprResult Locator = getDerived().TransformExpr(E); | |
| if (Locator.isInvalid()) | |
| continue; | |
| Locators.push_back(Locator.get()); | |
| } | |
| return getDerived().RebuildOMPAffinityClause( | |
| C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(), C->getEndLoc(), | |
| ModifierRes.get(), Locators); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPOrderClause(OMPOrderClause *C) { | |
| return getDerived().RebuildOMPOrderClause( | |
| C->getKind(), C->getKindKwLoc(), C->getBeginLoc(), C->getLParenLoc(), | |
| C->getEndLoc(), C->getModifier(), C->getModifierKwLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPBindClause(OMPBindClause *C) { | |
| return getDerived().RebuildOMPBindClause( | |
| C->getBindKind(), C->getBindKindLoc(), C->getBeginLoc(), | |
| C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPXDynCGroupMemClause( | |
| OMPXDynCGroupMemClause *C) { | |
| ExprResult Size = getDerived().TransformExpr(C->getSize()); | |
| if (Size.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPXDynCGroupMemClause( | |
| Size.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPDynGroupprivateClause( | |
| OMPDynGroupprivateClause *C) { | |
| ExprResult Size = getDerived().TransformExpr(C->getSize()); | |
| if (Size.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildOMPDynGroupprivateClause( | |
| C->getDynGroupprivateModifier(), C->getDynGroupprivateFallbackModifier(), | |
| Size.get(), C->getBeginLoc(), C->getLParenLoc(), | |
| C->getDynGroupprivateModifierLoc(), | |
| C->getDynGroupprivateFallbackModifierLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPDoacrossClause(OMPDoacrossClause *C) { | |
| llvm::SmallVector<Expr *, 16> Vars; | |
| Vars.reserve(C->varlist_size()); | |
| for (auto *VE : C->varlist()) { | |
| ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); | |
| if (EVar.isInvalid()) | |
| return nullptr; | |
| Vars.push_back(EVar.get()); | |
| } | |
| return getDerived().RebuildOMPDoacrossClause( | |
| C->getDependenceType(), C->getDependenceLoc(), C->getColonLoc(), Vars, | |
| C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause * | |
| TreeTransform<Derived>::TransformOMPXAttributeClause(OMPXAttributeClause *C) { | |
| SmallVector<const Attr *> NewAttrs; | |
| for (auto *A : C->getAttrs()) | |
| NewAttrs.push_back(getDerived().TransformAttr(A)); | |
| return getDerived().RebuildOMPXAttributeClause( | |
| NewAttrs, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| OMPClause *TreeTransform<Derived>::TransformOMPXBareClause(OMPXBareClause *C) { | |
| return getDerived().RebuildOMPXBareClause(C->getBeginLoc(), C->getEndLoc()); | |
| } | |
| //===----------------------------------------------------------------------===// | |
| // OpenACC transformation | |
| //===----------------------------------------------------------------------===// | |
| namespace { | |
| template <typename Derived> | |
| class OpenACCClauseTransform final | |
| : public OpenACCClauseVisitor<OpenACCClauseTransform<Derived>> { | |
| TreeTransform<Derived> &Self; | |
| ArrayRef<const OpenACCClause *> ExistingClauses; | |
| SemaOpenACC::OpenACCParsedClause &ParsedClause; | |
| OpenACCClause *NewClause = nullptr; | |
| ExprResult VisitVar(Expr *VarRef) { | |
| ExprResult Res = Self.TransformExpr(VarRef); | |
| if (!Res.isUsable()) | |
| return Res; | |
| Res = Self.getSema().OpenACC().ActOnVar(ParsedClause.getDirectiveKind(), | |
| ParsedClause.getClauseKind(), | |
| Res.get()); | |
| return Res; | |
| } | |
| llvm::SmallVector<Expr *> VisitVarList(ArrayRef<Expr *> VarList) { | |
| llvm::SmallVector<Expr *> InstantiatedVarList; | |
| for (Expr *CurVar : VarList) { | |
| ExprResult VarRef = VisitVar(CurVar); | |
| if (VarRef.isUsable()) | |
| InstantiatedVarList.push_back(VarRef.get()); | |
| } | |
| return InstantiatedVarList; | |
| } | |
| public: | |
| OpenACCClauseTransform(TreeTransform<Derived> &Self, | |
| ArrayRef<const OpenACCClause *> ExistingClauses, | |
| SemaOpenACC::OpenACCParsedClause &PC) | |
| : Self(Self), ExistingClauses(ExistingClauses), ParsedClause(PC) {} | |
| OpenACCClause *CreatedClause() const { return NewClause; } | |
| #define VISIT_CLAUSE(CLAUSE_NAME) \ | |
| void Visit##CLAUSE_NAME##Clause(const OpenACC##CLAUSE_NAME##Clause &Clause); | |
| #include "clang/Basic/OpenACCClauses.def" | |
| }; | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitDefaultClause( | |
| const OpenACCDefaultClause &C) { | |
| ParsedClause.setDefaultDetails(C.getDefaultClauseKind()); | |
| NewClause = OpenACCDefaultClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getDefaultClauseKind(), | |
| ParsedClause.getBeginLoc(), ParsedClause.getLParenLoc(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitIfClause(const OpenACCIfClause &C) { | |
| Expr *Cond = const_cast<Expr *>(C.getConditionExpr()); | |
| assert(Cond && "If constructed with invalid Condition"); | |
| Sema::ConditionResult Res = Self.TransformCondition( | |
| Cond->getExprLoc(), /*Var=*/nullptr, Cond, Sema::ConditionKind::Boolean); | |
| if (Res.isInvalid() || !Res.get().second) | |
| return; | |
| ParsedClause.setConditionDetails(Res.get().second); | |
| NewClause = OpenACCIfClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getConditionExpr(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitSelfClause( | |
| const OpenACCSelfClause &C) { | |
| // If this is an 'update' 'self' clause, this is actually a var list instead. | |
| if (ParsedClause.getDirectiveKind() == OpenACCDirectiveKind::Update) { | |
| llvm::SmallVector<Expr *> InstantiatedVarList; | |
| for (Expr *CurVar : C.getVarList()) { | |
| ExprResult Res = Self.TransformExpr(CurVar); | |
| if (!Res.isUsable()) | |
| continue; | |
| Res = Self.getSema().OpenACC().ActOnVar(ParsedClause.getDirectiveKind(), | |
| ParsedClause.getClauseKind(), | |
| Res.get()); | |
| if (Res.isUsable()) | |
| InstantiatedVarList.push_back(Res.get()); | |
| } | |
| ParsedClause.setVarListDetails(InstantiatedVarList, | |
| OpenACCModifierKind::Invalid); | |
| NewClause = OpenACCSelfClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getVarList(), | |
| ParsedClause.getEndLoc()); | |
| } else { | |
| if (C.hasConditionExpr()) { | |
| Expr *Cond = const_cast<Expr *>(C.getConditionExpr()); | |
| Sema::ConditionResult Res = | |
| Self.TransformCondition(Cond->getExprLoc(), /*Var=*/nullptr, Cond, | |
| Sema::ConditionKind::Boolean); | |
| if (Res.isInvalid() || !Res.get().second) | |
| return; | |
| ParsedClause.setConditionDetails(Res.get().second); | |
| } | |
| NewClause = OpenACCSelfClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getConditionExpr(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitNumGangsClause( | |
| const OpenACCNumGangsClause &C) { | |
| llvm::SmallVector<Expr *> InstantiatedIntExprs; | |
| for (Expr *CurIntExpr : C.getIntExprs()) { | |
| ExprResult Res = Self.TransformExpr(CurIntExpr); | |
| if (!Res.isUsable()) | |
| return; | |
| Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid, | |
| C.getClauseKind(), | |
| C.getBeginLoc(), Res.get()); | |
| if (!Res.isUsable()) | |
| return; | |
| InstantiatedIntExprs.push_back(Res.get()); | |
| } | |
| ParsedClause.setIntExprDetails(InstantiatedIntExprs); | |
| NewClause = OpenACCNumGangsClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getIntExprs(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitPrivateClause( | |
| const OpenACCPrivateClause &C) { | |
| llvm::SmallVector<Expr *> InstantiatedVarList; | |
| llvm::SmallVector<OpenACCPrivateRecipe> InitRecipes; | |
| for (const auto [RefExpr, InitRecipe] : | |
| llvm::zip(C.getVarList(), C.getInitRecipes())) { | |
| ExprResult VarRef = VisitVar(RefExpr); | |
| if (VarRef.isUsable()) { | |
| InstantiatedVarList.push_back(VarRef.get()); | |
| // We only have to create a new one if it is dependent, and Sema won't | |
| // make one of these unless the type is non-dependent. | |
| if (InitRecipe.isSet()) | |
| InitRecipes.push_back(InitRecipe); | |
| else | |
| InitRecipes.push_back( | |
| Self.getSema().OpenACC().CreatePrivateInitRecipe(VarRef.get())); | |
| } | |
| } | |
| ParsedClause.setVarListDetails(InstantiatedVarList, | |
| OpenACCModifierKind::Invalid); | |
| NewClause = OpenACCPrivateClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getVarList(), InitRecipes, | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitHostClause( | |
| const OpenACCHostClause &C) { | |
| ParsedClause.setVarListDetails(VisitVarList(C.getVarList()), | |
| OpenACCModifierKind::Invalid); | |
| NewClause = OpenACCHostClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getVarList(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitDeviceClause( | |
| const OpenACCDeviceClause &C) { | |
| ParsedClause.setVarListDetails(VisitVarList(C.getVarList()), | |
| OpenACCModifierKind::Invalid); | |
| NewClause = OpenACCDeviceClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getVarList(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitFirstPrivateClause( | |
| const OpenACCFirstPrivateClause &C) { | |
| llvm::SmallVector<Expr *> InstantiatedVarList; | |
| llvm::SmallVector<OpenACCFirstPrivateRecipe> InitRecipes; | |
| for (const auto [RefExpr, InitRecipe] : | |
| llvm::zip(C.getVarList(), C.getInitRecipes())) { | |
| ExprResult VarRef = VisitVar(RefExpr); | |
| if (VarRef.isUsable()) { | |
| InstantiatedVarList.push_back(VarRef.get()); | |
| // We only have to create a new one if it is dependent, and Sema won't | |
| // make one of these unless the type is non-dependent. | |
| if (InitRecipe.isSet()) | |
| InitRecipes.push_back(InitRecipe); | |
| else | |
| InitRecipes.push_back( | |
| Self.getSema().OpenACC().CreateFirstPrivateInitRecipe( | |
| VarRef.get())); | |
| } | |
| } | |
| ParsedClause.setVarListDetails(InstantiatedVarList, | |
| OpenACCModifierKind::Invalid); | |
| NewClause = OpenACCFirstPrivateClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getVarList(), InitRecipes, | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitNoCreateClause( | |
| const OpenACCNoCreateClause &C) { | |
| ParsedClause.setVarListDetails(VisitVarList(C.getVarList()), | |
| OpenACCModifierKind::Invalid); | |
| NewClause = OpenACCNoCreateClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getVarList(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitPresentClause( | |
| const OpenACCPresentClause &C) { | |
| ParsedClause.setVarListDetails(VisitVarList(C.getVarList()), | |
| OpenACCModifierKind::Invalid); | |
| NewClause = OpenACCPresentClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getVarList(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitCopyClause( | |
| const OpenACCCopyClause &C) { | |
| ParsedClause.setVarListDetails(VisitVarList(C.getVarList()), | |
| C.getModifierList()); | |
| NewClause = OpenACCCopyClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getClauseKind(), | |
| ParsedClause.getBeginLoc(), ParsedClause.getLParenLoc(), | |
| ParsedClause.getModifierList(), ParsedClause.getVarList(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitLinkClause( | |
| const OpenACCLinkClause &C) { | |
| llvm_unreachable("link clause not valid unless a decl transform"); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitDeviceResidentClause( | |
| const OpenACCDeviceResidentClause &C) { | |
| llvm_unreachable("device_resident clause not valid unless a decl transform"); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitNoHostClause( | |
| const OpenACCNoHostClause &C) { | |
| llvm_unreachable("nohost clause not valid unless a decl transform"); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitBindClause( | |
| const OpenACCBindClause &C) { | |
| llvm_unreachable("bind clause not valid unless a decl transform"); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitCopyInClause( | |
| const OpenACCCopyInClause &C) { | |
| ParsedClause.setVarListDetails(VisitVarList(C.getVarList()), | |
| C.getModifierList()); | |
| NewClause = OpenACCCopyInClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getClauseKind(), | |
| ParsedClause.getBeginLoc(), ParsedClause.getLParenLoc(), | |
| ParsedClause.getModifierList(), ParsedClause.getVarList(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitCopyOutClause( | |
| const OpenACCCopyOutClause &C) { | |
| ParsedClause.setVarListDetails(VisitVarList(C.getVarList()), | |
| C.getModifierList()); | |
| NewClause = OpenACCCopyOutClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getClauseKind(), | |
| ParsedClause.getBeginLoc(), ParsedClause.getLParenLoc(), | |
| ParsedClause.getModifierList(), ParsedClause.getVarList(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitCreateClause( | |
| const OpenACCCreateClause &C) { | |
| ParsedClause.setVarListDetails(VisitVarList(C.getVarList()), | |
| C.getModifierList()); | |
| NewClause = OpenACCCreateClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getClauseKind(), | |
| ParsedClause.getBeginLoc(), ParsedClause.getLParenLoc(), | |
| ParsedClause.getModifierList(), ParsedClause.getVarList(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitAttachClause( | |
| const OpenACCAttachClause &C) { | |
| llvm::SmallVector<Expr *> VarList = VisitVarList(C.getVarList()); | |
| // Ensure each var is a pointer type. | |
| llvm::erase_if(VarList, [&](Expr *E) { | |
| return Self.getSema().OpenACC().CheckVarIsPointerType( | |
| OpenACCClauseKind::Attach, E); | |
| }); | |
| ParsedClause.setVarListDetails(VarList, OpenACCModifierKind::Invalid); | |
| NewClause = OpenACCAttachClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getVarList(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitDetachClause( | |
| const OpenACCDetachClause &C) { | |
| llvm::SmallVector<Expr *> VarList = VisitVarList(C.getVarList()); | |
| // Ensure each var is a pointer type. | |
| llvm::erase_if(VarList, [&](Expr *E) { | |
| return Self.getSema().OpenACC().CheckVarIsPointerType( | |
| OpenACCClauseKind::Detach, E); | |
| }); | |
| ParsedClause.setVarListDetails(VarList, OpenACCModifierKind::Invalid); | |
| NewClause = OpenACCDetachClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getVarList(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitDeleteClause( | |
| const OpenACCDeleteClause &C) { | |
| ParsedClause.setVarListDetails(VisitVarList(C.getVarList()), | |
| OpenACCModifierKind::Invalid); | |
| NewClause = OpenACCDeleteClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getVarList(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitUseDeviceClause( | |
| const OpenACCUseDeviceClause &C) { | |
| ParsedClause.setVarListDetails(VisitVarList(C.getVarList()), | |
| OpenACCModifierKind::Invalid); | |
| NewClause = OpenACCUseDeviceClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getVarList(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitDevicePtrClause( | |
| const OpenACCDevicePtrClause &C) { | |
| llvm::SmallVector<Expr *> VarList = VisitVarList(C.getVarList()); | |
| // Ensure each var is a pointer type. | |
| llvm::erase_if(VarList, [&](Expr *E) { | |
| return Self.getSema().OpenACC().CheckVarIsPointerType( | |
| OpenACCClauseKind::DevicePtr, E); | |
| }); | |
| ParsedClause.setVarListDetails(VarList, OpenACCModifierKind::Invalid); | |
| NewClause = OpenACCDevicePtrClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getVarList(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitNumWorkersClause( | |
| const OpenACCNumWorkersClause &C) { | |
| Expr *IntExpr = const_cast<Expr *>(C.getIntExpr()); | |
| assert(IntExpr && "num_workers clause constructed with invalid int expr"); | |
| ExprResult Res = Self.TransformExpr(IntExpr); | |
| if (!Res.isUsable()) | |
| return; | |
| Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid, | |
| C.getClauseKind(), | |
| C.getBeginLoc(), Res.get()); | |
| if (!Res.isUsable()) | |
| return; | |
| ParsedClause.setIntExprDetails(Res.get()); | |
| NewClause = OpenACCNumWorkersClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getIntExprs()[0], | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitDeviceNumClause ( | |
| const OpenACCDeviceNumClause &C) { | |
| Expr *IntExpr = const_cast<Expr *>(C.getIntExpr()); | |
| assert(IntExpr && "device_num clause constructed with invalid int expr"); | |
| ExprResult Res = Self.TransformExpr(IntExpr); | |
| if (!Res.isUsable()) | |
| return; | |
| Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid, | |
| C.getClauseKind(), | |
| C.getBeginLoc(), Res.get()); | |
| if (!Res.isUsable()) | |
| return; | |
| ParsedClause.setIntExprDetails(Res.get()); | |
| NewClause = OpenACCDeviceNumClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getIntExprs()[0], | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitDefaultAsyncClause( | |
| const OpenACCDefaultAsyncClause &C) { | |
| Expr *IntExpr = const_cast<Expr *>(C.getIntExpr()); | |
| assert(IntExpr && "default_async clause constructed with invalid int expr"); | |
| ExprResult Res = Self.TransformExpr(IntExpr); | |
| if (!Res.isUsable()) | |
| return; | |
| Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid, | |
| C.getClauseKind(), | |
| C.getBeginLoc(), Res.get()); | |
| if (!Res.isUsable()) | |
| return; | |
| ParsedClause.setIntExprDetails(Res.get()); | |
| NewClause = OpenACCDefaultAsyncClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getIntExprs()[0], | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitVectorLengthClause( | |
| const OpenACCVectorLengthClause &C) { | |
| Expr *IntExpr = const_cast<Expr *>(C.getIntExpr()); | |
| assert(IntExpr && "vector_length clause constructed with invalid int expr"); | |
| ExprResult Res = Self.TransformExpr(IntExpr); | |
| if (!Res.isUsable()) | |
| return; | |
| Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid, | |
| C.getClauseKind(), | |
| C.getBeginLoc(), Res.get()); | |
| if (!Res.isUsable()) | |
| return; | |
| ParsedClause.setIntExprDetails(Res.get()); | |
| NewClause = OpenACCVectorLengthClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getIntExprs()[0], | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitAsyncClause( | |
| const OpenACCAsyncClause &C) { | |
| if (C.hasIntExpr()) { | |
| ExprResult Res = Self.TransformExpr(const_cast<Expr *>(C.getIntExpr())); | |
| if (!Res.isUsable()) | |
| return; | |
| Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid, | |
| C.getClauseKind(), | |
| C.getBeginLoc(), Res.get()); | |
| if (!Res.isUsable()) | |
| return; | |
| ParsedClause.setIntExprDetails(Res.get()); | |
| } | |
| NewClause = OpenACCAsyncClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), | |
| ParsedClause.getNumIntExprs() != 0 ? ParsedClause.getIntExprs()[0] | |
| : nullptr, | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitWorkerClause( | |
| const OpenACCWorkerClause &C) { | |
| if (C.hasIntExpr()) { | |
| // restrictions on this expression are all "does it exist in certain | |
| // situations" that are not possible to be dependent, so the only check we | |
| // have is that it transforms, and is an int expression. | |
| ExprResult Res = Self.TransformExpr(const_cast<Expr *>(C.getIntExpr())); | |
| if (!Res.isUsable()) | |
| return; | |
| Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid, | |
| C.getClauseKind(), | |
| C.getBeginLoc(), Res.get()); | |
| if (!Res.isUsable()) | |
| return; | |
| ParsedClause.setIntExprDetails(Res.get()); | |
| } | |
| NewClause = OpenACCWorkerClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), | |
| ParsedClause.getNumIntExprs() != 0 ? ParsedClause.getIntExprs()[0] | |
| : nullptr, | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitVectorClause( | |
| const OpenACCVectorClause &C) { | |
| if (C.hasIntExpr()) { | |
| // restrictions on this expression are all "does it exist in certain | |
| // situations" that are not possible to be dependent, so the only check we | |
| // have is that it transforms, and is an int expression. | |
| ExprResult Res = Self.TransformExpr(const_cast<Expr *>(C.getIntExpr())); | |
| if (!Res.isUsable()) | |
| return; | |
| Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid, | |
| C.getClauseKind(), | |
| C.getBeginLoc(), Res.get()); | |
| if (!Res.isUsable()) | |
| return; | |
| ParsedClause.setIntExprDetails(Res.get()); | |
| } | |
| NewClause = OpenACCVectorClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), | |
| ParsedClause.getNumIntExprs() != 0 ? ParsedClause.getIntExprs()[0] | |
| : nullptr, | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitWaitClause( | |
| const OpenACCWaitClause &C) { | |
| if (C.hasExprs()) { | |
| Expr *DevNumExpr = nullptr; | |
| llvm::SmallVector<Expr *> InstantiatedQueueIdExprs; | |
| // Instantiate devnum expr if it exists. | |
| if (C.getDevNumExpr()) { | |
| ExprResult Res = Self.TransformExpr(C.getDevNumExpr()); | |
| if (!Res.isUsable()) | |
| return; | |
| Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid, | |
| C.getClauseKind(), | |
| C.getBeginLoc(), Res.get()); | |
| if (!Res.isUsable()) | |
| return; | |
| DevNumExpr = Res.get(); | |
| } | |
| // Instantiate queue ids. | |
| for (Expr *CurQueueIdExpr : C.getQueueIdExprs()) { | |
| ExprResult Res = Self.TransformExpr(CurQueueIdExpr); | |
| if (!Res.isUsable()) | |
| return; | |
| Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid, | |
| C.getClauseKind(), | |
| C.getBeginLoc(), Res.get()); | |
| if (!Res.isUsable()) | |
| return; | |
| InstantiatedQueueIdExprs.push_back(Res.get()); | |
| } | |
| ParsedClause.setWaitDetails(DevNumExpr, C.getQueuesLoc(), | |
| std::move(InstantiatedQueueIdExprs)); | |
| } | |
| NewClause = OpenACCWaitClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getDevNumExpr(), | |
| ParsedClause.getQueuesLoc(), ParsedClause.getQueueIdExprs(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitDeviceTypeClause( | |
| const OpenACCDeviceTypeClause &C) { | |
| // Nothing to transform here, just create a new version of 'C'. | |
| NewClause = OpenACCDeviceTypeClause::Create( | |
| Self.getSema().getASTContext(), C.getClauseKind(), | |
| ParsedClause.getBeginLoc(), ParsedClause.getLParenLoc(), | |
| C.getArchitectures(), ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitAutoClause( | |
| const OpenACCAutoClause &C) { | |
| // Nothing to do, so just create a new node. | |
| NewClause = OpenACCAutoClause::Create(Self.getSema().getASTContext(), | |
| ParsedClause.getBeginLoc(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitIndependentClause( | |
| const OpenACCIndependentClause &C) { | |
| NewClause = OpenACCIndependentClause::Create(Self.getSema().getASTContext(), | |
| ParsedClause.getBeginLoc(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitSeqClause( | |
| const OpenACCSeqClause &C) { | |
| NewClause = OpenACCSeqClause::Create(Self.getSema().getASTContext(), | |
| ParsedClause.getBeginLoc(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitFinalizeClause( | |
| const OpenACCFinalizeClause &C) { | |
| NewClause = OpenACCFinalizeClause::Create(Self.getSema().getASTContext(), | |
| ParsedClause.getBeginLoc(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitIfPresentClause( | |
| const OpenACCIfPresentClause &C) { | |
| NewClause = OpenACCIfPresentClause::Create(Self.getSema().getASTContext(), | |
| ParsedClause.getBeginLoc(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitReductionClause( | |
| const OpenACCReductionClause &C) { | |
| SmallVector<Expr *> TransformedVars = VisitVarList(C.getVarList()); | |
| SmallVector<Expr *> ValidVars; | |
| llvm::SmallVector<OpenACCReductionRecipeWithStorage> Recipes; | |
| for (const auto [Var, OrigRecipe] : | |
| llvm::zip(TransformedVars, C.getRecipes())) { | |
| ExprResult Res = Self.getSema().OpenACC().CheckReductionVar( | |
| ParsedClause.getDirectiveKind(), C.getReductionOp(), Var); | |
| if (Res.isUsable()) { | |
| ValidVars.push_back(Res.get()); | |
| if (OrigRecipe.isSet()) | |
| Recipes.emplace_back(OrigRecipe.AllocaDecl, OrigRecipe.CombinerRecipes); | |
| else | |
| Recipes.push_back(Self.getSema().OpenACC().CreateReductionInitRecipe( | |
| C.getReductionOp(), Res.get())); | |
| } | |
| } | |
| NewClause = Self.getSema().OpenACC().CheckReductionClause( | |
| ExistingClauses, ParsedClause.getDirectiveKind(), | |
| ParsedClause.getBeginLoc(), ParsedClause.getLParenLoc(), | |
| C.getReductionOp(), ValidVars, Recipes, ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitCollapseClause( | |
| const OpenACCCollapseClause &C) { | |
| Expr *LoopCount = const_cast<Expr *>(C.getLoopCount()); | |
| assert(LoopCount && "collapse clause constructed with invalid loop count"); | |
| ExprResult NewLoopCount = Self.TransformExpr(LoopCount); | |
| if (!NewLoopCount.isUsable()) | |
| return; | |
| NewLoopCount = Self.getSema().OpenACC().ActOnIntExpr( | |
| OpenACCDirectiveKind::Invalid, ParsedClause.getClauseKind(), | |
| NewLoopCount.get()->getBeginLoc(), NewLoopCount.get()); | |
| // FIXME: It isn't clear whether this is properly tested here, we should | |
| // probably see if we can come up with a test for this. | |
| if (!NewLoopCount.isUsable()) | |
| return; | |
| NewLoopCount = | |
| Self.getSema().OpenACC().CheckCollapseLoopCount(NewLoopCount.get()); | |
| // FIXME: It isn't clear whether this is properly tested here, we should | |
| // probably see if we can come up with a test for this. | |
| if (!NewLoopCount.isUsable()) | |
| return; | |
| ParsedClause.setCollapseDetails(C.hasForce(), NewLoopCount.get()); | |
| NewClause = OpenACCCollapseClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.isForce(), | |
| ParsedClause.getLoopCount(), ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitTileClause( | |
| const OpenACCTileClause &C) { | |
| llvm::SmallVector<Expr *> TransformedExprs; | |
| for (Expr *E : C.getSizeExprs()) { | |
| ExprResult NewSizeExpr = Self.TransformExpr(E); | |
| if (!NewSizeExpr.isUsable()) | |
| return; | |
| NewSizeExpr = Self.getSema().OpenACC().ActOnIntExpr( | |
| OpenACCDirectiveKind::Invalid, ParsedClause.getClauseKind(), | |
| NewSizeExpr.get()->getBeginLoc(), NewSizeExpr.get()); | |
| // FIXME: It isn't clear whether this is properly tested here, we should | |
| // probably see if we can come up with a test for this. | |
| if (!NewSizeExpr.isUsable()) | |
| return; | |
| NewSizeExpr = Self.getSema().OpenACC().CheckTileSizeExpr(NewSizeExpr.get()); | |
| if (!NewSizeExpr.isUsable()) | |
| return; | |
| TransformedExprs.push_back(NewSizeExpr.get()); | |
| } | |
| ParsedClause.setIntExprDetails(TransformedExprs); | |
| NewClause = OpenACCTileClause::Create( | |
| Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), | |
| ParsedClause.getLParenLoc(), ParsedClause.getIntExprs(), | |
| ParsedClause.getEndLoc()); | |
| } | |
| template <typename Derived> | |
| void OpenACCClauseTransform<Derived>::VisitGangClause( | |
| const OpenACCGangClause &C) { | |
| llvm::SmallVector<OpenACCGangKind> TransformedGangKinds; | |
| llvm::SmallVector<Expr *> TransformedIntExprs; | |
| for (unsigned I = 0; I < C.getNumExprs(); ++I) { | |
| ExprResult ER = Self.TransformExpr(const_cast<Expr *>(C.getExpr(I).second)); | |
| if (!ER.isUsable()) | |
| continue; | |
| ER = Self.getSema().OpenACC().CheckGangExpr(ExistingClauses, | |
| ParsedClause.getDirectiveKind(), | |
| C.getExpr(I).first, ER.get()); | |
| if (!ER.isUsable()) | |
| continue; | |
| TransformedGangKinds.push_back(C.getExpr(I).first); | |
| TransformedIntExprs.push_back(ER.get()); | |
| } | |
| NewClause = Self.getSema().OpenACC().CheckGangClause( | |
| ParsedClause.getDirectiveKind(), ExistingClauses, | |
| ParsedClause.getBeginLoc(), ParsedClause.getLParenLoc(), | |
| TransformedGangKinds, TransformedIntExprs, ParsedClause.getEndLoc()); | |
| } | |
| } // namespace | |
| template <typename Derived> | |
| OpenACCClause *TreeTransform<Derived>::TransformOpenACCClause( | |
| ArrayRef<const OpenACCClause *> ExistingClauses, | |
| OpenACCDirectiveKind DirKind, const OpenACCClause *OldClause) { | |
| SemaOpenACC::OpenACCParsedClause ParsedClause( | |
| DirKind, OldClause->getClauseKind(), OldClause->getBeginLoc()); | |
| ParsedClause.setEndLoc(OldClause->getEndLoc()); | |
| if (const auto *WithParms = dyn_cast<OpenACCClauseWithParams>(OldClause)) | |
| ParsedClause.setLParenLoc(WithParms->getLParenLoc()); | |
| OpenACCClauseTransform<Derived> Transform{*this, ExistingClauses, | |
| ParsedClause}; | |
| Transform.Visit(OldClause); | |
| return Transform.CreatedClause(); | |
| } | |
| template <typename Derived> | |
| llvm::SmallVector<OpenACCClause *> | |
| TreeTransform<Derived>::TransformOpenACCClauseList( | |
| OpenACCDirectiveKind DirKind, ArrayRef<const OpenACCClause *> OldClauses) { | |
| llvm::SmallVector<OpenACCClause *> TransformedClauses; | |
| for (const auto *Clause : OldClauses) { | |
| if (OpenACCClause *TransformedClause = getDerived().TransformOpenACCClause( | |
| TransformedClauses, DirKind, Clause)) | |
| TransformedClauses.push_back(TransformedClause); | |
| } | |
| return TransformedClauses; | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOpenACCComputeConstruct( | |
| OpenACCComputeConstruct *C) { | |
| getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc()); | |
| llvm::SmallVector<OpenACCClause *> TransformedClauses = | |
| getDerived().TransformOpenACCClauseList(C->getDirectiveKind(), | |
| C->clauses()); | |
| if (getSema().OpenACC().ActOnStartStmtDirective( | |
| C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses)) | |
| return StmtError(); | |
| // Transform Structured Block. | |
| SemaOpenACC::AssociatedStmtRAII AssocStmtRAII( | |
| getSema().OpenACC(), C->getDirectiveKind(), C->getDirectiveLoc(), | |
| C->clauses(), TransformedClauses); | |
| StmtResult StrBlock = getDerived().TransformStmt(C->getStructuredBlock()); | |
| StrBlock = getSema().OpenACC().ActOnAssociatedStmt( | |
| C->getBeginLoc(), C->getDirectiveKind(), TransformedClauses, StrBlock); | |
| return getDerived().RebuildOpenACCComputeConstruct( | |
| C->getDirectiveKind(), C->getBeginLoc(), C->getDirectiveLoc(), | |
| C->getEndLoc(), TransformedClauses, StrBlock); | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOpenACCLoopConstruct(OpenACCLoopConstruct *C) { | |
| getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc()); | |
| llvm::SmallVector<OpenACCClause *> TransformedClauses = | |
| getDerived().TransformOpenACCClauseList(C->getDirectiveKind(), | |
| C->clauses()); | |
| if (getSema().OpenACC().ActOnStartStmtDirective( | |
| C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses)) | |
| return StmtError(); | |
| // Transform Loop. | |
| SemaOpenACC::AssociatedStmtRAII AssocStmtRAII( | |
| getSema().OpenACC(), C->getDirectiveKind(), C->getDirectiveLoc(), | |
| C->clauses(), TransformedClauses); | |
| StmtResult Loop = getDerived().TransformStmt(C->getLoop()); | |
| Loop = getSema().OpenACC().ActOnAssociatedStmt( | |
| C->getBeginLoc(), C->getDirectiveKind(), TransformedClauses, Loop); | |
| return getDerived().RebuildOpenACCLoopConstruct( | |
| C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(), | |
| TransformedClauses, Loop); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOpenACCCombinedConstruct( | |
| OpenACCCombinedConstruct *C) { | |
| getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc()); | |
| llvm::SmallVector<OpenACCClause *> TransformedClauses = | |
| getDerived().TransformOpenACCClauseList(C->getDirectiveKind(), | |
| C->clauses()); | |
| if (getSema().OpenACC().ActOnStartStmtDirective( | |
| C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses)) | |
| return StmtError(); | |
| // Transform Loop. | |
| SemaOpenACC::AssociatedStmtRAII AssocStmtRAII( | |
| getSema().OpenACC(), C->getDirectiveKind(), C->getDirectiveLoc(), | |
| C->clauses(), TransformedClauses); | |
| StmtResult Loop = getDerived().TransformStmt(C->getLoop()); | |
| Loop = getSema().OpenACC().ActOnAssociatedStmt( | |
| C->getBeginLoc(), C->getDirectiveKind(), TransformedClauses, Loop); | |
| return getDerived().RebuildOpenACCCombinedConstruct( | |
| C->getDirectiveKind(), C->getBeginLoc(), C->getDirectiveLoc(), | |
| C->getEndLoc(), TransformedClauses, Loop); | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOpenACCDataConstruct(OpenACCDataConstruct *C) { | |
| getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc()); | |
| llvm::SmallVector<OpenACCClause *> TransformedClauses = | |
| getDerived().TransformOpenACCClauseList(C->getDirectiveKind(), | |
| C->clauses()); | |
| if (getSema().OpenACC().ActOnStartStmtDirective( | |
| C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses)) | |
| return StmtError(); | |
| SemaOpenACC::AssociatedStmtRAII AssocStmtRAII( | |
| getSema().OpenACC(), C->getDirectiveKind(), C->getDirectiveLoc(), | |
| C->clauses(), TransformedClauses); | |
| StmtResult StrBlock = getDerived().TransformStmt(C->getStructuredBlock()); | |
| StrBlock = getSema().OpenACC().ActOnAssociatedStmt( | |
| C->getBeginLoc(), C->getDirectiveKind(), TransformedClauses, StrBlock); | |
| return getDerived().RebuildOpenACCDataConstruct( | |
| C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(), | |
| TransformedClauses, StrBlock); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOpenACCEnterDataConstruct( | |
| OpenACCEnterDataConstruct *C) { | |
| getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc()); | |
| llvm::SmallVector<OpenACCClause *> TransformedClauses = | |
| getDerived().TransformOpenACCClauseList(C->getDirectiveKind(), | |
| C->clauses()); | |
| if (getSema().OpenACC().ActOnStartStmtDirective( | |
| C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses)) | |
| return StmtError(); | |
| return getDerived().RebuildOpenACCEnterDataConstruct( | |
| C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(), | |
| TransformedClauses); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOpenACCExitDataConstruct( | |
| OpenACCExitDataConstruct *C) { | |
| getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc()); | |
| llvm::SmallVector<OpenACCClause *> TransformedClauses = | |
| getDerived().TransformOpenACCClauseList(C->getDirectiveKind(), | |
| C->clauses()); | |
| if (getSema().OpenACC().ActOnStartStmtDirective( | |
| C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses)) | |
| return StmtError(); | |
| return getDerived().RebuildOpenACCExitDataConstruct( | |
| C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(), | |
| TransformedClauses); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOpenACCHostDataConstruct( | |
| OpenACCHostDataConstruct *C) { | |
| getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc()); | |
| llvm::SmallVector<OpenACCClause *> TransformedClauses = | |
| getDerived().TransformOpenACCClauseList(C->getDirectiveKind(), | |
| C->clauses()); | |
| if (getSema().OpenACC().ActOnStartStmtDirective( | |
| C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses)) | |
| return StmtError(); | |
| SemaOpenACC::AssociatedStmtRAII AssocStmtRAII( | |
| getSema().OpenACC(), C->getDirectiveKind(), C->getDirectiveLoc(), | |
| C->clauses(), TransformedClauses); | |
| StmtResult StrBlock = getDerived().TransformStmt(C->getStructuredBlock()); | |
| StrBlock = getSema().OpenACC().ActOnAssociatedStmt( | |
| C->getBeginLoc(), C->getDirectiveKind(), TransformedClauses, StrBlock); | |
| return getDerived().RebuildOpenACCHostDataConstruct( | |
| C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(), | |
| TransformedClauses, StrBlock); | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOpenACCInitConstruct(OpenACCInitConstruct *C) { | |
| getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc()); | |
| llvm::SmallVector<OpenACCClause *> TransformedClauses = | |
| getDerived().TransformOpenACCClauseList(C->getDirectiveKind(), | |
| C->clauses()); | |
| if (getSema().OpenACC().ActOnStartStmtDirective( | |
| C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses)) | |
| return StmtError(); | |
| return getDerived().RebuildOpenACCInitConstruct( | |
| C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(), | |
| TransformedClauses); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOpenACCShutdownConstruct( | |
| OpenACCShutdownConstruct *C) { | |
| getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc()); | |
| llvm::SmallVector<OpenACCClause *> TransformedClauses = | |
| getDerived().TransformOpenACCClauseList(C->getDirectiveKind(), | |
| C->clauses()); | |
| if (getSema().OpenACC().ActOnStartStmtDirective( | |
| C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses)) | |
| return StmtError(); | |
| return getDerived().RebuildOpenACCShutdownConstruct( | |
| C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(), | |
| TransformedClauses); | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOpenACCSetConstruct(OpenACCSetConstruct *C) { | |
| getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc()); | |
| llvm::SmallVector<OpenACCClause *> TransformedClauses = | |
| getDerived().TransformOpenACCClauseList(C->getDirectiveKind(), | |
| C->clauses()); | |
| if (getSema().OpenACC().ActOnStartStmtDirective( | |
| C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses)) | |
| return StmtError(); | |
| return getDerived().RebuildOpenACCSetConstruct( | |
| C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(), | |
| TransformedClauses); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOpenACCUpdateConstruct( | |
| OpenACCUpdateConstruct *C) { | |
| getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc()); | |
| llvm::SmallVector<OpenACCClause *> TransformedClauses = | |
| getDerived().TransformOpenACCClauseList(C->getDirectiveKind(), | |
| C->clauses()); | |
| if (getSema().OpenACC().ActOnStartStmtDirective( | |
| C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses)) | |
| return StmtError(); | |
| return getDerived().RebuildOpenACCUpdateConstruct( | |
| C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(), | |
| TransformedClauses); | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformOpenACCWaitConstruct(OpenACCWaitConstruct *C) { | |
| getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc()); | |
| ExprResult DevNumExpr; | |
| if (C->hasDevNumExpr()) { | |
| DevNumExpr = getDerived().TransformExpr(C->getDevNumExpr()); | |
| if (DevNumExpr.isUsable()) | |
| DevNumExpr = getSema().OpenACC().ActOnIntExpr( | |
| OpenACCDirectiveKind::Wait, OpenACCClauseKind::Invalid, | |
| C->getBeginLoc(), DevNumExpr.get()); | |
| } | |
| llvm::SmallVector<Expr *> QueueIdExprs; | |
| for (Expr *QE : C->getQueueIdExprs()) { | |
| assert(QE && "Null queue id expr?"); | |
| ExprResult NewEQ = getDerived().TransformExpr(QE); | |
| if (!NewEQ.isUsable()) | |
| break; | |
| NewEQ = getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Wait, | |
| OpenACCClauseKind::Invalid, | |
| C->getBeginLoc(), NewEQ.get()); | |
| if (NewEQ.isUsable()) | |
| QueueIdExprs.push_back(NewEQ.get()); | |
| } | |
| llvm::SmallVector<OpenACCClause *> TransformedClauses = | |
| getDerived().TransformOpenACCClauseList(C->getDirectiveKind(), | |
| C->clauses()); | |
| if (getSema().OpenACC().ActOnStartStmtDirective( | |
| C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses)) | |
| return StmtError(); | |
| return getDerived().RebuildOpenACCWaitConstruct( | |
| C->getBeginLoc(), C->getDirectiveLoc(), C->getLParenLoc(), | |
| DevNumExpr.isUsable() ? DevNumExpr.get() : nullptr, C->getQueuesLoc(), | |
| QueueIdExprs, C->getRParenLoc(), C->getEndLoc(), TransformedClauses); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOpenACCCacheConstruct( | |
| OpenACCCacheConstruct *C) { | |
| getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc()); | |
| llvm::SmallVector<Expr *> TransformedVarList; | |
| for (Expr *Var : C->getVarList()) { | |
| assert(Var && "Null var listexpr?"); | |
| ExprResult NewVar = getDerived().TransformExpr(Var); | |
| if (!NewVar.isUsable()) | |
| break; | |
| NewVar = getSema().OpenACC().ActOnVar( | |
| C->getDirectiveKind(), OpenACCClauseKind::Invalid, NewVar.get()); | |
| if (!NewVar.isUsable()) | |
| break; | |
| TransformedVarList.push_back(NewVar.get()); | |
| } | |
| if (getSema().OpenACC().ActOnStartStmtDirective(C->getDirectiveKind(), | |
| C->getBeginLoc(), {})) | |
| return StmtError(); | |
| return getDerived().RebuildOpenACCCacheConstruct( | |
| C->getBeginLoc(), C->getDirectiveLoc(), C->getLParenLoc(), | |
| C->getReadOnlyLoc(), TransformedVarList, C->getRParenLoc(), | |
| C->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformOpenACCAtomicConstruct( | |
| OpenACCAtomicConstruct *C) { | |
| getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc()); | |
| llvm::SmallVector<OpenACCClause *> TransformedClauses = | |
| getDerived().TransformOpenACCClauseList(C->getDirectiveKind(), | |
| C->clauses()); | |
| if (getSema().OpenACC().ActOnStartStmtDirective(C->getDirectiveKind(), | |
| C->getBeginLoc(), {})) | |
| return StmtError(); | |
| // Transform Associated Stmt. | |
| SemaOpenACC::AssociatedStmtRAII AssocStmtRAII( | |
| getSema().OpenACC(), C->getDirectiveKind(), C->getDirectiveLoc(), {}, {}); | |
| StmtResult AssocStmt = getDerived().TransformStmt(C->getAssociatedStmt()); | |
| AssocStmt = getSema().OpenACC().ActOnAssociatedStmt( | |
| C->getBeginLoc(), C->getDirectiveKind(), C->getAtomicKind(), {}, | |
| AssocStmt); | |
| return getDerived().RebuildOpenACCAtomicConstruct( | |
| C->getBeginLoc(), C->getDirectiveLoc(), C->getAtomicKind(), | |
| C->getEndLoc(), TransformedClauses, AssocStmt); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformOpenACCAsteriskSizeExpr( | |
| OpenACCAsteriskSizeExpr *E) { | |
| if (getDerived().AlwaysRebuild()) | |
| return getDerived().RebuildOpenACCAsteriskSizeExpr(E->getLocation()); | |
| // Nothing can ever change, so there is never anything to transform. | |
| return E; | |
| } | |
| //===----------------------------------------------------------------------===// | |
| // Expression transformation | |
| //===----------------------------------------------------------------------===// | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformConstantExpr(ConstantExpr *E) { | |
| return TransformExpr(E->getSubExpr()); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformSYCLUniqueStableNameExpr( | |
| SYCLUniqueStableNameExpr *E) { | |
| if (!E->isTypeDependent()) | |
| return E; | |
| TypeSourceInfo *NewT = getDerived().TransformType(E->getTypeSourceInfo()); | |
| if (!NewT) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && E->getTypeSourceInfo() == NewT) | |
| return E; | |
| return getDerived().RebuildSYCLUniqueStableNameExpr( | |
| E->getLocation(), E->getLParenLocation(), E->getRParenLocation(), NewT); | |
| } | |
| template <typename Derived> | |
| StmtResult TreeTransform<Derived>::TransformUnresolvedSYCLKernelCallStmt( | |
| UnresolvedSYCLKernelCallStmt *S) { | |
| auto *FD = cast<FunctionDecl>(SemaRef.CurContext); | |
| const auto *SKEPAttr = FD->template getAttr<SYCLKernelEntryPointAttr>(); | |
| if (!SKEPAttr || SKEPAttr->isInvalidAttr()) | |
| return StmtError(); | |
| ExprResult IdExpr = getDerived().TransformExpr(S->getKernelLaunchIdExpr()); | |
| if (IdExpr.isInvalid()) | |
| return StmtError(); | |
| StmtResult Body = getDerived().TransformStmt(S->getOriginalStmt()); | |
| if (Body.isInvalid()) | |
| return StmtError(); | |
| StmtResult SR = SemaRef.SYCL().BuildSYCLKernelCallStmt( | |
| cast<FunctionDecl>(SemaRef.CurContext), cast<CompoundStmt>(Body.get()), | |
| IdExpr.get()); | |
| if (SR.isInvalid()) | |
| return StmtError(); | |
| return SR; | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformCXXReflectExpr(CXXReflectExpr *E) { | |
| // TODO(reflection): Implement its transform | |
| switch (E->getKind()) { | |
| case ReflectionKind::Type: { | |
| TypeSourceInfo *NewT = getDerived().TransformType( | |
| const_cast<TypeSourceInfo *>(E->getTypeSourceInfo())); | |
| if (!NewT) | |
| return ExprError(); | |
| return SemaRef.BuildCXXReflectExpr(E->getOperatorLoc(), NewT); | |
| } | |
| case ReflectionKind::Null: | |
| llvm_unreachable("A null reflection should not reach here"); | |
| } | |
| assert(false && "unknown or unimplemented reflection entities"); | |
| return ExprError(); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) { | |
| if (!E->isTypeDependent()) | |
| return E; | |
| return getDerived().RebuildPredefinedExpr(E->getLocation(), | |
| E->getIdentKind()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { | |
| NestedNameSpecifierLoc QualifierLoc; | |
| if (E->getQualifierLoc()) { | |
| QualifierLoc | |
| = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); | |
| if (!QualifierLoc) | |
| return ExprError(); | |
| } | |
| ValueDecl *ND | |
| = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(), | |
| E->getDecl())); | |
| if (!ND || ND->isInvalidDecl()) | |
| return ExprError(); | |
| NamedDecl *Found = ND; | |
| if (E->getFoundDecl() != E->getDecl()) { | |
| Found = cast_or_null<NamedDecl>( | |
| getDerived().TransformDecl(E->getLocation(), E->getFoundDecl())); | |
| if (!Found) | |
| return ExprError(); | |
| } | |
| DeclarationNameInfo NameInfo = E->getNameInfo(); | |
| if (NameInfo.getName()) { | |
| NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); | |
| if (!NameInfo.getName()) | |
| return ExprError(); | |
| } | |
| if (!getDerived().AlwaysRebuild() && | |
| !E->isCapturedByCopyInLambdaWithExplicitObjectParameter() && | |
| QualifierLoc == E->getQualifierLoc() && ND == E->getDecl() && | |
| Found == E->getFoundDecl() && | |
| NameInfo.getName() == E->getDecl()->getDeclName() && | |
| !E->hasExplicitTemplateArgs()) { | |
| // Mark it referenced in the new context regardless. | |
| // FIXME: this is a bit instantiation-specific. | |
| SemaRef.MarkDeclRefReferenced(E); | |
| return E; | |
| } | |
| TemplateArgumentListInfo TransArgs, *TemplateArgs = nullptr; | |
| if (E->hasExplicitTemplateArgs()) { | |
| TemplateArgs = &TransArgs; | |
| TransArgs.setLAngleLoc(E->getLAngleLoc()); | |
| TransArgs.setRAngleLoc(E->getRAngleLoc()); | |
| if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), | |
| E->getNumTemplateArgs(), | |
| TransArgs)) | |
| return ExprError(); | |
| } | |
| return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo, | |
| Found, TemplateArgs); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) { | |
| return E; | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformFixedPointLiteral( | |
| FixedPointLiteral *E) { | |
| return E; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) { | |
| return E; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) { | |
| return E; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) { | |
| return E; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { | |
| return E; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) { | |
| return getDerived().TransformCallExpr(E); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) { | |
| ExprResult ControllingExpr; | |
| TypeSourceInfo *ControllingType = nullptr; | |
| if (E->isExprPredicate()) | |
| ControllingExpr = getDerived().TransformExpr(E->getControllingExpr()); | |
| else | |
| ControllingType = getDerived().TransformType(E->getControllingType()); | |
| if (ControllingExpr.isInvalid() && !ControllingType) | |
| return ExprError(); | |
| SmallVector<Expr *, 4> AssocExprs; | |
| SmallVector<TypeSourceInfo *, 4> AssocTypes; | |
| for (const GenericSelectionExpr::Association Assoc : E->associations()) { | |
| TypeSourceInfo *TSI = Assoc.getTypeSourceInfo(); | |
| if (TSI) { | |
| TypeSourceInfo *AssocType = getDerived().TransformType(TSI); | |
| if (!AssocType) | |
| return ExprError(); | |
| AssocTypes.push_back(AssocType); | |
| } else { | |
| AssocTypes.push_back(nullptr); | |
| } | |
| ExprResult AssocExpr = | |
| getDerived().TransformExpr(Assoc.getAssociationExpr()); | |
| if (AssocExpr.isInvalid()) | |
| return ExprError(); | |
| AssocExprs.push_back(AssocExpr.get()); | |
| } | |
| if (!ControllingType) | |
| return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(), | |
| E->getDefaultLoc(), | |
| E->getRParenLoc(), | |
| ControllingExpr.get(), | |
| AssocTypes, | |
| AssocExprs); | |
| return getDerived().RebuildGenericSelectionExpr( | |
| E->getGenericLoc(), E->getDefaultLoc(), E->getRParenLoc(), | |
| ControllingType, AssocTypes, AssocExprs); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) { | |
| ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); | |
| if (SubExpr.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) | |
| return E; | |
| return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(), | |
| E->getRParen()); | |
| } | |
| /// The operand of a unary address-of operator has special rules: it's | |
| /// allowed to refer to a non-static member of a class even if there's no 'this' | |
| /// object available. | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformAddressOfOperand(Expr *E) { | |
| if (DependentScopeDeclRefExpr *DRE = dyn_cast<DependentScopeDeclRefExpr>(E)) | |
| return getDerived().TransformDependentScopeDeclRefExpr( | |
| DRE, /*IsAddressOfOperand=*/true, nullptr); | |
| else if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) | |
| return getDerived().TransformUnresolvedLookupExpr( | |
| ULE, /*IsAddressOfOperand=*/true); | |
| else | |
| return getDerived().TransformExpr(E); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) { | |
| ExprResult SubExpr; | |
| if (E->getOpcode() == UO_AddrOf) | |
| SubExpr = TransformAddressOfOperand(E->getSubExpr()); | |
| else | |
| SubExpr = TransformExpr(E->getSubExpr()); | |
| if (SubExpr.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) | |
| return E; | |
| return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), | |
| E->getOpcode(), | |
| SubExpr.get()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) { | |
| // Transform the type. | |
| TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo()); | |
| if (!Type) | |
| return ExprError(); | |
| // Transform all of the components into a Designation similar to what the | |
| // parser builds. | |
| // FIXME: It would be slightly more efficient in the non-dependent case to | |
| // just map FieldDecls, rather than requiring the rebuilder to look for | |
| // the fields again. However, __builtin_offsetof is rare enough in | |
| // template code that we don't care. | |
| bool ExprChanged = false; | |
| Designation Desig; | |
| for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { | |
| const OffsetOfNode &ON = E->getComponent(I); | |
| switch (ON.getKind()) { | |
| case OffsetOfNode::Array: { | |
| Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex()); | |
| ExprResult Index = getDerived().TransformExpr(FromIndex); | |
| if (Index.isInvalid()) | |
| return ExprError(); | |
| ExprChanged = ExprChanged || Index.get() != FromIndex; | |
| Designator AD = | |
| Designator::CreateArrayDesignator(Index.get(), ON.getBeginLoc()); | |
| AD.setRBracketLoc(ON.getEndLoc()); | |
| Desig.AddDesignator(AD); | |
| break; | |
| } | |
| case OffsetOfNode::Field: | |
| case OffsetOfNode::Identifier: { | |
| const IdentifierInfo *Name = ON.getFieldName(); | |
| if (!Name) | |
| continue; | |
| // The leading designator has no '.'; subsequent ones do. | |
| SourceLocation DotLoc = | |
| Desig.empty() ? SourceLocation() : ON.getBeginLoc(); | |
| Desig.AddDesignator( | |
| Designator::CreateFieldDesignator(Name, DotLoc, ON.getEndLoc())); | |
| break; | |
| } | |
| case OffsetOfNode::Base: | |
| // Will be recomputed during the rebuild. | |
| continue; | |
| } | |
| } | |
| // If nothing changed, retain the existing expression. | |
| if (!getDerived().AlwaysRebuild() && | |
| Type == E->getTypeSourceInfo() && | |
| !ExprChanged) | |
| return E; | |
| // Build a new offsetof expression. | |
| return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type, Desig, | |
| E->getRParenLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) { | |
| assert((!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) && | |
| "opaque value expression requires transformation"); | |
| return E; | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformRecoveryExpr(RecoveryExpr *E) { | |
| llvm::SmallVector<Expr *, 8> Children; | |
| bool Changed = false; | |
| for (Expr *C : E->subExpressions()) { | |
| ExprResult NewC = getDerived().TransformExpr(C); | |
| if (NewC.isInvalid()) | |
| return ExprError(); | |
| Children.push_back(NewC.get()); | |
| Changed |= NewC.get() != C; | |
| } | |
| if (!getDerived().AlwaysRebuild() && !Changed) | |
| return E; | |
| return getDerived().RebuildRecoveryExpr(E->getBeginLoc(), E->getEndLoc(), | |
| Children, E->getType()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) { | |
| // Rebuild the syntactic form. The original syntactic form has | |
| // opaque-value expressions in it, so strip those away and rebuild | |
| // the result. This is a really awful way of doing this, but the | |
| // better solution (rebuilding the semantic expressions and | |
| // rebinding OVEs as necessary) doesn't work; we'd need | |
| // TreeTransform to not strip away implicit conversions. | |
| Expr *newSyntacticForm = SemaRef.PseudoObject().recreateSyntacticForm(E); | |
| ExprResult result = getDerived().TransformExpr(newSyntacticForm); | |
| if (result.isInvalid()) return ExprError(); | |
| // If that gives us a pseudo-object result back, the pseudo-object | |
| // expression must have been an lvalue-to-rvalue conversion which we | |
| // should reapply. | |
| if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject)) | |
| result = SemaRef.PseudoObject().checkRValue(result.get()); | |
| return result; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr( | |
| UnaryExprOrTypeTraitExpr *E) { | |
| if (E->isArgumentType()) { | |
| TypeSourceInfo *OldT = E->getArgumentTypeInfo(); | |
| TypeSourceInfo *NewT = getDerived().TransformType(OldT); | |
| if (!NewT) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && OldT == NewT) | |
| return E; | |
| return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(), | |
| E->getKind(), | |
| E->getSourceRange()); | |
| } | |
| // C++0x [expr.sizeof]p1: | |
| // The operand is either an expression, which is an unevaluated operand | |
| // [...] | |
| EnterExpressionEvaluationContext Unevaluated( | |
| SemaRef, Sema::ExpressionEvaluationContext::Unevaluated, | |
| Sema::ReuseLambdaContextDecl); | |
| // Try to recover if we have something like sizeof(T::X) where X is a type. | |
| // Notably, there must be *exactly* one set of parens if X is a type. | |
| TypeSourceInfo *RecoveryTSI = nullptr; | |
| ExprResult SubExpr; | |
| auto *PE = dyn_cast<ParenExpr>(E->getArgumentExpr()); | |
| if (auto *DRE = | |
| PE ? dyn_cast<DependentScopeDeclRefExpr>(PE->getSubExpr()) : nullptr) | |
| SubExpr = getDerived().TransformParenDependentScopeDeclRefExpr( | |
| PE, DRE, false, &RecoveryTSI); | |
| else | |
| SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); | |
| if (RecoveryTSI) { | |
| return getDerived().RebuildUnaryExprOrTypeTrait( | |
| RecoveryTSI, E->getOperatorLoc(), E->getKind(), E->getSourceRange()); | |
| } else if (SubExpr.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) | |
| return E; | |
| return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(), | |
| E->getOperatorLoc(), | |
| E->getKind(), | |
| E->getSourceRange()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) { | |
| ExprResult LHS = getDerived().TransformExpr(E->getLHS()); | |
| if (LHS.isInvalid()) | |
| return ExprError(); | |
| ExprResult RHS = getDerived().TransformExpr(E->getRHS()); | |
| if (RHS.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| LHS.get() == E->getLHS() && | |
| RHS.get() == E->getRHS()) | |
| return E; | |
| return getDerived().RebuildArraySubscriptExpr( | |
| LHS.get(), | |
| /*FIXME:*/ E->getLHS()->getBeginLoc(), RHS.get(), E->getRBracketLoc()); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformMatrixSingleSubscriptExpr( | |
| MatrixSingleSubscriptExpr *E) { | |
| ExprResult Base = getDerived().TransformExpr(E->getBase()); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| ExprResult RowIdx = getDerived().TransformExpr(E->getRowIdx()); | |
| if (RowIdx.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() && | |
| RowIdx.get() == E->getRowIdx()) | |
| return E; | |
| return getDerived().RebuildMatrixSingleSubscriptExpr(Base.get(), RowIdx.get(), | |
| E->getRBracketLoc()); | |
| } | |
| template <typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformMatrixSubscriptExpr(MatrixSubscriptExpr *E) { | |
| ExprResult Base = getDerived().TransformExpr(E->getBase()); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| ExprResult RowIdx = getDerived().TransformExpr(E->getRowIdx()); | |
| if (RowIdx.isInvalid()) | |
| return ExprError(); | |
| ExprResult ColumnIdx = getDerived().TransformExpr(E->getColumnIdx()); | |
| if (ColumnIdx.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() && | |
| RowIdx.get() == E->getRowIdx() && ColumnIdx.get() == E->getColumnIdx()) | |
| return E; | |
| return getDerived().RebuildMatrixSubscriptExpr( | |
| Base.get(), RowIdx.get(), ColumnIdx.get(), E->getRBracketLoc()); | |
| } | |
| template <typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformArraySectionExpr(ArraySectionExpr *E) { | |
| ExprResult Base = getDerived().TransformExpr(E->getBase()); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| ExprResult LowerBound; | |
| if (E->getLowerBound()) { | |
| LowerBound = getDerived().TransformExpr(E->getLowerBound()); | |
| if (LowerBound.isInvalid()) | |
| return ExprError(); | |
| } | |
| ExprResult Length; | |
| if (E->getLength()) { | |
| Length = getDerived().TransformExpr(E->getLength()); | |
| if (Length.isInvalid()) | |
| return ExprError(); | |
| } | |
| ExprResult Stride; | |
| if (E->isOMPArraySection()) { | |
| if (Expr *Str = E->getStride()) { | |
| Stride = getDerived().TransformExpr(Str); | |
| if (Stride.isInvalid()) | |
| return ExprError(); | |
| } | |
| } | |
| if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() && | |
| LowerBound.get() == E->getLowerBound() && | |
| Length.get() == E->getLength() && | |
| (E->isOpenACCArraySection() || Stride.get() == E->getStride())) | |
| return E; | |
| return getDerived().RebuildArraySectionExpr( | |
| E->isOMPArraySection(), Base.get(), E->getBase()->getEndLoc(), | |
| LowerBound.get(), E->getColonLocFirst(), | |
| E->isOMPArraySection() ? E->getColonLocSecond() : SourceLocation{}, | |
| Length.get(), Stride.get(), E->getRBracketLoc()); | |
| } | |
| template <typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformOMPArrayShapingExpr(OMPArrayShapingExpr *E) { | |
| ExprResult Base = getDerived().TransformExpr(E->getBase()); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| SmallVector<Expr *, 4> Dims; | |
| bool ErrorFound = false; | |
| for (Expr *Dim : E->getDimensions()) { | |
| ExprResult DimRes = getDerived().TransformExpr(Dim); | |
| if (DimRes.isInvalid()) { | |
| ErrorFound = true; | |
| continue; | |
| } | |
| Dims.push_back(DimRes.get()); | |
| } | |
| if (ErrorFound) | |
| return ExprError(); | |
| return getDerived().RebuildOMPArrayShapingExpr(Base.get(), E->getLParenLoc(), | |
| E->getRParenLoc(), Dims, | |
| E->getBracketsRanges()); | |
| } | |
| template <typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformOMPIteratorExpr(OMPIteratorExpr *E) { | |
| unsigned NumIterators = E->numOfIterators(); | |
| SmallVector<SemaOpenMP::OMPIteratorData, 4> Data(NumIterators); | |
| bool ErrorFound = false; | |
| bool NeedToRebuild = getDerived().AlwaysRebuild(); | |
| for (unsigned I = 0; I < NumIterators; ++I) { | |
| auto *D = cast<VarDecl>(E->getIteratorDecl(I)); | |
| Data[I].DeclIdent = D->getIdentifier(); | |
| Data[I].DeclIdentLoc = D->getLocation(); | |
| if (D->getLocation() == D->getBeginLoc()) { | |
| assert(SemaRef.Context.hasSameType(D->getType(), SemaRef.Context.IntTy) && | |
| "Implicit type must be int."); | |
| } else { | |
| TypeSourceInfo *TSI = getDerived().TransformType(D->getTypeSourceInfo()); | |
| QualType DeclTy = getDerived().TransformType(D->getType()); | |
| Data[I].Type = SemaRef.CreateParsedType(DeclTy, TSI); | |
| } | |
| OMPIteratorExpr::IteratorRange Range = E->getIteratorRange(I); | |
| ExprResult Begin = getDerived().TransformExpr(Range.Begin); | |
| ExprResult End = getDerived().TransformExpr(Range.End); | |
| ExprResult Step = getDerived().TransformExpr(Range.Step); | |
| ErrorFound = ErrorFound || | |
| !(!D->getTypeSourceInfo() || (Data[I].Type.getAsOpaquePtr() && | |
| !Data[I].Type.get().isNull())) || | |
| Begin.isInvalid() || End.isInvalid() || Step.isInvalid(); | |
| if (ErrorFound) | |
| continue; | |
| Data[I].Range.Begin = Begin.get(); | |
| Data[I].Range.End = End.get(); | |
| Data[I].Range.Step = Step.get(); | |
| Data[I].AssignLoc = E->getAssignLoc(I); | |
| Data[I].ColonLoc = E->getColonLoc(I); | |
| Data[I].SecColonLoc = E->getSecondColonLoc(I); | |
| NeedToRebuild = | |
| NeedToRebuild || | |
| (D->getTypeSourceInfo() && Data[I].Type.get().getTypePtrOrNull() != | |
| D->getType().getTypePtrOrNull()) || | |
| Range.Begin != Data[I].Range.Begin || Range.End != Data[I].Range.End || | |
| Range.Step != Data[I].Range.Step; | |
| } | |
| if (ErrorFound) | |
| return ExprError(); | |
| if (!NeedToRebuild) | |
| return E; | |
| ExprResult Res = getDerived().RebuildOMPIteratorExpr( | |
| E->getIteratorKwLoc(), E->getLParenLoc(), E->getRParenLoc(), Data); | |
| if (!Res.isUsable()) | |
| return Res; | |
| auto *IE = cast<OMPIteratorExpr>(Res.get()); | |
| for (unsigned I = 0; I < NumIterators; ++I) | |
| getDerived().transformedLocalDecl(E->getIteratorDecl(I), | |
| IE->getIteratorDecl(I)); | |
| return Res; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCallExpr(CallExpr *E) { | |
| // Transform the callee. | |
| ExprResult Callee = getDerived().TransformExpr(E->getCallee()); | |
| if (Callee.isInvalid()) | |
| return ExprError(); | |
| // Transform arguments. | |
| bool ArgChanged = false; | |
| SmallVector<Expr*, 8> Args; | |
| if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, | |
| &ArgChanged)) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| Callee.get() == E->getCallee() && | |
| !ArgChanged) | |
| return SemaRef.MaybeBindToTemporary(E); | |
| // FIXME: Wrong source location information for the '('. | |
| SourceLocation FakeLParenLoc | |
| = ((Expr *)Callee.get())->getSourceRange().getBegin(); | |
| Sema::FPFeaturesStateRAII FPFeaturesState(getSema()); | |
| if (E->hasStoredFPFeatures()) { | |
| FPOptionsOverride NewOverrides = E->getFPFeatures(); | |
| getSema().CurFPFeatures = | |
| NewOverrides.applyOverrides(getSema().getLangOpts()); | |
| getSema().FpPragmaStack.CurrentValue = NewOverrides; | |
| } | |
| return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc, | |
| Args, | |
| E->getRParenLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { | |
| ExprResult Base = getDerived().TransformExpr(E->getBase()); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| NestedNameSpecifierLoc QualifierLoc; | |
| if (E->hasQualifier()) { | |
| QualifierLoc | |
| = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); | |
| if (!QualifierLoc) | |
| return ExprError(); | |
| } | |
| SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc(); | |
| ValueDecl *Member | |
| = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(), | |
| E->getMemberDecl())); | |
| if (!Member) | |
| return ExprError(); | |
| NamedDecl *FoundDecl = E->getFoundDecl(); | |
| if (FoundDecl == E->getMemberDecl()) { | |
| FoundDecl = Member; | |
| } else { | |
| FoundDecl = cast_or_null<NamedDecl>( | |
| getDerived().TransformDecl(E->getMemberLoc(), FoundDecl)); | |
| if (!FoundDecl) | |
| return ExprError(); | |
| } | |
| if (!getDerived().AlwaysRebuild() && | |
| Base.get() == E->getBase() && | |
| QualifierLoc == E->getQualifierLoc() && | |
| Member == E->getMemberDecl() && | |
| FoundDecl == E->getFoundDecl() && | |
| !E->hasExplicitTemplateArgs()) { | |
| // Skip for member expression of (this->f), rebuilt thisi->f is needed | |
| // for Openmp where the field need to be privatizized in the case. | |
| if (!(isa<CXXThisExpr>(E->getBase()) && | |
| getSema().OpenMP().isOpenMPRebuildMemberExpr( | |
| cast<ValueDecl>(Member)))) { | |
| // Mark it referenced in the new context regardless. | |
| // FIXME: this is a bit instantiation-specific. | |
| SemaRef.MarkMemberReferenced(E); | |
| return E; | |
| } | |
| } | |
| TemplateArgumentListInfo TransArgs; | |
| if (E->hasExplicitTemplateArgs()) { | |
| TransArgs.setLAngleLoc(E->getLAngleLoc()); | |
| TransArgs.setRAngleLoc(E->getRAngleLoc()); | |
| if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), | |
| E->getNumTemplateArgs(), | |
| TransArgs)) | |
| return ExprError(); | |
| } | |
| // FIXME: Bogus source location for the operator | |
| SourceLocation FakeOperatorLoc = | |
| SemaRef.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); | |
| // FIXME: to do this check properly, we will need to preserve the | |
| // first-qualifier-in-scope here, just in case we had a dependent | |
| // base (and therefore couldn't do the check) and a | |
| // nested-name-qualifier (and therefore could do the lookup). | |
| NamedDecl *FirstQualifierInScope = nullptr; | |
| DeclarationNameInfo MemberNameInfo = E->getMemberNameInfo(); | |
| if (MemberNameInfo.getName()) { | |
| MemberNameInfo = getDerived().TransformDeclarationNameInfo(MemberNameInfo); | |
| if (!MemberNameInfo.getName()) | |
| return ExprError(); | |
| } | |
| return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc, | |
| E->isArrow(), | |
| QualifierLoc, | |
| TemplateKWLoc, | |
| MemberNameInfo, | |
| Member, | |
| FoundDecl, | |
| (E->hasExplicitTemplateArgs() | |
| ? &TransArgs : nullptr), | |
| FirstQualifierInScope); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { | |
| ExprResult LHS = getDerived().TransformExpr(E->getLHS()); | |
| if (LHS.isInvalid()) | |
| return ExprError(); | |
| ExprResult RHS = | |
| getDerived().TransformInitializer(E->getRHS(), /*NotCopyInit=*/false); | |
| if (RHS.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| LHS.get() == E->getLHS() && | |
| RHS.get() == E->getRHS()) | |
| return E; | |
| if (E->isCompoundAssignmentOp()) | |
| // FPFeatures has already been established from trailing storage | |
| return getDerived().RebuildBinaryOperator( | |
| E->getOperatorLoc(), E->getOpcode(), LHS.get(), RHS.get()); | |
| Sema::FPFeaturesStateRAII FPFeaturesState(getSema()); | |
| FPOptionsOverride NewOverrides(E->getFPFeatures()); | |
| getSema().CurFPFeatures = | |
| NewOverrides.applyOverrides(getSema().getLangOpts()); | |
| getSema().FpPragmaStack.CurrentValue = NewOverrides; | |
| return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(), | |
| LHS.get(), RHS.get()); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformCXXRewrittenBinaryOperator( | |
| CXXRewrittenBinaryOperator *E) { | |
| CXXRewrittenBinaryOperator::DecomposedForm Decomp = E->getDecomposedForm(); | |
| ExprResult LHS = getDerived().TransformExpr(const_cast<Expr*>(Decomp.LHS)); | |
| if (LHS.isInvalid()) | |
| return ExprError(); | |
| ExprResult RHS = getDerived().TransformExpr(const_cast<Expr*>(Decomp.RHS)); | |
| if (RHS.isInvalid()) | |
| return ExprError(); | |
| // Extract the already-resolved callee declarations so that we can restrict | |
| // ourselves to using them as the unqualified lookup results when rebuilding. | |
| UnresolvedSet<2> UnqualLookups; | |
| bool ChangedAnyLookups = false; | |
| Expr *PossibleBinOps[] = {E->getSemanticForm(), | |
| const_cast<Expr *>(Decomp.InnerBinOp)}; | |
| for (Expr *PossibleBinOp : PossibleBinOps) { | |
| auto *Op = dyn_cast<CXXOperatorCallExpr>(PossibleBinOp->IgnoreImplicit()); | |
| if (!Op) | |
| continue; | |
| auto *Callee = dyn_cast<DeclRefExpr>(Op->getCallee()->IgnoreImplicit()); | |
| if (!Callee || isa<CXXMethodDecl>(Callee->getDecl())) | |
| continue; | |
| // Transform the callee in case we built a call to a local extern | |
| // declaration. | |
| NamedDecl *Found = cast_or_null<NamedDecl>(getDerived().TransformDecl( | |
| E->getOperatorLoc(), Callee->getFoundDecl())); | |
| if (!Found) | |
| return ExprError(); | |
| if (Found != Callee->getFoundDecl()) | |
| ChangedAnyLookups = true; | |
| UnqualLookups.addDecl(Found); | |
| } | |
| if (!getDerived().AlwaysRebuild() && !ChangedAnyLookups && | |
| LHS.get() == Decomp.LHS && RHS.get() == Decomp.RHS) { | |
| // Mark all functions used in the rewrite as referenced. Note that when | |
| // a < b is rewritten to (a <=> b) < 0, both the <=> and the < might be | |
| // function calls, and/or there might be a user-defined conversion sequence | |
| // applied to the operands of the <. | |
| // FIXME: this is a bit instantiation-specific. | |
| const Expr *StopAt[] = {Decomp.LHS, Decomp.RHS}; | |
| SemaRef.MarkDeclarationsReferencedInExpr(E, false, StopAt); | |
| return E; | |
| } | |
| return getDerived().RebuildCXXRewrittenBinaryOperator( | |
| E->getOperatorLoc(), Decomp.Opcode, UnqualLookups, LHS.get(), RHS.get()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCompoundAssignOperator( | |
| CompoundAssignOperator *E) { | |
| Sema::FPFeaturesStateRAII FPFeaturesState(getSema()); | |
| FPOptionsOverride NewOverrides(E->getFPFeatures()); | |
| getSema().CurFPFeatures = | |
| NewOverrides.applyOverrides(getSema().getLangOpts()); | |
| getSema().FpPragmaStack.CurrentValue = NewOverrides; | |
| return getDerived().TransformBinaryOperator(E); | |
| } | |
| template<typename Derived> | |
| ExprResult TreeTransform<Derived>:: | |
| TransformBinaryConditionalOperator(BinaryConditionalOperator *e) { | |
| // Just rebuild the common and RHS expressions and see whether we | |
| // get any changes. | |
| ExprResult commonExpr = getDerived().TransformExpr(e->getCommon()); | |
| if (commonExpr.isInvalid()) | |
| return ExprError(); | |
| ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr()); | |
| if (rhs.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| commonExpr.get() == e->getCommon() && | |
| rhs.get() == e->getFalseExpr()) | |
| return e; | |
| return getDerived().RebuildConditionalOperator(commonExpr.get(), | |
| e->getQuestionLoc(), | |
| nullptr, | |
| e->getColonLoc(), | |
| rhs.get()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) { | |
| ExprResult Cond = getDerived().TransformExpr(E->getCond()); | |
| if (Cond.isInvalid()) | |
| return ExprError(); | |
| ExprResult LHS = getDerived().TransformExpr(E->getLHS()); | |
| if (LHS.isInvalid()) | |
| return ExprError(); | |
| ExprResult RHS = getDerived().TransformExpr(E->getRHS()); | |
| if (RHS.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| Cond.get() == E->getCond() && | |
| LHS.get() == E->getLHS() && | |
| RHS.get() == E->getRHS()) | |
| return E; | |
| return getDerived().RebuildConditionalOperator(Cond.get(), | |
| E->getQuestionLoc(), | |
| LHS.get(), | |
| E->getColonLoc(), | |
| RHS.get()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) { | |
| // Implicit casts are eliminated during transformation, since they | |
| // will be recomputed by semantic analysis after transformation. | |
| return getDerived().TransformExpr(E->getSubExprAsWritten()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) { | |
| TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); | |
| if (!Type) | |
| return ExprError(); | |
| ExprResult SubExpr | |
| = getDerived().TransformExpr(E->getSubExprAsWritten()); | |
| if (SubExpr.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| Type == E->getTypeInfoAsWritten() && | |
| SubExpr.get() == E->getSubExpr()) | |
| return E; | |
| return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(), | |
| Type, | |
| E->getRParenLoc(), | |
| SubExpr.get()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) { | |
| TypeSourceInfo *OldT = E->getTypeSourceInfo(); | |
| TypeSourceInfo *NewT = getDerived().TransformType(OldT); | |
| if (!NewT) | |
| return ExprError(); | |
| ExprResult Init = getDerived().TransformExpr(E->getInitializer()); | |
| if (Init.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| OldT == NewT && | |
| Init.get() == E->getInitializer()) | |
| return SemaRef.MaybeBindToTemporary(E); | |
| // Note: the expression type doesn't necessarily match the | |
| // type-as-written, but that's okay, because it should always be | |
| // derivable from the initializer. | |
| return getDerived().RebuildCompoundLiteralExpr( | |
| E->getLParenLoc(), NewT, | |
| /*FIXME:*/ E->getInitializer()->getEndLoc(), Init.get()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { | |
| ExprResult Base = getDerived().TransformExpr(E->getBase()); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| Base.get() == E->getBase()) | |
| return E; | |
| // FIXME: Bad source location | |
| SourceLocation FakeOperatorLoc = | |
| SemaRef.getLocForEndOfToken(E->getBase()->getEndLoc()); | |
| return getDerived().RebuildExtVectorOrMatrixElementExpr( | |
| Base.get(), FakeOperatorLoc, E->isArrow(), E->getAccessorLoc(), | |
| E->getAccessor()); | |
| } | |
| template <typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformMatrixElementExpr(MatrixElementExpr *E) { | |
| ExprResult Base = getDerived().TransformExpr(E->getBase()); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase()) | |
| return E; | |
| // FIXME: Bad source location | |
| SourceLocation FakeOperatorLoc = | |
| SemaRef.getLocForEndOfToken(E->getBase()->getEndLoc()); | |
| return getDerived().RebuildExtVectorOrMatrixElementExpr( | |
| Base.get(), FakeOperatorLoc, /*isArrow*/ false, E->getAccessorLoc(), | |
| E->getAccessor()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) { | |
| if (InitListExpr *Syntactic = E->getSyntacticForm()) | |
| E = Syntactic; | |
| bool InitChanged = false; | |
| EnterExpressionEvaluationContext Context( | |
| getSema(), EnterExpressionEvaluationContext::InitList); | |
| SmallVector<Expr*, 4> Inits; | |
| if (getDerived().TransformExprs(E->getInits(), E->getNumInits(), false, | |
| Inits, &InitChanged)) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && !InitChanged) { | |
| // FIXME: Attempt to reuse the existing syntactic form of the InitListExpr | |
| // in some cases. We can't reuse it in general, because the syntactic and | |
| // semantic forms are linked, and we can't know that semantic form will | |
| // match even if the syntactic form does. | |
| } | |
| return getDerived().RebuildInitList(E->getLBraceLoc(), Inits, | |
| E->getRBraceLoc(), E->isExplicit()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { | |
| Designation Desig; | |
| // transform the initializer value | |
| ExprResult Init = getDerived().TransformExpr(E->getInit()); | |
| if (Init.isInvalid()) | |
| return ExprError(); | |
| // transform the designators. | |
| SmallVector<Expr*, 4> ArrayExprs; | |
| bool ExprChanged = false; | |
| for (const DesignatedInitExpr::Designator &D : E->designators()) { | |
| if (D.isFieldDesignator()) { | |
| if (D.getFieldDecl()) { | |
| FieldDecl *Field = cast_or_null<FieldDecl>( | |
| getDerived().TransformDecl(D.getFieldLoc(), D.getFieldDecl())); | |
| if (Field != D.getFieldDecl()) | |
| // Rebuild the expression when the transformed FieldDecl is | |
| // different to the already assigned FieldDecl. | |
| ExprChanged = true; | |
| if (Field->isAnonymousStructOrUnion()) | |
| continue; | |
| } else { | |
| // Ensure that the designator expression is rebuilt when there isn't | |
| // a resolved FieldDecl in the designator as we don't want to assign | |
| // a FieldDecl to a pattern designator that will be instantiated again. | |
| ExprChanged = true; | |
| } | |
| Desig.AddDesignator(Designator::CreateFieldDesignator( | |
| D.getFieldName(), D.getDotLoc(), D.getFieldLoc())); | |
| continue; | |
| } | |
| if (D.isArrayDesignator()) { | |
| ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(D)); | |
| if (Index.isInvalid()) | |
| return ExprError(); | |
| Desig.AddDesignator( | |
| Designator::CreateArrayDesignator(Index.get(), D.getLBracketLoc())); | |
| ExprChanged = ExprChanged || Index.get() != E->getArrayIndex(D); | |
| ArrayExprs.push_back(Index.get()); | |
| continue; | |
| } | |
| assert(D.isArrayRangeDesignator() && "New kind of designator?"); | |
| ExprResult Start | |
| = getDerived().TransformExpr(E->getArrayRangeStart(D)); | |
| if (Start.isInvalid()) | |
| return ExprError(); | |
| ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(D)); | |
| if (End.isInvalid()) | |
| return ExprError(); | |
| Desig.AddDesignator(Designator::CreateArrayRangeDesignator( | |
| Start.get(), End.get(), D.getLBracketLoc(), D.getEllipsisLoc())); | |
| ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(D) || | |
| End.get() != E->getArrayRangeEnd(D); | |
| ArrayExprs.push_back(Start.get()); | |
| ArrayExprs.push_back(End.get()); | |
| } | |
| if (!getDerived().AlwaysRebuild() && | |
| Init.get() == E->getInit() && | |
| !ExprChanged) | |
| return E; | |
| return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs, | |
| E->getEqualOrColonLoc(), | |
| E->usesGNUSyntax(), Init.get()); | |
| } | |
| // Seems that if TransformInitListExpr() only works on the syntactic form of an | |
| // InitListExpr, then a DesignatedInitUpdateExpr is not encountered. | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformDesignatedInitUpdateExpr( | |
| DesignatedInitUpdateExpr *E) { | |
| llvm_unreachable("Unexpected DesignatedInitUpdateExpr in syntactic form of " | |
| "initializer"); | |
| return ExprError(); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformNoInitExpr( | |
| NoInitExpr *E) { | |
| llvm_unreachable("Unexpected NoInitExpr in syntactic form of initializer"); | |
| return ExprError(); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformArrayInitLoopExpr(ArrayInitLoopExpr *E) { | |
| llvm_unreachable("Unexpected ArrayInitLoopExpr outside of initializer"); | |
| return ExprError(); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformArrayInitIndexExpr(ArrayInitIndexExpr *E) { | |
| llvm_unreachable("Unexpected ArrayInitIndexExpr outside of initializer"); | |
| return ExprError(); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformImplicitValueInitExpr( | |
| ImplicitValueInitExpr *E) { | |
| TemporaryBase Rebase(*this, E->getBeginLoc(), DeclarationName()); | |
| // FIXME: Will we ever have proper type location here? Will we actually | |
| // need to transform the type? | |
| QualType T = getDerived().TransformType(E->getType()); | |
| if (T.isNull()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| T == E->getType()) | |
| return E; | |
| return getDerived().RebuildImplicitValueInitExpr(T); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) { | |
| TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo()); | |
| if (!TInfo) | |
| return ExprError(); | |
| ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); | |
| if (SubExpr.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| TInfo == E->getWrittenTypeInfo() && | |
| SubExpr.get() == E->getSubExpr()) | |
| return E; | |
| return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(), | |
| TInfo, E->getRParenLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { | |
| bool ArgumentChanged = false; | |
| SmallVector<Expr*, 4> Inits; | |
| if (TransformExprs(E->getExprs(), E->getNumExprs(), true, Inits, | |
| &ArgumentChanged)) | |
| return ExprError(); | |
| return getDerived().RebuildParenListExpr(E->getLParenLoc(), | |
| Inits, | |
| E->getRParenLoc()); | |
| } | |
| /// Transform an address-of-label expression. | |
| /// | |
| /// By default, the transformation of an address-of-label expression always | |
| /// rebuilds the expression, so that the label identifier can be resolved to | |
| /// the corresponding label statement by semantic analysis. | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) { | |
| Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(), | |
| E->getLabel()); | |
| if (!LD) | |
| return ExprError(); | |
| return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(), | |
| cast<LabelDecl>(LD)); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) { | |
| SemaRef.ActOnStartStmtExpr(); | |
| StmtResult SubStmt | |
| = getDerived().TransformCompoundStmt(E->getSubStmt(), true); | |
| if (SubStmt.isInvalid()) { | |
| SemaRef.ActOnStmtExprError(); | |
| return ExprError(); | |
| } | |
| unsigned OldDepth = E->getTemplateDepth(); | |
| unsigned NewDepth = getDerived().TransformTemplateDepth(OldDepth); | |
| if (!getDerived().AlwaysRebuild() && OldDepth == NewDepth && | |
| SubStmt.get() == E->getSubStmt()) { | |
| // Calling this an 'error' is unintuitive, but it does the right thing. | |
| SemaRef.ActOnStmtExprError(); | |
| return SemaRef.MaybeBindToTemporary(E); | |
| } | |
| return getDerived().RebuildStmtExpr(E->getLParenLoc(), SubStmt.get(), | |
| E->getRParenLoc(), NewDepth); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { | |
| ExprResult Cond = getDerived().TransformExpr(E->getCond()); | |
| if (Cond.isInvalid()) | |
| return ExprError(); | |
| ExprResult LHS = getDerived().TransformExpr(E->getLHS()); | |
| if (LHS.isInvalid()) | |
| return ExprError(); | |
| ExprResult RHS = getDerived().TransformExpr(E->getRHS()); | |
| if (RHS.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| Cond.get() == E->getCond() && | |
| LHS.get() == E->getLHS() && | |
| RHS.get() == E->getRHS()) | |
| return E; | |
| return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), | |
| Cond.get(), LHS.get(), RHS.get(), | |
| E->getRParenLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) { | |
| return E; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { | |
| switch (E->getOperator()) { | |
| case OO_New: | |
| case OO_Delete: | |
| case OO_Array_New: | |
| case OO_Array_Delete: | |
| llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr"); | |
| case OO_Subscript: | |
| case OO_Call: { | |
| // This is a call to an object's operator(). | |
| assert(E->getNumArgs() >= 1 && "Object call is missing arguments"); | |
| // Transform the object itself. | |
| ExprResult Object = getDerived().TransformExpr(E->getArg(0)); | |
| if (Object.isInvalid()) | |
| return ExprError(); | |
| // FIXME: Poor location information. Also, if the location for the end of | |
| // the token is within a macro expansion, getLocForEndOfToken() will return | |
| // an invalid source location. If that happens and we have an otherwise | |
| // valid end location, use the valid one instead of the invalid one. | |
| SourceLocation EndLoc = static_cast<Expr *>(Object.get())->getEndLoc(); | |
| SourceLocation FakeLParenLoc = SemaRef.getLocForEndOfToken(EndLoc); | |
| if (FakeLParenLoc.isInvalid() && EndLoc.isValid()) | |
| FakeLParenLoc = EndLoc; | |
| // Transform the call arguments. | |
| SmallVector<Expr*, 8> Args; | |
| if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1, true, | |
| Args)) | |
| return ExprError(); | |
| if (E->getOperator() == OO_Subscript) | |
| return getDerived().RebuildCxxSubscriptExpr(Object.get(), FakeLParenLoc, | |
| Args, E->getEndLoc()); | |
| return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc, Args, | |
| E->getEndLoc()); | |
| } | |
| #define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \ | |
| case OO_##Name: \ | |
| break; | |
| #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly) | |
| #include "clang/Basic/OperatorKinds.def" | |
| case OO_Conditional: | |
| llvm_unreachable("conditional operator is not actually overloadable"); | |
| case OO_None: | |
| case NUM_OVERLOADED_OPERATORS: | |
| llvm_unreachable("not an overloaded operator?"); | |
| } | |
| ExprResult First; | |
| if (E->getNumArgs() == 1 && E->getOperator() == OO_Amp) | |
| First = getDerived().TransformAddressOfOperand(E->getArg(0)); | |
| else | |
| First = getDerived().TransformExpr(E->getArg(0)); | |
| if (First.isInvalid()) | |
| return ExprError(); | |
| ExprResult Second; | |
| if (E->getNumArgs() == 2) { | |
| Second = | |
| getDerived().TransformInitializer(E->getArg(1), /*NotCopyInit=*/false); | |
| if (Second.isInvalid()) | |
| return ExprError(); | |
| } | |
| Sema::FPFeaturesStateRAII FPFeaturesState(getSema()); | |
| FPOptionsOverride NewOverrides(E->getFPFeatures()); | |
| getSema().CurFPFeatures = | |
| NewOverrides.applyOverrides(getSema().getLangOpts()); | |
| getSema().FpPragmaStack.CurrentValue = NewOverrides; | |
| Expr *Callee = E->getCallee(); | |
| if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) { | |
| LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(), | |
| Sema::LookupOrdinaryName); | |
| if (getDerived().TransformOverloadExprDecls(ULE, ULE->requiresADL(), R)) | |
| return ExprError(); | |
| return getDerived().RebuildCXXOperatorCallExpr( | |
| E->getOperator(), E->getOperatorLoc(), Callee->getBeginLoc(), | |
| ULE->requiresADL(), R.asUnresolvedSet(), First.get(), Second.get()); | |
| } | |
| UnresolvedSet<1> Functions; | |
| if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee)) | |
| Callee = ICE->getSubExprAsWritten(); | |
| NamedDecl *DR = cast<DeclRefExpr>(Callee)->getDecl(); | |
| ValueDecl *VD = cast_or_null<ValueDecl>( | |
| getDerived().TransformDecl(DR->getLocation(), DR)); | |
| if (!VD) | |
| return ExprError(); | |
| if (!isa<CXXMethodDecl>(VD)) | |
| Functions.addDecl(VD); | |
| return getDerived().RebuildCXXOperatorCallExpr( | |
| E->getOperator(), E->getOperatorLoc(), Callee->getBeginLoc(), | |
| /*RequiresADL=*/false, Functions, First.get(), Second.get()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) { | |
| return getDerived().TransformCallExpr(E); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformSourceLocExpr(SourceLocExpr *E) { | |
| bool NeedRebuildFunc = SourceLocExpr::MayBeDependent(E->getIdentKind()) && | |
| getSema().CurContext != E->getParentContext(); | |
| if (!getDerived().AlwaysRebuild() && !NeedRebuildFunc) | |
| return E; | |
| return getDerived().RebuildSourceLocExpr(E->getIdentKind(), E->getType(), | |
| E->getBeginLoc(), E->getEndLoc(), | |
| getSema().CurContext); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformEmbedExpr(EmbedExpr *E) { | |
| return E; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) { | |
| // Transform the callee. | |
| ExprResult Callee = getDerived().TransformExpr(E->getCallee()); | |
| if (Callee.isInvalid()) | |
| return ExprError(); | |
| // Transform exec config. | |
| ExprResult EC = getDerived().TransformCallExpr(E->getConfig()); | |
| if (EC.isInvalid()) | |
| return ExprError(); | |
| // Transform arguments. | |
| bool ArgChanged = false; | |
| SmallVector<Expr*, 8> Args; | |
| if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, | |
| &ArgChanged)) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| Callee.get() == E->getCallee() && | |
| !ArgChanged) | |
| return SemaRef.MaybeBindToTemporary(E); | |
| // FIXME: Wrong source location information for the '('. | |
| SourceLocation FakeLParenLoc | |
| = ((Expr *)Callee.get())->getSourceRange().getBegin(); | |
| return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc, | |
| Args, | |
| E->getRParenLoc(), EC.get()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) { | |
| TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); | |
| if (!Type) | |
| return ExprError(); | |
| ExprResult SubExpr | |
| = getDerived().TransformExpr(E->getSubExprAsWritten()); | |
| if (SubExpr.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| Type == E->getTypeInfoAsWritten() && | |
| SubExpr.get() == E->getSubExpr()) | |
| return E; | |
| return getDerived().RebuildCXXNamedCastExpr( | |
| E->getOperatorLoc(), E->getStmtClass(), E->getAngleBrackets().getBegin(), | |
| Type, E->getAngleBrackets().getEnd(), | |
| // FIXME. this should be '(' location | |
| E->getAngleBrackets().getEnd(), SubExpr.get(), E->getRParenLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformBuiltinBitCastExpr(BuiltinBitCastExpr *BCE) { | |
| TypeSourceInfo *TSI = | |
| getDerived().TransformType(BCE->getTypeInfoAsWritten()); | |
| if (!TSI) | |
| return ExprError(); | |
| ExprResult Sub = getDerived().TransformExpr(BCE->getSubExpr()); | |
| if (Sub.isInvalid()) | |
| return ExprError(); | |
| return getDerived().RebuildBuiltinBitCastExpr(BCE->getBeginLoc(), TSI, | |
| Sub.get(), BCE->getEndLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) { | |
| return getDerived().TransformCXXNamedCastExpr(E); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) { | |
| return getDerived().TransformCXXNamedCastExpr(E); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXReinterpretCastExpr( | |
| CXXReinterpretCastExpr *E) { | |
| return getDerived().TransformCXXNamedCastExpr(E); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) { | |
| return getDerived().TransformCXXNamedCastExpr(E); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) { | |
| return getDerived().TransformCXXNamedCastExpr(E); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXFunctionalCastExpr( | |
| CXXFunctionalCastExpr *E) { | |
| TypeSourceInfo *Type = | |
| getDerived().TransformTypeWithDeducedTST(E->getTypeInfoAsWritten()); | |
| if (!Type) | |
| return ExprError(); | |
| ExprResult SubExpr | |
| = getDerived().TransformExpr(E->getSubExprAsWritten()); | |
| if (SubExpr.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| Type == E->getTypeInfoAsWritten() && | |
| SubExpr.get() == E->getSubExpr()) | |
| return E; | |
| return getDerived().RebuildCXXFunctionalCastExpr(Type, | |
| E->getLParenLoc(), | |
| SubExpr.get(), | |
| E->getRParenLoc(), | |
| E->isListInitialization()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { | |
| if (E->isTypeOperand()) { | |
| TypeSourceInfo *TInfo | |
| = getDerived().TransformType(E->getTypeOperandSourceInfo()); | |
| if (!TInfo) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| TInfo == E->getTypeOperandSourceInfo()) | |
| return E; | |
| return getDerived().RebuildCXXTypeidExpr(E->getType(), E->getBeginLoc(), | |
| TInfo, E->getEndLoc()); | |
| } | |
| // Typeid's operand is an unevaluated context, unless it's a polymorphic | |
| // type. We must not unilaterally enter unevaluated context here, as then | |
| // semantic processing can re-transform an already transformed operand. | |
| Expr *Op = E->getExprOperand(); | |
| auto EvalCtx = Sema::ExpressionEvaluationContext::Unevaluated; | |
| if (E->isGLValue()) { | |
| QualType OpType = Op->getType(); | |
| if (auto *RD = OpType->getAsCXXRecordDecl()) { | |
| if (SemaRef.RequireCompleteType(E->getBeginLoc(), OpType, | |
| diag::err_incomplete_typeid)) | |
| return ExprError(); | |
| if (RD->isPolymorphic()) | |
| EvalCtx = SemaRef.ExprEvalContexts.back().Context; | |
| } | |
| } | |
| EnterExpressionEvaluationContext Unevaluated(SemaRef, EvalCtx, | |
| Sema::ReuseLambdaContextDecl); | |
| ExprResult SubExpr = getDerived().TransformExpr(Op); | |
| if (SubExpr.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| SubExpr.get() == E->getExprOperand()) | |
| return E; | |
| return getDerived().RebuildCXXTypeidExpr(E->getType(), E->getBeginLoc(), | |
| SubExpr.get(), E->getEndLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) { | |
| if (E->isTypeOperand()) { | |
| TypeSourceInfo *TInfo | |
| = getDerived().TransformType(E->getTypeOperandSourceInfo()); | |
| if (!TInfo) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| TInfo == E->getTypeOperandSourceInfo()) | |
| return E; | |
| return getDerived().RebuildCXXUuidofExpr(E->getType(), E->getBeginLoc(), | |
| TInfo, E->getEndLoc()); | |
| } | |
| EnterExpressionEvaluationContext Unevaluated( | |
| SemaRef, Sema::ExpressionEvaluationContext::Unevaluated); | |
| ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); | |
| if (SubExpr.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| SubExpr.get() == E->getExprOperand()) | |
| return E; | |
| return getDerived().RebuildCXXUuidofExpr(E->getType(), E->getBeginLoc(), | |
| SubExpr.get(), E->getEndLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { | |
| return E; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( | |
| CXXNullPtrLiteralExpr *E) { | |
| return E; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) { | |
| // In lambdas, the qualifiers of the type depends of where in | |
| // the call operator `this` appear, and we do not have a good way to | |
| // rebuild this information, so we transform the type. | |
| // | |
| // In other contexts, the type of `this` may be overrided | |
| // for type deduction, so we need to recompute it. | |
| // | |
| // Always recompute the type if we're in the body of a lambda, and | |
| // 'this' is dependent on a lambda's explicit object parameter; we | |
| // also need to always rebuild the expression in this case to clear | |
| // the flag. | |
| QualType T = [&]() { | |
| auto &S = getSema(); | |
| if (E->isCapturedByCopyInLambdaWithExplicitObjectParameter()) | |
| return S.getCurrentThisType(); | |
| if (S.getCurLambda()) | |
| return getDerived().TransformType(E->getType()); | |
| return S.getCurrentThisType(); | |
| }(); | |
| if (!getDerived().AlwaysRebuild() && T == E->getType() && | |
| !E->isCapturedByCopyInLambdaWithExplicitObjectParameter()) { | |
| // Mark it referenced in the new context regardless. | |
| // FIXME: this is a bit instantiation-specific. | |
| getSema().MarkThisReferenced(E); | |
| return E; | |
| } | |
| return getDerived().RebuildCXXThisExpr(E->getBeginLoc(), T, E->isImplicit()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) { | |
| ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); | |
| if (SubExpr.isInvalid()) | |
| return ExprError(); | |
| getSema().DiagnoseExceptionUse(E->getThrowLoc(), /* IsTry= */ false); | |
| if (!getDerived().AlwaysRebuild() && | |
| SubExpr.get() == E->getSubExpr()) | |
| return E; | |
| return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(), | |
| E->isThrownVariableInScope()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { | |
| ParmVarDecl *Param = cast_or_null<ParmVarDecl>( | |
| getDerived().TransformDecl(E->getBeginLoc(), E->getParam())); | |
| if (!Param) | |
| return ExprError(); | |
| ExprResult InitRes; | |
| if (E->hasRewrittenInit()) { | |
| InitRes = getDerived().TransformExpr(E->getRewrittenExpr()); | |
| if (InitRes.isInvalid()) | |
| return ExprError(); | |
| } | |
| if (!getDerived().AlwaysRebuild() && Param == E->getParam() && | |
| E->getUsedContext() == SemaRef.CurContext && | |
| InitRes.get() == E->getRewrittenExpr()) | |
| return E; | |
| return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param, | |
| InitRes.get()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) { | |
| FieldDecl *Field = cast_or_null<FieldDecl>( | |
| getDerived().TransformDecl(E->getBeginLoc(), E->getField())); | |
| if (!Field) | |
| return ExprError(); | |
| ExprResult InitRes; | |
| if (E->hasRewrittenInit()) { | |
| // The initializer can refer to `this` and to other members, so it has to | |
| // be transformed in the scope of the field's class. | |
| Sema::CXXThisScopeRAII ThisScope(SemaRef, Field->getParent(), Qualifiers()); | |
| InitRes = getDerived().TransformExpr(E->getRewrittenExpr()); | |
| if (InitRes.isInvalid()) | |
| return ExprError(); | |
| } | |
| if (!getDerived().AlwaysRebuild() && Field == E->getField() && | |
| E->getUsedContext() == SemaRef.CurContext && | |
| InitRes.get() == E->getExpr()) | |
| return E; | |
| return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field, | |
| InitRes.get()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXScalarValueInitExpr( | |
| CXXScalarValueInitExpr *E) { | |
| TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); | |
| if (!T) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| T == E->getTypeSourceInfo()) | |
| return E; | |
| return getDerived().RebuildCXXScalarValueInitExpr(T, | |
| /*FIXME:*/T->getTypeLoc().getEndLoc(), | |
| E->getRParenLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { | |
| // Transform the type that we're allocating | |
| TypeSourceInfo *AllocTypeInfo = | |
| getDerived().TransformTypeWithDeducedTST(E->getAllocatedTypeSourceInfo()); | |
| if (!AllocTypeInfo) | |
| return ExprError(); | |
| // Transform the size of the array we're allocating (if any). | |
| std::optional<Expr *> ArraySize; | |
| if (E->isArray()) { | |
| ExprResult NewArraySize; | |
| if (std::optional<Expr *> OldArraySize = E->getArraySize()) { | |
| NewArraySize = getDerived().TransformExpr(*OldArraySize); | |
| if (NewArraySize.isInvalid()) | |
| return ExprError(); | |
| } | |
| ArraySize = NewArraySize.get(); | |
| } | |
| // Transform the placement arguments (if any). | |
| bool ArgumentChanged = false; | |
| SmallVector<Expr*, 8> PlacementArgs; | |
| if (getDerived().TransformExprs(E->getPlacementArgs(), | |
| E->getNumPlacementArgs(), true, | |
| PlacementArgs, &ArgumentChanged)) | |
| return ExprError(); | |
| // Transform the initializer (if any). | |
| Expr *OldInit = E->getInitializer(); | |
| ExprResult NewInit; | |
| if (OldInit) | |
| NewInit = getDerived().TransformInitializer(OldInit, true); | |
| if (NewInit.isInvalid()) | |
| return ExprError(); | |
| // Transform new operator and delete operator. | |
| FunctionDecl *OperatorNew = nullptr; | |
| if (E->getOperatorNew()) { | |
| OperatorNew = cast_or_null<FunctionDecl>( | |
| getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorNew())); | |
| if (!OperatorNew) | |
| return ExprError(); | |
| } | |
| FunctionDecl *OperatorDelete = nullptr; | |
| if (E->getOperatorDelete()) { | |
| OperatorDelete = cast_or_null<FunctionDecl>( | |
| getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorDelete())); | |
| if (!OperatorDelete) | |
| return ExprError(); | |
| } | |
| if (!getDerived().AlwaysRebuild() && | |
| AllocTypeInfo == E->getAllocatedTypeSourceInfo() && | |
| ArraySize == E->getArraySize() && | |
| NewInit.get() == OldInit && | |
| OperatorNew == E->getOperatorNew() && | |
| OperatorDelete == E->getOperatorDelete() && | |
| !ArgumentChanged) { | |
| // Mark any declarations we need as referenced. | |
| // FIXME: instantiation-specific. | |
| if (OperatorNew) | |
| SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorNew); | |
| if (OperatorDelete) | |
| SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorDelete); | |
| if (E->isArray() && !E->getAllocatedType()->isDependentType()) { | |
| QualType ElementType | |
| = SemaRef.Context.getBaseElementType(E->getAllocatedType()); | |
| if (CXXRecordDecl *Record = ElementType->getAsCXXRecordDecl()) { | |
| if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(Record)) | |
| SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Destructor); | |
| } | |
| } | |
| return E; | |
| } | |
| QualType AllocType = AllocTypeInfo->getType(); | |
| if (!ArraySize) { | |
| // If no array size was specified, but the new expression was | |
| // instantiated with an array type (e.g., "new T" where T is | |
| // instantiated with "int[4]"), extract the outer bound from the | |
| // array type as our array size. We do this with constant and | |
| // dependently-sized array types. | |
| const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType); | |
| if (!ArrayT) { | |
| // Do nothing | |
| } else if (const ConstantArrayType *ConsArrayT | |
| = dyn_cast<ConstantArrayType>(ArrayT)) { | |
| ArraySize = IntegerLiteral::Create(SemaRef.Context, ConsArrayT->getSize(), | |
| SemaRef.Context.getSizeType(), | |
| /*FIXME:*/ E->getBeginLoc()); | |
| AllocType = ConsArrayT->getElementType(); | |
| } else if (const DependentSizedArrayType *DepArrayT | |
| = dyn_cast<DependentSizedArrayType>(ArrayT)) { | |
| if (DepArrayT->getSizeExpr()) { | |
| ArraySize = DepArrayT->getSizeExpr(); | |
| AllocType = DepArrayT->getElementType(); | |
| } | |
| } | |
| } | |
| return getDerived().RebuildCXXNewExpr( | |
| E->getBeginLoc(), E->isGlobalNew(), | |
| /*FIXME:*/ E->getBeginLoc(), PlacementArgs, | |
| /*FIXME:*/ E->getBeginLoc(), E->getTypeIdParens(), AllocType, | |
| AllocTypeInfo, ArraySize, E->getDirectInitRange(), NewInit.get()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) { | |
| ExprResult Operand = getDerived().TransformExpr(E->getArgument()); | |
| if (Operand.isInvalid()) | |
| return ExprError(); | |
| // Transform the delete operator, if known. | |
| FunctionDecl *OperatorDelete = nullptr; | |
| if (E->getOperatorDelete()) { | |
| OperatorDelete = cast_or_null<FunctionDecl>( | |
| getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorDelete())); | |
| if (!OperatorDelete) | |
| return ExprError(); | |
| } | |
| if (!getDerived().AlwaysRebuild() && | |
| Operand.get() == E->getArgument() && | |
| OperatorDelete == E->getOperatorDelete()) { | |
| // Mark any declarations we need as referenced. | |
| // FIXME: instantiation-specific. | |
| if (OperatorDelete) | |
| SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorDelete); | |
| if (!E->getArgument()->isTypeDependent()) { | |
| QualType Destroyed = SemaRef.Context.getBaseElementType( | |
| E->getDestroyedType()); | |
| if (auto *Record = Destroyed->getAsCXXRecordDecl()) | |
| SemaRef.MarkFunctionReferenced(E->getBeginLoc(), | |
| SemaRef.LookupDestructor(Record)); | |
| } | |
| return E; | |
| } | |
| return getDerived().RebuildCXXDeleteExpr( | |
| E->getBeginLoc(), E->isGlobalDelete(), E->isArrayForm(), Operand.get()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( | |
| CXXPseudoDestructorExpr *E) { | |
| ExprResult Base = getDerived().TransformExpr(E->getBase()); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| ParsedType ObjectTypePtr; | |
| bool MayBePseudoDestructor = false; | |
| Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(), | |
| E->getOperatorLoc(), | |
| E->isArrow()? tok::arrow : tok::period, | |
| ObjectTypePtr, | |
| MayBePseudoDestructor); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| QualType ObjectType = ObjectTypePtr.get(); | |
| NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc(); | |
| if (QualifierLoc) { | |
| QualifierLoc | |
| = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType); | |
| if (!QualifierLoc) | |
| return ExprError(); | |
| } | |
| CXXScopeSpec SS; | |
| SS.Adopt(QualifierLoc); | |
| PseudoDestructorTypeStorage Destroyed; | |
| if (E->getDestroyedTypeInfo()) { | |
| TypeSourceInfo *DestroyedTypeInfo = getDerived().TransformTypeInObjectScope( | |
| E->getDestroyedTypeInfo(), ObjectType, | |
| /*FirstQualifierInScope=*/nullptr); | |
| if (!DestroyedTypeInfo) | |
| return ExprError(); | |
| Destroyed = DestroyedTypeInfo; | |
| } else if (!ObjectType.isNull() && ObjectType->isDependentType()) { | |
| // We aren't likely to be able to resolve the identifier down to a type | |
| // now anyway, so just retain the identifier. | |
| Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(), | |
| E->getDestroyedTypeLoc()); | |
| } else { | |
| // Look for a destructor known with the given name. | |
| ParsedType T = SemaRef.getDestructorName( | |
| *E->getDestroyedTypeIdentifier(), E->getDestroyedTypeLoc(), | |
| /*Scope=*/nullptr, SS, ObjectTypePtr, false); | |
| if (!T) | |
| return ExprError(); | |
| Destroyed | |
| = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T), | |
| E->getDestroyedTypeLoc()); | |
| } | |
| TypeSourceInfo *ScopeTypeInfo = nullptr; | |
| if (E->getScopeTypeInfo()) { | |
| ScopeTypeInfo = getDerived().TransformTypeInObjectScope( | |
| E->getScopeTypeInfo(), ObjectType, nullptr); | |
| if (!ScopeTypeInfo) | |
| return ExprError(); | |
| } | |
| return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(), | |
| E->getOperatorLoc(), | |
| E->isArrow(), | |
| SS, | |
| ScopeTypeInfo, | |
| E->getColonColonLoc(), | |
| E->getTildeLoc(), | |
| Destroyed); | |
| } | |
| template <typename Derived> | |
| bool TreeTransform<Derived>::TransformOverloadExprDecls(OverloadExpr *Old, | |
| bool RequiresADL, | |
| LookupResult &R) { | |
| // Transform all the decls. | |
| bool AllEmptyPacks = true; | |
| for (auto *OldD : Old->decls()) { | |
| Decl *InstD = getDerived().TransformDecl(Old->getNameLoc(), OldD); | |
| if (!InstD) { | |
| // Silently ignore these if a UsingShadowDecl instantiated to nothing. | |
| // This can happen because of dependent hiding. | |
| if (isa<UsingShadowDecl>(OldD)) | |
| continue; | |
| else { | |
| R.clear(); | |
| return true; | |
| } | |
| } | |
| // Expand using pack declarations. | |
| NamedDecl *SingleDecl = cast<NamedDecl>(InstD); | |
| ArrayRef<NamedDecl*> Decls = SingleDecl; | |
| if (auto *UPD = dyn_cast<UsingPackDecl>(InstD)) | |
| Decls = UPD->expansions(); | |
| // Expand using declarations. | |
| for (auto *D : Decls) { | |
| if (auto *UD = dyn_cast<UsingDecl>(D)) { | |
| for (auto *SD : UD->shadows()) | |
| R.addDecl(SD); | |
| } else { | |
| R.addDecl(D); | |
| } | |
| } | |
| AllEmptyPacks &= Decls.empty(); | |
| } | |
| // C++ [temp.res]/8.4.2: | |
| // The program is ill-formed, no diagnostic required, if [...] lookup for | |
| // a name in the template definition found a using-declaration, but the | |
| // lookup in the corresponding scope in the instantiation odoes not find | |
| // any declarations because the using-declaration was a pack expansion and | |
| // the corresponding pack is empty | |
| if (AllEmptyPacks && !RequiresADL) { | |
| getSema().Diag(Old->getNameLoc(), diag::err_using_pack_expansion_empty) | |
| << isa<UnresolvedMemberExpr>(Old) << Old->getName(); | |
| return true; | |
| } | |
| // Resolve a kind, but don't do any further analysis. If it's | |
| // ambiguous, the callee needs to deal with it. | |
| R.resolveKind(); | |
| if (Old->hasTemplateKeyword() && !R.empty()) { | |
| NamedDecl *FoundDecl = R.getRepresentativeDecl()->getUnderlyingDecl(); | |
| getSema().FilterAcceptableTemplateNames(R, | |
| /*AllowFunctionTemplates=*/true, | |
| /*AllowDependent=*/true); | |
| if (R.empty()) { | |
| // If a 'template' keyword was used, a lookup that finds only non-template | |
| // names is an error. | |
| getSema().Diag(R.getNameLoc(), | |
| diag::err_template_kw_refers_to_non_template) | |
| << R.getLookupName() << Old->getQualifierLoc().getSourceRange() | |
| << Old->hasTemplateKeyword() << Old->getTemplateKeywordLoc(); | |
| getSema().Diag(FoundDecl->getLocation(), | |
| diag::note_template_kw_refers_to_non_template) | |
| << R.getLookupName(); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformUnresolvedLookupExpr( | |
| UnresolvedLookupExpr *Old) { | |
| return TransformUnresolvedLookupExpr(Old, /*IsAddressOfOperand=*/false); | |
| } | |
| template <typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformUnresolvedLookupExpr(UnresolvedLookupExpr *Old, | |
| bool IsAddressOfOperand) { | |
| LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(), | |
| Sema::LookupOrdinaryName); | |
| // Transform the declaration set. | |
| if (TransformOverloadExprDecls(Old, Old->requiresADL(), R)) | |
| return ExprError(); | |
| // Rebuild the nested-name qualifier, if present. | |
| CXXScopeSpec SS; | |
| if (Old->getQualifierLoc()) { | |
| NestedNameSpecifierLoc QualifierLoc | |
| = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc()); | |
| if (!QualifierLoc) | |
| return ExprError(); | |
| SS.Adopt(QualifierLoc); | |
| } | |
| if (Old->getNamingClass()) { | |
| CXXRecordDecl *NamingClass | |
| = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( | |
| Old->getNameLoc(), | |
| Old->getNamingClass())); | |
| if (!NamingClass) { | |
| R.clear(); | |
| return ExprError(); | |
| } | |
| R.setNamingClass(NamingClass); | |
| } | |
| // Rebuild the template arguments, if any. | |
| SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc(); | |
| TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc()); | |
| if (Old->hasExplicitTemplateArgs() && | |
| getDerived().TransformTemplateArguments(Old->getTemplateArgs(), | |
| Old->getNumTemplateArgs(), | |
| TransArgs)) { | |
| R.clear(); | |
| return ExprError(); | |
| } | |
| // An UnresolvedLookupExpr can refer to a class member. This occurs e.g. when | |
| // a non-static data member is named in an unevaluated operand, or when | |
| // a member is named in a dependent class scope function template explicit | |
| // specialization that is neither declared static nor with an explicit object | |
| // parameter. | |
| if (SemaRef.isPotentialImplicitMemberAccess(SS, R, IsAddressOfOperand)) | |
| return SemaRef.BuildPossibleImplicitMemberExpr( | |
| SS, TemplateKWLoc, R, | |
| Old->hasExplicitTemplateArgs() ? &TransArgs : nullptr, | |
| /*S=*/nullptr); | |
| // If we have neither explicit template arguments, nor the template keyword, | |
| // it's a normal declaration name or member reference. | |
| if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid()) | |
| return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL()); | |
| // If we have template arguments, then rebuild the template-id expression. | |
| return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R, | |
| Old->requiresADL(), &TransArgs); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) { | |
| bool ArgChanged = false; | |
| SmallVector<TypeSourceInfo *, 4> Args; | |
| for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { | |
| TypeSourceInfo *From = E->getArg(I); | |
| TypeLoc FromTL = From->getTypeLoc(); | |
| if (!FromTL.getAs<PackExpansionTypeLoc>()) { | |
| TypeLocBuilder TLB; | |
| TLB.reserve(FromTL.getFullDataSize()); | |
| QualType To = getDerived().TransformType(TLB, FromTL); | |
| if (To.isNull()) | |
| return ExprError(); | |
| if (To == From->getType()) | |
| Args.push_back(From); | |
| else { | |
| Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); | |
| ArgChanged = true; | |
| } | |
| continue; | |
| } | |
| ArgChanged = true; | |
| // We have a pack expansion. Instantiate it. | |
| PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>(); | |
| TypeLoc PatternTL = ExpansionTL.getPatternLoc(); | |
| SmallVector<UnexpandedParameterPack, 2> Unexpanded; | |
| SemaRef.collectUnexpandedParameterPacks(PatternTL, Unexpanded); | |
| // Determine whether the set of unexpanded parameter packs can and should | |
| // be expanded. | |
| bool Expand = true; | |
| bool RetainExpansion = false; | |
| UnsignedOrNone OrigNumExpansions = | |
| ExpansionTL.getTypePtr()->getNumExpansions(); | |
| UnsignedOrNone NumExpansions = OrigNumExpansions; | |
| if (getDerived().TryExpandParameterPacks( | |
| ExpansionTL.getEllipsisLoc(), PatternTL.getSourceRange(), | |
| Unexpanded, /*FailOnPackProducingTemplates=*/true, Expand, | |
| RetainExpansion, NumExpansions)) | |
| return ExprError(); | |
| if (!Expand) { | |
| // The transform has determined that we should perform a simple | |
| // transformation on the pack expansion, producing another pack | |
| // expansion. | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); | |
| TypeLocBuilder TLB; | |
| TLB.reserve(From->getTypeLoc().getFullDataSize()); | |
| QualType To = getDerived().TransformType(TLB, PatternTL); | |
| if (To.isNull()) | |
| return ExprError(); | |
| To = getDerived().RebuildPackExpansionType(To, | |
| PatternTL.getSourceRange(), | |
| ExpansionTL.getEllipsisLoc(), | |
| NumExpansions); | |
| if (To.isNull()) | |
| return ExprError(); | |
| PackExpansionTypeLoc ToExpansionTL | |
| = TLB.push<PackExpansionTypeLoc>(To); | |
| ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc()); | |
| Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); | |
| continue; | |
| } | |
| // Expand the pack expansion by substituting for each argument in the | |
| // pack(s). | |
| for (unsigned I = 0; I != *NumExpansions; ++I) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex(SemaRef, I); | |
| TypeLocBuilder TLB; | |
| TLB.reserve(PatternTL.getFullDataSize()); | |
| QualType To = getDerived().TransformType(TLB, PatternTL); | |
| if (To.isNull()) | |
| return ExprError(); | |
| if (To->containsUnexpandedParameterPack()) { | |
| To = getDerived().RebuildPackExpansionType(To, | |
| PatternTL.getSourceRange(), | |
| ExpansionTL.getEllipsisLoc(), | |
| NumExpansions); | |
| if (To.isNull()) | |
| return ExprError(); | |
| PackExpansionTypeLoc ToExpansionTL | |
| = TLB.push<PackExpansionTypeLoc>(To); | |
| ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc()); | |
| } | |
| Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); | |
| } | |
| if (!RetainExpansion) | |
| continue; | |
| // If we're supposed to retain a pack expansion, do so by temporarily | |
| // forgetting the partially-substituted parameter pack. | |
| ForgetPartiallySubstitutedPackRAII Forget(getDerived()); | |
| TypeLocBuilder TLB; | |
| TLB.reserve(From->getTypeLoc().getFullDataSize()); | |
| QualType To = getDerived().TransformType(TLB, PatternTL); | |
| if (To.isNull()) | |
| return ExprError(); | |
| To = getDerived().RebuildPackExpansionType(To, | |
| PatternTL.getSourceRange(), | |
| ExpansionTL.getEllipsisLoc(), | |
| NumExpansions); | |
| if (To.isNull()) | |
| return ExprError(); | |
| PackExpansionTypeLoc ToExpansionTL | |
| = TLB.push<PackExpansionTypeLoc>(To); | |
| ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc()); | |
| Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); | |
| } | |
| if (!getDerived().AlwaysRebuild() && !ArgChanged) | |
| return E; | |
| return getDerived().RebuildTypeTrait(E->getTrait(), E->getBeginLoc(), Args, | |
| E->getEndLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformConceptSpecializationExpr( | |
| ConceptSpecializationExpr *E) { | |
| const ASTTemplateArgumentListInfo *Old = E->getTemplateArgsAsWritten(); | |
| TemplateArgumentListInfo TransArgs(Old->LAngleLoc, Old->RAngleLoc); | |
| if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(), | |
| Old->NumTemplateArgs, TransArgs)) | |
| return ExprError(); | |
| return getDerived().RebuildConceptSpecializationExpr( | |
| E->getNestedNameSpecifierLoc(), E->getTemplateKWLoc(), | |
| E->getConceptNameInfo(), E->getFoundDecl(), E->getConceptDecl(), | |
| &TransArgs); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *E) { | |
| SmallVector<ParmVarDecl*, 4> TransParams; | |
| SmallVector<QualType, 4> TransParamTypes; | |
| Sema::ExtParameterInfoBuilder ExtParamInfos; | |
| // C++2a [expr.prim.req]p2 | |
| // Expressions appearing within a requirement-body are unevaluated operands. | |
| EnterExpressionEvaluationContext Ctx( | |
| SemaRef, Sema::ExpressionEvaluationContext::Unevaluated, | |
| Sema::ReuseLambdaContextDecl); | |
| RequiresExprBodyDecl *Body = RequiresExprBodyDecl::Create( | |
| getSema().Context, getSema().CurContext, | |
| E->getBody()->getBeginLoc()); | |
| Sema::ContextRAII SavedContext(getSema(), Body, /*NewThisContext*/false); | |
| ExprResult TypeParamResult = getDerived().TransformRequiresTypeParams( | |
| E->getRequiresKWLoc(), E->getRBraceLoc(), E, Body, | |
| E->getLocalParameters(), TransParamTypes, TransParams, ExtParamInfos); | |
| for (ParmVarDecl *Param : TransParams) | |
| if (Param) | |
| Param->setDeclContext(Body); | |
| // On failure to transform, TransformRequiresTypeParams returns an expression | |
| // in the event that the transformation of the type params failed in some way. | |
| // It is expected that this will result in a 'not satisfied' Requires clause | |
| // when instantiating. | |
| if (!TypeParamResult.isUnset()) | |
| return TypeParamResult; | |
| SmallVector<concepts::Requirement *, 4> TransReqs; | |
| if (getDerived().TransformRequiresExprRequirements(E->getRequirements(), | |
| TransReqs)) | |
| return ExprError(); | |
| for (concepts::Requirement *Req : TransReqs) { | |
| if (auto *ER = dyn_cast<concepts::ExprRequirement>(Req)) { | |
| if (ER->getReturnTypeRequirement().isTypeConstraint()) { | |
| ER->getReturnTypeRequirement() | |
| .getTypeConstraintTemplateParameterList()->getParam(0) | |
| ->setDeclContext(Body); | |
| } | |
| } | |
| } | |
| return getDerived().RebuildRequiresExpr( | |
| E->getRequiresKWLoc(), Body, E->getLParenLoc(), TransParams, | |
| E->getRParenLoc(), TransReqs, E->getRBraceLoc()); | |
| } | |
| template<typename Derived> | |
| bool TreeTransform<Derived>::TransformRequiresExprRequirements( | |
| ArrayRef<concepts::Requirement *> Reqs, | |
| SmallVectorImpl<concepts::Requirement *> &Transformed) { | |
| for (concepts::Requirement *Req : Reqs) { | |
| concepts::Requirement *TransReq = nullptr; | |
| if (auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req)) | |
| TransReq = getDerived().TransformTypeRequirement(TypeReq); | |
| else if (auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req)) | |
| TransReq = getDerived().TransformExprRequirement(ExprReq); | |
| else | |
| TransReq = getDerived().TransformNestedRequirement( | |
| cast<concepts::NestedRequirement>(Req)); | |
| if (!TransReq) | |
| return true; | |
| Transformed.push_back(TransReq); | |
| } | |
| return false; | |
| } | |
| template<typename Derived> | |
| concepts::TypeRequirement * | |
| TreeTransform<Derived>::TransformTypeRequirement( | |
| concepts::TypeRequirement *Req) { | |
| if (Req->isSubstitutionFailure()) { | |
| if (getDerived().AlwaysRebuild()) | |
| return getDerived().RebuildTypeRequirement( | |
| Req->getSubstitutionDiagnostic()); | |
| return Req; | |
| } | |
| TypeSourceInfo *TransType = getDerived().TransformType(Req->getType()); | |
| if (!TransType) | |
| return nullptr; | |
| return getDerived().RebuildTypeRequirement(TransType); | |
| } | |
| template<typename Derived> | |
| concepts::ExprRequirement * | |
| TreeTransform<Derived>::TransformExprRequirement(concepts::ExprRequirement *Req) { | |
| llvm::PointerUnion<Expr *, concepts::Requirement::SubstitutionDiagnostic *> TransExpr; | |
| if (Req->isExprSubstitutionFailure()) | |
| TransExpr = Req->getExprSubstitutionDiagnostic(); | |
| else { | |
| ExprResult TransExprRes = getDerived().TransformExpr(Req->getExpr()); | |
| if (TransExprRes.isUsable() && TransExprRes.get()->hasPlaceholderType()) | |
| TransExprRes = SemaRef.CheckPlaceholderExpr(TransExprRes.get()); | |
| if (TransExprRes.isInvalid()) | |
| return nullptr; | |
| TransExpr = TransExprRes.get(); | |
| } | |
| std::optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq; | |
| const auto &RetReq = Req->getReturnTypeRequirement(); | |
| if (RetReq.isEmpty()) | |
| TransRetReq.emplace(); | |
| else if (RetReq.isSubstitutionFailure()) | |
| TransRetReq.emplace(RetReq.getSubstitutionDiagnostic()); | |
| else if (RetReq.isTypeConstraint()) { | |
| TemplateParameterList *OrigTPL = | |
| RetReq.getTypeConstraintTemplateParameterList(); | |
| TemplateParameterList *TPL = | |
| getDerived().TransformTemplateParameterList(OrigTPL); | |
| if (!TPL) | |
| return nullptr; | |
| TransRetReq.emplace(TPL); | |
| } | |
| assert(TransRetReq && "All code paths leading here must set TransRetReq"); | |
| if (Expr *E = dyn_cast<Expr *>(TransExpr)) | |
| return getDerived().RebuildExprRequirement(E, Req->isSimple(), | |
| Req->getNoexceptLoc(), | |
| std::move(*TransRetReq)); | |
| return getDerived().RebuildExprRequirement( | |
| cast<concepts::Requirement::SubstitutionDiagnostic *>(TransExpr), | |
| Req->isSimple(), Req->getNoexceptLoc(), std::move(*TransRetReq)); | |
| } | |
| template<typename Derived> | |
| concepts::NestedRequirement * | |
| TreeTransform<Derived>::TransformNestedRequirement( | |
| concepts::NestedRequirement *Req) { | |
| if (Req->hasInvalidConstraint()) { | |
| if (getDerived().AlwaysRebuild()) | |
| return getDerived().RebuildNestedRequirement( | |
| Req->getInvalidConstraintEntity(), Req->getConstraintSatisfaction()); | |
| return Req; | |
| } | |
| ExprResult TransConstraint = | |
| getDerived().TransformExpr(Req->getConstraintExpr()); | |
| if (TransConstraint.isInvalid()) | |
| return nullptr; | |
| return getDerived().RebuildNestedRequirement(TransConstraint.get()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { | |
| TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo()); | |
| if (!T) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| T == E->getQueriedTypeSourceInfo()) | |
| return E; | |
| ExprResult SubExpr; | |
| { | |
| EnterExpressionEvaluationContext Unevaluated( | |
| SemaRef, Sema::ExpressionEvaluationContext::Unevaluated); | |
| SubExpr = getDerived().TransformExpr(E->getDimensionExpression()); | |
| if (SubExpr.isInvalid()) | |
| return ExprError(); | |
| } | |
| return getDerived().RebuildArrayTypeTrait(E->getTrait(), E->getBeginLoc(), T, | |
| SubExpr.get(), E->getEndLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) { | |
| ExprResult SubExpr; | |
| { | |
| EnterExpressionEvaluationContext Unevaluated( | |
| SemaRef, Sema::ExpressionEvaluationContext::Unevaluated); | |
| SubExpr = getDerived().TransformExpr(E->getQueriedExpression()); | |
| if (SubExpr.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression()) | |
| return E; | |
| } | |
| return getDerived().RebuildExpressionTrait(E->getTrait(), E->getBeginLoc(), | |
| SubExpr.get(), E->getEndLoc()); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformParenDependentScopeDeclRefExpr( | |
| ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool AddrTaken, | |
| TypeSourceInfo **RecoveryTSI) { | |
| ExprResult NewDRE = getDerived().TransformDependentScopeDeclRefExpr( | |
| DRE, AddrTaken, RecoveryTSI); | |
| // Propagate both errors and recovered types, which return ExprEmpty. | |
| if (!NewDRE.isUsable()) | |
| return NewDRE; | |
| // We got an expr, wrap it up in parens. | |
| if (!getDerived().AlwaysRebuild() && NewDRE.get() == DRE) | |
| return PE; | |
| return getDerived().RebuildParenExpr(NewDRE.get(), PE->getLParen(), | |
| PE->getRParen()); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( | |
| DependentScopeDeclRefExpr *E) { | |
| return TransformDependentScopeDeclRefExpr(E, /*IsAddressOfOperand=*/false, | |
| nullptr); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( | |
| DependentScopeDeclRefExpr *E, bool IsAddressOfOperand, | |
| TypeSourceInfo **RecoveryTSI) { | |
| assert(E->getQualifierLoc()); | |
| NestedNameSpecifierLoc QualifierLoc = | |
| getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); | |
| if (!QualifierLoc) | |
| return ExprError(); | |
| SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc(); | |
| // TODO: If this is a conversion-function-id, verify that the | |
| // destination type name (if present) resolves the same way after | |
| // instantiation as it did in the local scope. | |
| DeclarationNameInfo NameInfo = | |
| getDerived().TransformDeclarationNameInfo(E->getNameInfo()); | |
| if (!NameInfo.getName()) | |
| return ExprError(); | |
| if (!E->hasExplicitTemplateArgs()) { | |
| if (!getDerived().AlwaysRebuild() && QualifierLoc == E->getQualifierLoc() && | |
| // Note: it is sufficient to compare the Name component of NameInfo: | |
| // if name has not changed, DNLoc has not changed either. | |
| NameInfo.getName() == E->getDeclName()) | |
| return E; | |
| return getDerived().RebuildDependentScopeDeclRefExpr( | |
| QualifierLoc, TemplateKWLoc, NameInfo, /*TemplateArgs=*/nullptr, | |
| IsAddressOfOperand, RecoveryTSI); | |
| } | |
| TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); | |
| if (getDerived().TransformTemplateArguments( | |
| E->getTemplateArgs(), E->getNumTemplateArgs(), TransArgs)) | |
| return ExprError(); | |
| return getDerived().RebuildDependentScopeDeclRefExpr( | |
| QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand, | |
| RecoveryTSI); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { | |
| // CXXConstructExprs other than for list-initialization and | |
| // CXXTemporaryObjectExpr are always implicit, so when we have | |
| // a 1-argument construction we just transform that argument. | |
| if (getDerived().AllowSkippingCXXConstructExpr() && | |
| ((E->getNumArgs() == 1 || | |
| (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) && | |
| (!getDerived().DropCallArgument(E->getArg(0))) && | |
| !E->isListInitialization())) | |
| return getDerived().TransformInitializer(E->getArg(0), | |
| /*DirectInit*/ false); | |
| TemporaryBase Rebase(*this, /*FIXME*/ E->getBeginLoc(), DeclarationName()); | |
| QualType T = getDerived().TransformType(E->getType()); | |
| if (T.isNull()) | |
| return ExprError(); | |
| CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>( | |
| getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor())); | |
| if (!Constructor) | |
| return ExprError(); | |
| bool ArgumentChanged = false; | |
| SmallVector<Expr*, 8> Args; | |
| { | |
| EnterExpressionEvaluationContext Context( | |
| getSema(), EnterExpressionEvaluationContext::InitList, | |
| E->isListInitialization()); | |
| if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, | |
| &ArgumentChanged)) | |
| return ExprError(); | |
| } | |
| if (!getDerived().AlwaysRebuild() && | |
| T == E->getType() && | |
| Constructor == E->getConstructor() && | |
| !ArgumentChanged) { | |
| // Mark the constructor as referenced. | |
| // FIXME: Instantiation-specific | |
| SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor); | |
| return E; | |
| } | |
| return getDerived().RebuildCXXConstructExpr( | |
| T, /*FIXME:*/ E->getBeginLoc(), Constructor, E->isElidable(), Args, | |
| E->hadMultipleCandidates(), E->isListInitialization(), | |
| E->isStdInitListInitialization(), E->requiresZeroInitialization(), | |
| E->getConstructionKind(), E->getParenOrBraceRange()); | |
| } | |
| template<typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformCXXInheritedCtorInitExpr( | |
| CXXInheritedCtorInitExpr *E) { | |
| QualType T = getDerived().TransformType(E->getType()); | |
| if (T.isNull()) | |
| return ExprError(); | |
| CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>( | |
| getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor())); | |
| if (!Constructor) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| T == E->getType() && | |
| Constructor == E->getConstructor()) { | |
| // Mark the constructor as referenced. | |
| // FIXME: Instantiation-specific | |
| SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor); | |
| return E; | |
| } | |
| return getDerived().RebuildCXXInheritedCtorInitExpr( | |
| T, E->getLocation(), Constructor, | |
| E->constructsVBase(), E->inheritedFromVBase()); | |
| } | |
| /// Transform a C++ temporary-binding expression. | |
| /// | |
| /// Since CXXBindTemporaryExpr nodes are implicitly generated, we just | |
| /// transform the subexpression and return that. | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { | |
| if (auto *Dtor = E->getTemporary()->getDestructor()) | |
| SemaRef.MarkFunctionReferenced(E->getBeginLoc(), | |
| const_cast<CXXDestructorDecl *>(Dtor)); | |
| return getDerived().TransformExpr(E->getSubExpr()); | |
| } | |
| /// Transform a C++ expression that contains cleanups that should | |
| /// be run after the expression is evaluated. | |
| /// | |
| /// Since ExprWithCleanups nodes are implicitly generated, we | |
| /// just transform the subexpression and return that. | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) { | |
| return getDerived().TransformExpr(E->getSubExpr()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( | |
| CXXTemporaryObjectExpr *E) { | |
| TypeSourceInfo *T = | |
| getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo()); | |
| if (!T) | |
| return ExprError(); | |
| CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>( | |
| getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor())); | |
| if (!Constructor) | |
| return ExprError(); | |
| bool ArgumentChanged = false; | |
| SmallVector<Expr*, 8> Args; | |
| Args.reserve(E->getNumArgs()); | |
| { | |
| EnterExpressionEvaluationContext Context( | |
| getSema(), EnterExpressionEvaluationContext::InitList, | |
| E->isListInitialization()); | |
| if (TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, | |
| &ArgumentChanged)) | |
| return ExprError(); | |
| if (E->isListInitialization() && !E->isStdInitListInitialization()) { | |
| ExprResult Res = RebuildInitList(E->getBeginLoc(), Args, E->getEndLoc(), | |
| /*IsExplicit=*/true); | |
| if (Res.isInvalid()) | |
| return ExprError(); | |
| Args = {Res.get()}; | |
| } | |
| } | |
| if (!getDerived().AlwaysRebuild() && | |
| T == E->getTypeSourceInfo() && | |
| Constructor == E->getConstructor() && | |
| !ArgumentChanged) { | |
| // FIXME: Instantiation-specific | |
| SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor); | |
| return SemaRef.MaybeBindToTemporary(E); | |
| } | |
| SourceLocation LParenLoc = T->getTypeLoc().getEndLoc(); | |
| return getDerived().RebuildCXXTemporaryObjectExpr( | |
| T, LParenLoc, Args, E->getEndLoc(), E->isListInitialization()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { | |
| // Transform any init-capture expressions before entering the scope of the | |
| // lambda body, because they are not semantically within that scope. | |
| typedef std::pair<ExprResult, QualType> InitCaptureInfoTy; | |
| struct TransformedInitCapture { | |
| // The location of the ... if the result is retaining a pack expansion. | |
| SourceLocation EllipsisLoc; | |
| // Zero or more expansions of the init-capture. | |
| SmallVector<InitCaptureInfoTy, 4> Expansions; | |
| }; | |
| SmallVector<TransformedInitCapture, 4> InitCaptures; | |
| InitCaptures.resize(E->explicit_capture_end() - E->explicit_capture_begin()); | |
| for (LambdaExpr::capture_iterator C = E->capture_begin(), | |
| CEnd = E->capture_end(); | |
| C != CEnd; ++C) { | |
| if (!E->isInitCapture(C)) | |
| continue; | |
| TransformedInitCapture &Result = InitCaptures[C - E->capture_begin()]; | |
| auto *OldVD = cast<VarDecl>(C->getCapturedVar()); | |
| auto SubstInitCapture = [&](SourceLocation EllipsisLoc, | |
| UnsignedOrNone NumExpansions) { | |
| ExprResult NewExprInitResult = getDerived().TransformInitializer( | |
| OldVD->getInit(), OldVD->getInitStyle() == VarDecl::CallInit); | |
| if (NewExprInitResult.isInvalid()) { | |
| Result.Expansions.push_back(InitCaptureInfoTy(ExprError(), QualType())); | |
| return; | |
| } | |
| Expr *NewExprInit = NewExprInitResult.get(); | |
| QualType NewInitCaptureType = | |
| getSema().buildLambdaInitCaptureInitialization( | |
| C->getLocation(), C->getCaptureKind() == LCK_ByRef, | |
| EllipsisLoc, NumExpansions, OldVD->getIdentifier(), | |
| cast<VarDecl>(C->getCapturedVar())->getInitStyle() != | |
| VarDecl::CInit, | |
| NewExprInit); | |
| Result.Expansions.push_back( | |
| InitCaptureInfoTy(NewExprInit, NewInitCaptureType)); | |
| }; | |
| // If this is an init-capture pack, consider expanding the pack now. | |
| if (OldVD->isParameterPack()) { | |
| PackExpansionTypeLoc ExpansionTL = OldVD->getTypeSourceInfo() | |
| ->getTypeLoc() | |
| .castAs<PackExpansionTypeLoc>(); | |
| SmallVector<UnexpandedParameterPack, 2> Unexpanded; | |
| SemaRef.collectUnexpandedParameterPacks(OldVD->getInit(), Unexpanded); | |
| // Determine whether the set of unexpanded parameter packs can and should | |
| // be expanded. | |
| bool Expand = true; | |
| bool RetainExpansion = false; | |
| UnsignedOrNone OrigNumExpansions = | |
| ExpansionTL.getTypePtr()->getNumExpansions(); | |
| UnsignedOrNone NumExpansions = OrigNumExpansions; | |
| if (getDerived().TryExpandParameterPacks( | |
| ExpansionTL.getEllipsisLoc(), OldVD->getInit()->getSourceRange(), | |
| Unexpanded, /*FailOnPackProducingTemplates=*/true, Expand, | |
| RetainExpansion, NumExpansions)) | |
| return ExprError(); | |
| assert(!RetainExpansion && "Should not need to retain expansion after a " | |
| "capture since it cannot be extended"); | |
| if (Expand) { | |
| for (unsigned I = 0; I != *NumExpansions; ++I) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); | |
| SubstInitCapture(SourceLocation(), std::nullopt); | |
| } | |
| } else { | |
| SubstInitCapture(ExpansionTL.getEllipsisLoc(), NumExpansions); | |
| Result.EllipsisLoc = ExpansionTL.getEllipsisLoc(); | |
| } | |
| } else { | |
| SubstInitCapture(SourceLocation(), std::nullopt); | |
| } | |
| } | |
| LambdaScopeInfo *LSI = getSema().PushLambdaScope(); | |
| Sema::FunctionScopeRAII FuncScopeCleanup(getSema()); | |
| // Create the local class that will describe the lambda. | |
| // FIXME: DependencyKind below is wrong when substituting inside a templated | |
| // context that isn't a DeclContext (such as a variable template), or when | |
| // substituting an unevaluated lambda inside of a function's parameter's type | |
| // - as parameter types are not instantiated from within a function's DC. We | |
| // use evaluation contexts to distinguish the function parameter case. | |
| CXXRecordDecl::LambdaDependencyKind DependencyKind = | |
| CXXRecordDecl::LDK_Unknown; | |
| DeclContext *DC = getSema().CurContext; | |
| // A RequiresExprBodyDecl is not interesting for dependencies. | |
| // For the following case, | |
| // | |
| // template <typename> | |
| // concept C = requires { [] {}; }; | |
| // | |
| // template <class F> | |
| // struct Widget; | |
| // | |
| // template <C F> | |
| // struct Widget<F> {}; | |
| // | |
| // While we are substituting Widget<F>, the parent of DC would be | |
| // the template specialization itself. Thus, the lambda expression | |
| // will be deemed as dependent even if there are no dependent template | |
| // arguments. | |
| // (A ClassTemplateSpecializationDecl is always a dependent context.) | |
| while (DC->isRequiresExprBody() || isa<CXXExpansionStmtDecl>(DC)) | |
| DC = DC->getParent(); | |
| if ((getSema().isUnevaluatedContext() || | |
| getSema().isConstantEvaluatedContext()) && | |
| !(dyn_cast_or_null<CXXRecordDecl>(DC->getParent()) && | |
| cast<CXXRecordDecl>(DC->getParent())->isGenericLambda()) && | |
| (DC->isFileContext() || !DC->getParent()->isDependentContext())) | |
| DependencyKind = CXXRecordDecl::LDK_NeverDependent; | |
| CXXRecordDecl *OldClass = E->getLambdaClass(); | |
| CXXRecordDecl *Class = getSema().createLambdaClosureType( | |
| E->getIntroducerRange(), /*Info=*/nullptr, DependencyKind, | |
| E->getCaptureDefault()); | |
| getDerived().transformedLocalDecl(OldClass, {Class}); | |
| CXXMethodDecl *NewCallOperator = | |
| getSema().CreateLambdaCallOperator(E->getIntroducerRange(), Class); | |
| // Enter the scope of the lambda. | |
| getSema().buildLambdaScope(LSI, NewCallOperator, E->getIntroducerRange(), | |
| E->getCaptureDefault(), E->getCaptureDefaultLoc(), | |
| E->hasExplicitParameters(), E->isMutable()); | |
| // Introduce the context of the call operator. | |
| Sema::ContextRAII SavedContext(getSema(), NewCallOperator, | |
| /*NewThisContext*/false); | |
| bool Invalid = false; | |
| // Transform captures. | |
| for (LambdaExpr::capture_iterator C = E->capture_begin(), | |
| CEnd = E->capture_end(); | |
| C != CEnd; ++C) { | |
| // When we hit the first implicit capture, tell Sema that we've finished | |
| // the list of explicit captures. | |
| if (C->isImplicit()) | |
| break; | |
| // Capturing 'this' is trivial. | |
| if (C->capturesThis()) { | |
| // If this is a lambda that is part of a default member initialiser | |
| // and which we're instantiating outside the class that 'this' is | |
| // supposed to refer to, adjust the type of 'this' accordingly. | |
| // | |
| // Otherwise, leave the type of 'this' as-is. | |
| Sema::CXXThisScopeRAII ThisScope( | |
| getSema(), | |
| dyn_cast_if_present<CXXRecordDecl>( | |
| getSema().getFunctionLevelDeclContext()), | |
| Qualifiers()); | |
| getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(), | |
| /*BuildAndDiagnose*/ true, nullptr, | |
| C->getCaptureKind() == LCK_StarThis); | |
| continue; | |
| } | |
| // Captured expression will be recaptured during captured variables | |
| // rebuilding. | |
| if (C->capturesVLAType()) | |
| continue; | |
| // Rebuild init-captures, including the implied field declaration. | |
| if (E->isInitCapture(C)) { | |
| TransformedInitCapture &NewC = InitCaptures[C - E->capture_begin()]; | |
| auto *OldVD = cast<VarDecl>(C->getCapturedVar()); | |
| llvm::SmallVector<Decl*, 4> NewVDs; | |
| for (InitCaptureInfoTy &Info : NewC.Expansions) { | |
| ExprResult Init = Info.first; | |
| QualType InitQualType = Info.second; | |
| if (Init.isInvalid() || InitQualType.isNull()) { | |
| Invalid = true; | |
| break; | |
| } | |
| VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl( | |
| OldVD->getLocation(), InitQualType, NewC.EllipsisLoc, | |
| OldVD->getIdentifier(), OldVD->getInitStyle(), Init.get(), | |
| getSema().CurContext); | |
| if (!NewVD) { | |
| Invalid = true; | |
| break; | |
| } | |
| NewVDs.push_back(NewVD); | |
| getSema().addInitCapture(LSI, NewVD, C->getCaptureKind() == LCK_ByRef); | |
| // Cases we want to tackle: | |
| // ([C(Pack)] {}, ...) | |
| // But rule out cases e.g. | |
| // [...C = Pack()] {} | |
| if (NewC.EllipsisLoc.isInvalid()) | |
| LSI->ContainsUnexpandedParameterPack |= | |
| Init.get()->containsUnexpandedParameterPack(); | |
| } | |
| if (Invalid) | |
| break; | |
| getDerived().transformedLocalDecl(OldVD, NewVDs); | |
| continue; | |
| } | |
| assert(C->capturesVariable() && "unexpected kind of lambda capture"); | |
| // Determine the capture kind for Sema. | |
| TryCaptureKind Kind = C->isImplicit() ? TryCaptureKind::Implicit | |
| : C->getCaptureKind() == LCK_ByCopy | |
| ? TryCaptureKind::ExplicitByVal | |
| : TryCaptureKind::ExplicitByRef; | |
| SourceLocation EllipsisLoc; | |
| if (C->isPackExpansion()) { | |
| UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation()); | |
| bool ShouldExpand = false; | |
| bool RetainExpansion = false; | |
| UnsignedOrNone NumExpansions = std::nullopt; | |
| if (getDerived().TryExpandParameterPacks( | |
| C->getEllipsisLoc(), C->getLocation(), Unexpanded, | |
| /*FailOnPackProducingTemplates=*/true, ShouldExpand, | |
| RetainExpansion, NumExpansions)) { | |
| Invalid = true; | |
| continue; | |
| } | |
| if (ShouldExpand) { | |
| // The transform has determined that we should perform an expansion; | |
| // transform and capture each of the arguments. | |
| // expansion of the pattern. Do so. | |
| auto *Pack = cast<ValueDecl>(C->getCapturedVar()); | |
| for (unsigned I = 0; I != *NumExpansions; ++I) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); | |
| ValueDecl *CapturedVar = cast_if_present<ValueDecl>( | |
| getDerived().TransformDecl(C->getLocation(), Pack)); | |
| if (!CapturedVar) { | |
| Invalid = true; | |
| continue; | |
| } | |
| // Capture the transformed variable. | |
| getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind); | |
| } | |
| // FIXME: Retain a pack expansion if RetainExpansion is true. | |
| continue; | |
| } | |
| EllipsisLoc = C->getEllipsisLoc(); | |
| } | |
| // Transform the captured variable. | |
| auto *CapturedVar = cast_or_null<ValueDecl>( | |
| getDerived().TransformDecl(C->getLocation(), C->getCapturedVar())); | |
| if (!CapturedVar || CapturedVar->isInvalidDecl()) { | |
| Invalid = true; | |
| continue; | |
| } | |
| // This is not an init-capture; however it contains an unexpanded pack e.g. | |
| // ([Pack] {}(), ...) | |
| if (auto *VD = dyn_cast<VarDecl>(CapturedVar); VD && !C->isPackExpansion()) | |
| LSI->ContainsUnexpandedParameterPack |= VD->isParameterPack(); | |
| // Capture the transformed variable. | |
| getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind, | |
| EllipsisLoc); | |
| } | |
| getSema().finishLambdaExplicitCaptures(LSI); | |
| // Transform the template parameters, and add them to the current | |
| // instantiation scope. The null case is handled correctly. | |
| auto TPL = getDerived().TransformTemplateParameterList( | |
| E->getTemplateParameterList()); | |
| LSI->GLTemplateParameterList = TPL; | |
| if (TPL) { | |
| getSema().AddTemplateParametersToLambdaCallOperator(NewCallOperator, Class, | |
| TPL); | |
| LSI->ContainsUnexpandedParameterPack |= | |
| TPL->containsUnexpandedParameterPack(); | |
| } | |
| TypeLocBuilder NewCallOpTLBuilder; | |
| TypeLoc OldCallOpTypeLoc = | |
| E->getCallOperator()->getTypeSourceInfo()->getTypeLoc(); | |
| QualType NewCallOpType = | |
| getDerived().TransformType(NewCallOpTLBuilder, OldCallOpTypeLoc); | |
| if (NewCallOpType.isNull()) | |
| return ExprError(); | |
| LSI->ContainsUnexpandedParameterPack |= | |
| NewCallOpType->containsUnexpandedParameterPack(); | |
| TypeSourceInfo *NewCallOpTSI = | |
| NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context, NewCallOpType); | |
| // The type may be an AttributedType or some other kind of sugar; | |
| // get the actual underlying FunctionProtoType. | |
| auto FPTL = NewCallOpTSI->getTypeLoc().getAsAdjusted<FunctionProtoTypeLoc>(); | |
| assert(FPTL && "Not a FunctionProtoType?"); | |
| AssociatedConstraint TRC = E->getCallOperator()->getTrailingRequiresClause(); | |
| if (TRC) { | |
| ExprResult E = getDerived().TransformLambdaConstraint( | |
| const_cast<Expr *>(TRC.ConstraintExpr)); | |
| if (E.isInvalid()) | |
| return E; | |
| TRC.ConstraintExpr = E.get(); | |
| } | |
| LSI->BeforeCompoundStatement = false; | |
| getSema().CompleteLambdaCallOperator( | |
| NewCallOperator, E->getCallOperator()->getLocation(), | |
| E->getCallOperator()->getInnerLocStart(), TRC, NewCallOpTSI, | |
| E->getCallOperator()->getConstexprKind(), | |
| E->getCallOperator()->getStorageClass(), FPTL.getParams(), | |
| E->hasExplicitResultType()); | |
| getDerived().transformAttrs(E->getCallOperator(), NewCallOperator); | |
| getDerived().transformedLocalDecl(E->getCallOperator(), {NewCallOperator}); | |
| { | |
| // Number the lambda for linkage purposes if necessary. | |
| Sema::ContextRAII ManglingContext(getSema(), Class->getDeclContext()); | |
| std::optional<CXXRecordDecl::LambdaNumbering> Numbering; | |
| if (getDerived().ReplacingOriginal()) { | |
| Numbering = OldClass->getLambdaNumbering(); | |
| } | |
| getSema().handleLambdaNumbering(Class, NewCallOperator, Numbering); | |
| } | |
| // FIXME: Sema's lambda-building mechanism expects us to push an expression | |
| // evaluation context even if we're not transforming the function body. | |
| getSema().PushExpressionEvaluationContextForFunction( | |
| Sema::ExpressionEvaluationContext::PotentiallyEvaluated, | |
| E->getCallOperator()); | |
| StmtResult Body; | |
| { | |
| Sema::NonSFINAEContext _(getSema()); | |
| Sema::CodeSynthesisContext C; | |
| C.Kind = clang::Sema::CodeSynthesisContext::LambdaExpressionSubstitution; | |
| C.PointOfInstantiation = E->getBody()->getBeginLoc(); | |
| getSema().pushCodeSynthesisContext(C); | |
| // Instantiate the body of the lambda expression. | |
| Body = Invalid ? StmtError() | |
| : getDerived().TransformLambdaBody(E, E->getBody()); | |
| getSema().popCodeSynthesisContext(); | |
| } | |
| // ActOnLambda* will pop the function scope for us. | |
| FuncScopeCleanup.disable(); | |
| if (Body.isInvalid()) { | |
| SavedContext.pop(); | |
| getSema().ActOnLambdaError(E->getBeginLoc(), /*CurScope=*/nullptr, | |
| /*IsInstantiation=*/true); | |
| return ExprError(); | |
| } | |
| getSema().ActOnFinishFunctionBody(NewCallOperator, Body.get(), | |
| /*IsInstantiation=*/true, | |
| /*RetainFunctionScopeInfo=*/true); | |
| SavedContext.pop(); | |
| // Recompute the dependency of the lambda so that we can defer the lambda call | |
| // construction until after we have all the necessary template arguments. For | |
| // example, given | |
| // | |
| // template <class> struct S { | |
| // template <class U> | |
| // using Type = decltype([](U){}(42.0)); | |
| // }; | |
| // void foo() { | |
| // using T = S<int>::Type<float>; | |
| // ^~~~~~ | |
| // } | |
| // | |
| // We would end up here from instantiating S<int> when ensuring its | |
| // completeness. That would transform the lambda call expression regardless of | |
| // the absence of the corresponding argument for U. | |
| // | |
| // Going ahead with unsubstituted type U makes things worse: we would soon | |
| // compare the argument type (which is float) against the parameter U | |
| // somewhere in Sema::BuildCallExpr. Then we would quickly run into a bogus | |
| // error suggesting unmatched types 'U' and 'float'! | |
| // | |
| // That said, everything will be fine if we defer that semantic checking. | |
| // Fortunately, we have such a mechanism that bypasses it if the CallExpr is | |
| // dependent. Since the CallExpr's dependency boils down to the lambda's | |
| // dependency in this case, we can harness that by recomputing the dependency | |
| // from the instantiation arguments. | |
| // | |
| // FIXME: Creating the type of a lambda requires us to have a dependency | |
| // value, which happens before its substitution. We update its dependency | |
| // *after* the substitution in case we can't decide the dependency | |
| // so early, e.g. because we want to see if any of the *substituted* | |
| // parameters are dependent. | |
| DependencyKind = getDerived().ComputeLambdaDependency(LSI); | |
| Class->setLambdaDependencyKind(DependencyKind); | |
| return getDerived().RebuildLambdaExpr(E->getBeginLoc(), | |
| Body.get()->getEndLoc(), LSI); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformLambdaBody(LambdaExpr *E, Stmt *S) { | |
| return TransformStmt(S); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::SkipLambdaBody(LambdaExpr *E, Stmt *S) { | |
| // Transform captures. | |
| for (LambdaExpr::capture_iterator C = E->capture_begin(), | |
| CEnd = E->capture_end(); | |
| C != CEnd; ++C) { | |
| // When we hit the first implicit capture, tell Sema that we've finished | |
| // the list of explicit captures. | |
| if (!C->isImplicit()) | |
| continue; | |
| // Capturing 'this' is trivial. | |
| if (C->capturesThis()) { | |
| getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(), | |
| /*BuildAndDiagnose*/ true, nullptr, | |
| C->getCaptureKind() == LCK_StarThis); | |
| continue; | |
| } | |
| // Captured expression will be recaptured during captured variables | |
| // rebuilding. | |
| if (C->capturesVLAType()) | |
| continue; | |
| assert(C->capturesVariable() && "unexpected kind of lambda capture"); | |
| assert(!E->isInitCapture(C) && "implicit init-capture?"); | |
| // Transform the captured variable. | |
| VarDecl *CapturedVar = cast_or_null<VarDecl>( | |
| getDerived().TransformDecl(C->getLocation(), C->getCapturedVar())); | |
| if (!CapturedVar || CapturedVar->isInvalidDecl()) | |
| return StmtError(); | |
| // Capture the transformed variable. | |
| getSema().tryCaptureVariable(CapturedVar, C->getLocation()); | |
| } | |
| return S; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( | |
| CXXUnresolvedConstructExpr *E) { | |
| TypeSourceInfo *T = | |
| getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo()); | |
| if (!T) | |
| return ExprError(); | |
| bool ArgumentChanged = false; | |
| SmallVector<Expr*, 8> Args; | |
| Args.reserve(E->getNumArgs()); | |
| { | |
| EnterExpressionEvaluationContext Context( | |
| getSema(), EnterExpressionEvaluationContext::InitList, | |
| E->isListInitialization()); | |
| if (getDerived().TransformExprs(E->arg_begin(), E->getNumArgs(), true, Args, | |
| &ArgumentChanged)) | |
| return ExprError(); | |
| } | |
| if (!getDerived().AlwaysRebuild() && | |
| T == E->getTypeSourceInfo() && | |
| !ArgumentChanged) | |
| return E; | |
| // FIXME: we're faking the locations of the commas | |
| return getDerived().RebuildCXXUnresolvedConstructExpr( | |
| T, E->getLParenLoc(), Args, E->getRParenLoc(), E->isListInitialization()); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformDependentTemplateIdExpr( | |
| DependentTemplateIdExpr *E) { | |
| TemplateName Name = getDerived().TransformConceptTemplateName( | |
| E->getTemplateName(), E->getNameLoc()); | |
| if (Name.isNull()) | |
| return ExprError(); | |
| TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); | |
| if (getDerived().TransformTemplateArguments( | |
| E->template_arguments().data(), E->getNumTemplateArgs(), TransArgs)) | |
| return ExprError(); | |
| TemplateDecl *TD = Name.getAsTemplateDecl(); | |
| if (!TD) | |
| return SemaRef.CheckVarOrConceptTemplateTemplateId(E->getNameInfo(), Name, | |
| &TransArgs); | |
| CXXScopeSpec SS; | |
| LookupResult R(SemaRef, E->getNameInfo(), Sema::LookupOrdinaryName); | |
| R.addDecl(TD); | |
| R.resolveKind(); | |
| return getDerived().RebuildTemplateIdExpr( | |
| SS, /*Template Keyword=*/SourceLocation(), R, | |
| /*RequiresADL=*/false, &TransArgs); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( | |
| CXXDependentScopeMemberExpr *E) { | |
| // Transform the base of the expression. | |
| ExprResult Base((Expr*) nullptr); | |
| Expr *OldBase; | |
| QualType BaseType; | |
| QualType ObjectType; | |
| if (!E->isImplicitAccess()) { | |
| OldBase = E->getBase(); | |
| Base = getDerived().TransformExpr(OldBase); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| // Start the member reference and compute the object's type. | |
| ParsedType ObjectTy; | |
| bool MayBePseudoDestructor = false; | |
| Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(), | |
| E->getOperatorLoc(), | |
| E->isArrow()? tok::arrow : tok::period, | |
| ObjectTy, | |
| MayBePseudoDestructor); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| ObjectType = ObjectTy.get(); | |
| BaseType = ((Expr*) Base.get())->getType(); | |
| } else { | |
| OldBase = nullptr; | |
| BaseType = getDerived().TransformType(E->getBaseType()); | |
| ObjectType = BaseType->castAs<PointerType>()->getPointeeType(); | |
| } | |
| // Transform the first part of the nested-name-specifier that qualifies | |
| // the member name. | |
| NamedDecl *FirstQualifierInScope | |
| = getDerived().TransformFirstQualifierInScope( | |
| E->getFirstQualifierFoundInScope(), | |
| E->getQualifierLoc().getBeginLoc()); | |
| NestedNameSpecifierLoc QualifierLoc; | |
| if (E->getQualifier()) { | |
| QualifierLoc | |
| = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(), | |
| ObjectType, | |
| FirstQualifierInScope); | |
| if (!QualifierLoc) | |
| return ExprError(); | |
| } | |
| SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc(); | |
| // TODO: If this is a conversion-function-id, verify that the | |
| // destination type name (if present) resolves the same way after | |
| // instantiation as it did in the local scope. | |
| DeclarationNameInfo NameInfo | |
| = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo()); | |
| if (!NameInfo.getName()) | |
| return ExprError(); | |
| if (!E->hasExplicitTemplateArgs()) { | |
| // This is a reference to a member without an explicitly-specified | |
| // template argument list. Optimize for this common case. | |
| if (!getDerived().AlwaysRebuild() && | |
| Base.get() == OldBase && | |
| BaseType == E->getBaseType() && | |
| QualifierLoc == E->getQualifierLoc() && | |
| NameInfo.getName() == E->getMember() && | |
| FirstQualifierInScope == E->getFirstQualifierFoundInScope()) | |
| return E; | |
| return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), | |
| BaseType, | |
| E->isArrow(), | |
| E->getOperatorLoc(), | |
| QualifierLoc, | |
| TemplateKWLoc, | |
| FirstQualifierInScope, | |
| NameInfo, | |
| /*TemplateArgs*/nullptr); | |
| } | |
| TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); | |
| if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), | |
| E->getNumTemplateArgs(), | |
| TransArgs)) | |
| return ExprError(); | |
| return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), | |
| BaseType, | |
| E->isArrow(), | |
| E->getOperatorLoc(), | |
| QualifierLoc, | |
| TemplateKWLoc, | |
| FirstQualifierInScope, | |
| NameInfo, | |
| &TransArgs); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformUnresolvedMemberExpr( | |
| UnresolvedMemberExpr *Old) { | |
| // Transform the base of the expression. | |
| ExprResult Base((Expr *)nullptr); | |
| QualType BaseType; | |
| if (!Old->isImplicitAccess()) { | |
| Base = getDerived().TransformExpr(Old->getBase()); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| Base = | |
| getSema().PerformMemberExprBaseConversion(Base.get(), Old->isArrow()); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| BaseType = Base.get()->getType(); | |
| } else { | |
| BaseType = getDerived().TransformType(Old->getBaseType()); | |
| } | |
| NestedNameSpecifierLoc QualifierLoc; | |
| if (Old->getQualifierLoc()) { | |
| QualifierLoc = | |
| getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc()); | |
| if (!QualifierLoc) | |
| return ExprError(); | |
| } | |
| SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc(); | |
| LookupResult R(SemaRef, Old->getMemberNameInfo(), Sema::LookupOrdinaryName); | |
| // Transform the declaration set. | |
| if (TransformOverloadExprDecls(Old, /*RequiresADL*/ false, R)) | |
| return ExprError(); | |
| // Determine the naming class. | |
| if (Old->getNamingClass()) { | |
| CXXRecordDecl *NamingClass = cast_or_null<CXXRecordDecl>( | |
| getDerived().TransformDecl(Old->getMemberLoc(), Old->getNamingClass())); | |
| if (!NamingClass) | |
| return ExprError(); | |
| R.setNamingClass(NamingClass); | |
| } | |
| TemplateArgumentListInfo TransArgs; | |
| if (Old->hasExplicitTemplateArgs()) { | |
| TransArgs.setLAngleLoc(Old->getLAngleLoc()); | |
| TransArgs.setRAngleLoc(Old->getRAngleLoc()); | |
| if (getDerived().TransformTemplateArguments( | |
| Old->getTemplateArgs(), Old->getNumTemplateArgs(), TransArgs)) | |
| return ExprError(); | |
| } | |
| // FIXME: to do this check properly, we will need to preserve the | |
| // first-qualifier-in-scope here, just in case we had a dependent | |
| // base (and therefore couldn't do the check) and a | |
| // nested-name-qualifier (and therefore could do the lookup). | |
| NamedDecl *FirstQualifierInScope = nullptr; | |
| return getDerived().RebuildUnresolvedMemberExpr( | |
| Base.get(), BaseType, Old->getOperatorLoc(), Old->isArrow(), QualifierLoc, | |
| TemplateKWLoc, FirstQualifierInScope, R, | |
| (Old->hasExplicitTemplateArgs() ? &TransArgs : nullptr)); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) { | |
| EnterExpressionEvaluationContext Unevaluated( | |
| SemaRef, Sema::ExpressionEvaluationContext::Unevaluated); | |
| ExprResult SubExpr = getDerived().TransformExpr(E->getOperand()); | |
| if (SubExpr.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand()) | |
| return E; | |
| return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) { | |
| ExprResult Pattern = getDerived().TransformExpr(E->getPattern()); | |
| if (Pattern.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern()) | |
| return E; | |
| return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(), | |
| E->getNumExpansions()); | |
| } | |
| template <typename Derived> | |
| UnsignedOrNone TreeTransform<Derived>::ComputeSizeOfPackExprWithoutSubstitution( | |
| ArrayRef<TemplateArgument> PackArgs) { | |
| UnsignedOrNone Result = 0u; | |
| for (const TemplateArgument &Arg : PackArgs) { | |
| if (!Arg.isPackExpansion()) { | |
| Result = *Result + 1; | |
| continue; | |
| } | |
| TemplateArgumentLoc ArgLoc; | |
| InventTemplateArgumentLoc(Arg, ArgLoc); | |
| // Find the pattern of the pack expansion. | |
| SourceLocation Ellipsis; | |
| UnsignedOrNone OrigNumExpansions = std::nullopt; | |
| TemplateArgumentLoc Pattern = | |
| getSema().getTemplateArgumentPackExpansionPattern(ArgLoc, Ellipsis, | |
| OrigNumExpansions); | |
| // Substitute under the pack expansion. Do not expand the pack (yet). | |
| TemplateArgumentLoc OutPattern; | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); | |
| if (getDerived().TransformTemplateArgument(Pattern, OutPattern, | |
| /*Uneval*/ true)) | |
| return 1u; | |
| // See if we can determine the number of arguments from the result. | |
| UnsignedOrNone NumExpansions = | |
| getSema().getFullyPackExpandedSize(OutPattern.getArgument()); | |
| if (!NumExpansions) { | |
| // No: we must be in an alias template expansion, and we're going to | |
| // need to actually expand the packs. | |
| Result = std::nullopt; | |
| break; | |
| } | |
| Result = *Result + *NumExpansions; | |
| } | |
| return Result; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { | |
| // If E is not value-dependent, then nothing will change when we transform it. | |
| // Note: This is an instantiation-centric view. | |
| if (!E->isValueDependent()) | |
| return E; | |
| EnterExpressionEvaluationContext Unevaluated( | |
| getSema(), Sema::ExpressionEvaluationContext::Unevaluated); | |
| ArrayRef<TemplateArgument> PackArgs; | |
| TemplateArgument ArgStorage; | |
| // Find the argument list to transform. | |
| if (E->isPartiallySubstituted()) { | |
| PackArgs = E->getPartialArguments(); | |
| } else if (E->isValueDependent()) { | |
| UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc()); | |
| bool ShouldExpand = false; | |
| bool RetainExpansion = false; | |
| UnsignedOrNone NumExpansions = std::nullopt; | |
| if (getDerived().TryExpandParameterPacks( | |
| E->getOperatorLoc(), E->getPackLoc(), Unexpanded, | |
| /*FailOnPackProducingTemplates=*/true, ShouldExpand, | |
| RetainExpansion, NumExpansions)) | |
| return ExprError(); | |
| // If we need to expand the pack, build a template argument from it and | |
| // expand that. | |
| if (ShouldExpand) { | |
| auto *Pack = E->getPack(); | |
| if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Pack)) { | |
| ArgStorage = getSema().Context.getPackExpansionType( | |
| getSema().Context.getTypeDeclType(TTPD), std::nullopt); | |
| } else if (auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Pack)) { | |
| ArgStorage = TemplateArgument(TemplateName(TTPD), std::nullopt); | |
| } else { | |
| auto *VD = cast<ValueDecl>(Pack); | |
| ExprResult DRE = getSema().BuildDeclRefExpr( | |
| VD, VD->getType().getNonLValueExprType(getSema().Context), | |
| VD->getType()->isReferenceType() ? VK_LValue : VK_PRValue, | |
| E->getPackLoc()); | |
| if (DRE.isInvalid()) | |
| return ExprError(); | |
| ArgStorage = TemplateArgument( | |
| new (getSema().Context) | |
| PackExpansionExpr(DRE.get(), E->getPackLoc(), std::nullopt), | |
| /*IsCanonical=*/false); | |
| } | |
| PackArgs = ArgStorage; | |
| } | |
| } | |
| // If we're not expanding the pack, just transform the decl. | |
| if (!PackArgs.size()) { | |
| auto *Pack = cast_or_null<NamedDecl>( | |
| getDerived().TransformDecl(E->getPackLoc(), E->getPack())); | |
| if (!Pack) | |
| return ExprError(); | |
| return getDerived().RebuildSizeOfPackExpr( | |
| E->getOperatorLoc(), Pack, E->getPackLoc(), E->getRParenLoc(), | |
| std::nullopt, {}); | |
| } | |
| // Try to compute the result without performing a partial substitution. | |
| UnsignedOrNone Result = | |
| getDerived().ComputeSizeOfPackExprWithoutSubstitution(PackArgs); | |
| // Common case: we could determine the number of expansions without | |
| // substituting. | |
| if (Result) | |
| return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(), | |
| E->getPackLoc(), | |
| E->getRParenLoc(), *Result, {}); | |
| TemplateArgumentListInfo TransformedPackArgs(E->getPackLoc(), | |
| E->getPackLoc()); | |
| { | |
| TemporaryBase Rebase(*this, E->getPackLoc(), getBaseEntity()); | |
| typedef TemplateArgumentLocInventIterator< | |
| Derived, const TemplateArgument*> PackLocIterator; | |
| if (TransformTemplateArguments(PackLocIterator(*this, PackArgs.begin()), | |
| PackLocIterator(*this, PackArgs.end()), | |
| TransformedPackArgs, /*Uneval*/true)) | |
| return ExprError(); | |
| } | |
| // Check whether we managed to fully-expand the pack. | |
| // FIXME: Is it possible for us to do so and not hit the early exit path? | |
| SmallVector<TemplateArgument, 8> Args; | |
| bool PartialSubstitution = false; | |
| for (auto &Loc : TransformedPackArgs.arguments()) { | |
| Args.push_back(Loc.getArgument()); | |
| if (Loc.getArgument().isPackExpansion()) | |
| PartialSubstitution = true; | |
| } | |
| if (PartialSubstitution) | |
| return getDerived().RebuildSizeOfPackExpr( | |
| E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(), | |
| std::nullopt, Args); | |
| return getDerived().RebuildSizeOfPackExpr( | |
| E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(), | |
| /*Length=*/static_cast<unsigned>(Args.size()), | |
| /*PartialArgs=*/{}); | |
| } | |
| template <typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformPackIndexingExpr(PackIndexingExpr *E) { | |
| if (!E->isValueDependent()) | |
| return E; | |
| // Transform the index | |
| ExprResult IndexExpr; | |
| { | |
| EnterExpressionEvaluationContext ConstantContext( | |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); | |
| IndexExpr = getDerived().TransformExpr(E->getIndexExpr()); | |
| if (IndexExpr.isInvalid()) | |
| return ExprError(); | |
| } | |
| SmallVector<Expr *, 5> ExpandedExprs; | |
| bool FullySubstituted = true; | |
| if (!E->expandsToEmptyPack() && E->getExpressions().empty()) { | |
| Expr *Pattern = E->getPackIdExpression(); | |
| SmallVector<UnexpandedParameterPack, 2> Unexpanded; | |
| getSema().collectUnexpandedParameterPacks(E->getPackIdExpression(), | |
| Unexpanded); | |
| assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); | |
| // Determine whether the set of unexpanded parameter packs can and should | |
| // be expanded. | |
| bool ShouldExpand = true; | |
| bool RetainExpansion = false; | |
| UnsignedOrNone OrigNumExpansions = std::nullopt, | |
| NumExpansions = std::nullopt; | |
| if (getDerived().TryExpandParameterPacks( | |
| E->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded, | |
| /*FailOnPackProducingTemplates=*/true, ShouldExpand, | |
| RetainExpansion, NumExpansions)) | |
| return true; | |
| if (!ShouldExpand) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); | |
| ExprResult Pack = getDerived().TransformExpr(Pattern); | |
| if (Pack.isInvalid()) | |
| return ExprError(); | |
| return getDerived().RebuildPackIndexingExpr( | |
| E->getEllipsisLoc(), E->getRSquareLoc(), Pack.get(), IndexExpr.get(), | |
| {}, /*FullySubstituted=*/false); | |
| } | |
| for (unsigned I = 0; I != *NumExpansions; ++I) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); | |
| ExprResult Out = getDerived().TransformExpr(Pattern); | |
| if (Out.isInvalid()) | |
| return true; | |
| if (Out.get()->containsUnexpandedParameterPack()) { | |
| Out = getDerived().RebuildPackExpansion(Out.get(), E->getEllipsisLoc(), | |
| OrigNumExpansions); | |
| if (Out.isInvalid()) | |
| return true; | |
| FullySubstituted = false; | |
| } | |
| ExpandedExprs.push_back(Out.get()); | |
| } | |
| // If we're supposed to retain a pack expansion, do so by temporarily | |
| // forgetting the partially-substituted parameter pack. | |
| if (RetainExpansion) { | |
| ForgetPartiallySubstitutedPackRAII Forget(getDerived()); | |
| ExprResult Out = getDerived().TransformExpr(Pattern); | |
| if (Out.isInvalid()) | |
| return true; | |
| Out = getDerived().RebuildPackExpansion(Out.get(), E->getEllipsisLoc(), | |
| OrigNumExpansions); | |
| if (Out.isInvalid()) | |
| return true; | |
| FullySubstituted = false; | |
| ExpandedExprs.push_back(Out.get()); | |
| } | |
| } else if (!E->expandsToEmptyPack()) { | |
| if (getDerived().TransformExprs(E->getExpressions().data(), | |
| E->getExpressions().size(), false, | |
| ExpandedExprs)) | |
| return ExprError(); | |
| } | |
| return getDerived().RebuildPackIndexingExpr( | |
| E->getEllipsisLoc(), E->getRSquareLoc(), E->getPackIdExpression(), | |
| IndexExpr.get(), ExpandedExprs, FullySubstituted); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr( | |
| SubstNonTypeTemplateParmPackExpr *E) { | |
| if (!getSema().ArgPackSubstIndex) | |
| // We aren't expanding the parameter pack, so just return ourselves. | |
| return E; | |
| TemplateArgument Pack = E->getArgumentPack(); | |
| TemplateArgument Arg = SemaRef.getPackSubstitutedTemplateArgument(Pack); | |
| return getDerived().RebuildSubstNonTypeTemplateParmExpr( | |
| E->getAssociatedDecl(), E->getParameterPack()->getPosition(), | |
| E->getParameterPack()->getType(), E->getParameterPackLocation(), Arg, | |
| SemaRef.getPackIndex(Pack), E->getFinal()); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr( | |
| SubstNonTypeTemplateParmExpr *E) { | |
| Expr *OrigReplacement = E->getReplacement()->IgnoreImplicitAsWritten(); | |
| // Insert a constant-evaluated context for the transform. | |
| // Otherwise, when a normalized constraint places the replacement inside | |
| // an unevaluated operand (e.g. decltype), entities it refers to are not | |
| // odr-used, and the constant evaluation performed by CheckTemplateArgument | |
| // below can spuriously fail for otherwise valid replacements, | |
| // e.g. when a call materializes a function parameter of class type whose | |
| // special members were never instantiated. | |
| EnterExpressionEvaluationContext ConstantEvaluated( | |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated, | |
| Sema::ReuseLambdaContextDecl, | |
| Sema::ExpressionEvaluationContextRecord::EK_TemplateArgument); | |
| ExprResult Replacement = getDerived().TransformExpr(OrigReplacement); | |
| if (Replacement.isInvalid()) | |
| return true; | |
| Decl *AssociatedDecl = | |
| getDerived().TransformDecl(E->getNameLoc(), E->getAssociatedDecl()); | |
| if (!AssociatedDecl) | |
| return true; | |
| QualType ParamType = TransformType(E->getParameterType()); | |
| if (ParamType.isNull()) | |
| return true; | |
| if (Replacement.get() == OrigReplacement && | |
| AssociatedDecl == E->getAssociatedDecl() && | |
| ParamType == E->getParameterType()) | |
| return E; | |
| if (Replacement.get() != OrigReplacement || | |
| ParamType != E->getParameterType()) { | |
| auto *Param = cast<NonTypeTemplateParmDecl>(std::get<0>( | |
| getReplacedTemplateParameter(AssociatedDecl, E->getIndex()))); | |
| // When transforming the replacement expression previously, all Sema | |
| // specific annotations, such as implicit casts, are discarded. Calling the | |
| // corresponding sema action is necessary to recover those. Otherwise, | |
| // equivalency of the result would be lost. | |
| TemplateArgument SugaredConverted, CanonicalConverted; | |
| Replacement = SemaRef.CheckTemplateArgument( | |
| Param, ParamType, Replacement.get(), SugaredConverted, | |
| CanonicalConverted, | |
| /*StrictCheck=*/false, Sema::CTAK_Specified); | |
| if (Replacement.isInvalid()) | |
| return true; | |
| } else { | |
| // Otherwise, the same expression would have been produced. | |
| Replacement = E->getReplacement(); | |
| } | |
| return getDerived().RebuildSubstNonTypeTemplateParmExpr( | |
| AssociatedDecl, E->getIndex(), ParamType, E->getNameLoc(), | |
| TemplateArgument(Replacement.get(), /*IsCanonical=*/false), | |
| E->getPackIndex(), E->getFinal()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) { | |
| // Default behavior is to do nothing with this transformation. | |
| return E; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformMaterializeTemporaryExpr( | |
| MaterializeTemporaryExpr *E) { | |
| return getDerived().TransformExpr(E->getSubExpr()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) { | |
| UnresolvedLookupExpr *Callee = nullptr; | |
| if (Expr *OldCallee = E->getCallee()) { | |
| ExprResult CalleeResult = getDerived().TransformExpr(OldCallee); | |
| if (CalleeResult.isInvalid()) | |
| return ExprError(); | |
| Callee = cast<UnresolvedLookupExpr>(CalleeResult.get()); | |
| } | |
| Expr *Pattern = E->getPattern(); | |
| SmallVector<UnexpandedParameterPack, 2> Unexpanded; | |
| getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); | |
| assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); | |
| // Determine whether the set of unexpanded parameter packs can and should | |
| // be expanded. | |
| bool Expand = true; | |
| bool RetainExpansion = false; | |
| UnsignedOrNone OrigNumExpansions = E->getNumExpansions(), | |
| NumExpansions = OrigNumExpansions; | |
| if (getDerived().TryExpandParameterPacks( | |
| E->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded, | |
| /*FailOnPackProducingTemplates=*/true, Expand, RetainExpansion, | |
| NumExpansions)) | |
| return true; | |
| if (!Expand) { | |
| // Do not expand any packs here, just transform and rebuild a fold | |
| // expression. | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); | |
| ExprResult LHS = | |
| E->getLHS() ? getDerived().TransformExpr(E->getLHS()) : ExprResult(); | |
| if (LHS.isInvalid()) | |
| return true; | |
| ExprResult RHS = | |
| E->getRHS() ? getDerived().TransformExpr(E->getRHS()) : ExprResult(); | |
| if (RHS.isInvalid()) | |
| return true; | |
| if (!getDerived().AlwaysRebuild() && | |
| LHS.get() == E->getLHS() && RHS.get() == E->getRHS()) | |
| return E; | |
| return getDerived().RebuildCXXFoldExpr( | |
| Callee, E->getBeginLoc(), LHS.get(), E->getOperator(), | |
| E->getEllipsisLoc(), RHS.get(), E->getEndLoc(), NumExpansions); | |
| } | |
| // Formally a fold expression expands to nested parenthesized expressions. | |
| // Enforce this limit to avoid creating trees so deep we can't safely traverse | |
| // them. | |
| if (NumExpansions && SemaRef.getLangOpts().BracketDepth < *NumExpansions) { | |
| SemaRef.Diag(E->getEllipsisLoc(), | |
| clang::diag::err_fold_expression_limit_exceeded) | |
| << *NumExpansions << SemaRef.getLangOpts().BracketDepth | |
| << E->getSourceRange(); | |
| SemaRef.Diag(E->getEllipsisLoc(), diag::note_bracket_depth); | |
| return ExprError(); | |
| } | |
| // The transform has determined that we should perform an elementwise | |
| // expansion of the pattern. Do so. | |
| ExprResult Result = getDerived().TransformExpr(E->getInit()); | |
| if (Result.isInvalid()) | |
| return true; | |
| bool LeftFold = E->isLeftFold(); | |
| // If we're retaining an expansion for a right fold, it is the innermost | |
| // component and takes the init (if any). | |
| if (!LeftFold && RetainExpansion) { | |
| ForgetPartiallySubstitutedPackRAII Forget(getDerived()); | |
| ExprResult Out = getDerived().TransformExpr(Pattern); | |
| if (Out.isInvalid()) | |
| return true; | |
| Result = getDerived().RebuildCXXFoldExpr( | |
| Callee, E->getBeginLoc(), Out.get(), E->getOperator(), | |
| E->getEllipsisLoc(), Result.get(), E->getEndLoc(), OrigNumExpansions); | |
| if (Result.isInvalid()) | |
| return true; | |
| } | |
| bool WarnedOnComparison = false; | |
| for (unsigned I = 0; I != *NumExpansions; ++I) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex( | |
| getSema(), LeftFold ? I : *NumExpansions - I - 1); | |
| ExprResult Out = getDerived().TransformExpr(Pattern); | |
| if (Out.isInvalid()) | |
| return true; | |
| if (Out.get()->containsUnexpandedParameterPack()) { | |
| // We still have a pack; retain a pack expansion for this slice. | |
| Result = getDerived().RebuildCXXFoldExpr( | |
| Callee, E->getBeginLoc(), LeftFold ? Result.get() : Out.get(), | |
| E->getOperator(), E->getEllipsisLoc(), | |
| LeftFold ? Out.get() : Result.get(), E->getEndLoc(), | |
| OrigNumExpansions); | |
| } else if (Result.isUsable()) { | |
| // We've got down to a single element; build a binary operator. | |
| Expr *LHS = LeftFold ? Result.get() : Out.get(); | |
| Expr *RHS = LeftFold ? Out.get() : Result.get(); | |
| if (Callee) { | |
| UnresolvedSet<16> Functions; | |
| Functions.append(Callee->decls_begin(), Callee->decls_end()); | |
| Result = getDerived().RebuildCXXOperatorCallExpr( | |
| BinaryOperator::getOverloadedOperator(E->getOperator()), | |
| E->getEllipsisLoc(), Callee->getBeginLoc(), Callee->requiresADL(), | |
| Functions, LHS, RHS); | |
| } else { | |
| Result = getDerived().RebuildBinaryOperator(E->getEllipsisLoc(), | |
| E->getOperator(), LHS, RHS, | |
| /*ForFoldExpresion=*/true); | |
| if (!WarnedOnComparison && Result.isUsable()) { | |
| if (auto *BO = dyn_cast<BinaryOperator>(Result.get()); | |
| BO && BO->isComparisonOp()) { | |
| WarnedOnComparison = true; | |
| SemaRef.Diag(BO->getBeginLoc(), | |
| diag::warn_comparison_in_fold_expression) | |
| << BO->getOpcodeStr(); | |
| } | |
| } | |
| } | |
| } else | |
| Result = Out; | |
| if (Result.isInvalid()) | |
| return true; | |
| } | |
| // If we're retaining an expansion for a left fold, it is the outermost | |
| // component and takes the complete expansion so far as its init (if any). | |
| if (LeftFold && RetainExpansion) { | |
| ForgetPartiallySubstitutedPackRAII Forget(getDerived()); | |
| ExprResult Out = getDerived().TransformExpr(Pattern); | |
| if (Out.isInvalid()) | |
| return true; | |
| Result = getDerived().RebuildCXXFoldExpr( | |
| Callee, E->getBeginLoc(), Result.get(), E->getOperator(), | |
| E->getEllipsisLoc(), Out.get(), E->getEndLoc(), OrigNumExpansions); | |
| if (Result.isInvalid()) | |
| return true; | |
| } | |
| if (ParenExpr *PE = dyn_cast_or_null<ParenExpr>(Result.get())) | |
| PE->setIsProducedByFoldExpansion(); | |
| // If we had no init and an empty pack, and we're not retaining an expansion, | |
| // then produce a fallback value or error. | |
| if (Result.isUnset()) | |
| return getDerived().RebuildEmptyCXXFoldExpr(E->getEllipsisLoc(), | |
| E->getOperator()); | |
| return Result; | |
| } | |
| template <typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXParenListInitExpr(CXXParenListInitExpr *E) { | |
| SmallVector<Expr *, 4> TransformedInits; | |
| ArrayRef<Expr *> InitExprs = E->getInitExprs(); | |
| QualType T = getDerived().TransformType(E->getType()); | |
| bool ArgChanged = false; | |
| if (getDerived().TransformExprs(InitExprs.data(), InitExprs.size(), true, | |
| TransformedInits, &ArgChanged)) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && !ArgChanged && T == E->getType()) | |
| return E; | |
| return getDerived().RebuildCXXParenListInitExpr( | |
| TransformedInits, T, E->getUserSpecifiedInitExprs().size(), | |
| E->getInitLoc(), E->getBeginLoc(), E->getEndLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformCXXStdInitializerListExpr( | |
| CXXStdInitializerListExpr *E) { | |
| return getDerived().TransformExpr(E->getSubExpr()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { | |
| return SemaRef.MaybeBindToTemporary(E); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { | |
| return E; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) { | |
| ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); | |
| if (SubExpr.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| SubExpr.get() == E->getSubExpr()) | |
| return E; | |
| return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *E) { | |
| // Transform each of the elements. | |
| SmallVector<Expr *, 8> Elements; | |
| bool ArgChanged = false; | |
| if (getDerived().TransformExprs(E->getElements(), E->getNumElements(), | |
| /*IsCall=*/false, Elements, &ArgChanged)) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && !ArgChanged) | |
| return SemaRef.MaybeBindToTemporary(E); | |
| return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(), | |
| Elements.data(), | |
| Elements.size()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformObjCDictionaryLiteral( | |
| ObjCDictionaryLiteral *E) { | |
| // Transform each of the elements. | |
| SmallVector<ObjCDictionaryElement, 8> Elements; | |
| bool ArgChanged = false; | |
| for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) { | |
| ObjCDictionaryElement OrigElement = E->getKeyValueElement(I); | |
| if (OrigElement.isPackExpansion()) { | |
| // This key/value element is a pack expansion. | |
| SmallVector<UnexpandedParameterPack, 2> Unexpanded; | |
| getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded); | |
| getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded); | |
| assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); | |
| // Determine whether the set of unexpanded parameter packs can | |
| // and should be expanded. | |
| bool Expand = true; | |
| bool RetainExpansion = false; | |
| UnsignedOrNone OrigNumExpansions = OrigElement.NumExpansions; | |
| UnsignedOrNone NumExpansions = OrigNumExpansions; | |
| SourceRange PatternRange(OrigElement.Key->getBeginLoc(), | |
| OrigElement.Value->getEndLoc()); | |
| if (getDerived().TryExpandParameterPacks( | |
| OrigElement.EllipsisLoc, PatternRange, Unexpanded, | |
| /*FailOnPackProducingTemplates=*/true, Expand, RetainExpansion, | |
| NumExpansions)) | |
| return ExprError(); | |
| if (!Expand) { | |
| // The transform has determined that we should perform a simple | |
| // transformation on the pack expansion, producing another pack | |
| // expansion. | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); | |
| ExprResult Key = getDerived().TransformExpr(OrigElement.Key); | |
| if (Key.isInvalid()) | |
| return ExprError(); | |
| if (Key.get() != OrigElement.Key) | |
| ArgChanged = true; | |
| ExprResult Value = getDerived().TransformExpr(OrigElement.Value); | |
| if (Value.isInvalid()) | |
| return ExprError(); | |
| if (Value.get() != OrigElement.Value) | |
| ArgChanged = true; | |
| ObjCDictionaryElement Expansion = { | |
| Key.get(), Value.get(), OrigElement.EllipsisLoc, NumExpansions | |
| }; | |
| Elements.push_back(Expansion); | |
| continue; | |
| } | |
| // Record right away that the argument was changed. This needs | |
| // to happen even if the array expands to nothing. | |
| ArgChanged = true; | |
| // The transform has determined that we should perform an elementwise | |
| // expansion of the pattern. Do so. | |
| for (unsigned I = 0; I != *NumExpansions; ++I) { | |
| Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); | |
| ExprResult Key = getDerived().TransformExpr(OrigElement.Key); | |
| if (Key.isInvalid()) | |
| return ExprError(); | |
| ExprResult Value = getDerived().TransformExpr(OrigElement.Value); | |
| if (Value.isInvalid()) | |
| return ExprError(); | |
| ObjCDictionaryElement Element = { | |
| Key.get(), Value.get(), SourceLocation(), NumExpansions | |
| }; | |
| // If any unexpanded parameter packs remain, we still have a | |
| // pack expansion. | |
| // FIXME: Can this really happen? | |
| if (Key.get()->containsUnexpandedParameterPack() || | |
| Value.get()->containsUnexpandedParameterPack()) | |
| Element.EllipsisLoc = OrigElement.EllipsisLoc; | |
| Elements.push_back(Element); | |
| } | |
| // FIXME: Retain a pack expansion if RetainExpansion is true. | |
| // We've finished with this pack expansion. | |
| continue; | |
| } | |
| // Transform and check key. | |
| ExprResult Key = getDerived().TransformExpr(OrigElement.Key); | |
| if (Key.isInvalid()) | |
| return ExprError(); | |
| if (Key.get() != OrigElement.Key) | |
| ArgChanged = true; | |
| // Transform and check value. | |
| ExprResult Value | |
| = getDerived().TransformExpr(OrigElement.Value); | |
| if (Value.isInvalid()) | |
| return ExprError(); | |
| if (Value.get() != OrigElement.Value) | |
| ArgChanged = true; | |
| ObjCDictionaryElement Element = {Key.get(), Value.get(), SourceLocation(), | |
| std::nullopt}; | |
| Elements.push_back(Element); | |
| } | |
| if (!getDerived().AlwaysRebuild() && !ArgChanged) | |
| return SemaRef.MaybeBindToTemporary(E); | |
| return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(), | |
| Elements); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { | |
| TypeSourceInfo *EncodedTypeInfo | |
| = getDerived().TransformType(E->getEncodedTypeSourceInfo()); | |
| if (!EncodedTypeInfo) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| EncodedTypeInfo == E->getEncodedTypeSourceInfo()) | |
| return E; | |
| return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), | |
| EncodedTypeInfo, | |
| E->getRParenLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult TreeTransform<Derived>:: | |
| TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { | |
| // This is a kind of implicit conversion, and it needs to get dropped | |
| // and recomputed for the same general reasons that ImplicitCastExprs | |
| // do, as well a more specific one: this expression is only valid when | |
| // it appears *immediately* as an argument expression. | |
| return getDerived().TransformExpr(E->getSubExpr()); | |
| } | |
| template<typename Derived> | |
| ExprResult TreeTransform<Derived>:: | |
| TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { | |
| TypeSourceInfo *TSInfo | |
| = getDerived().TransformType(E->getTypeInfoAsWritten()); | |
| if (!TSInfo) | |
| return ExprError(); | |
| ExprResult Result = getDerived().TransformExpr(E->getSubExpr()); | |
| if (Result.isInvalid()) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| TSInfo == E->getTypeInfoAsWritten() && | |
| Result.get() == E->getSubExpr()) | |
| return E; | |
| return SemaRef.ObjC().BuildObjCBridgedCast( | |
| E->getLParenLoc(), E->getBridgeKind(), E->getBridgeKeywordLoc(), TSInfo, | |
| Result.get()); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformObjCAvailabilityCheckExpr( | |
| ObjCAvailabilityCheckExpr *E) { | |
| return E; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { | |
| // Transform arguments. | |
| bool ArgChanged = false; | |
| SmallVector<Expr*, 8> Args; | |
| Args.reserve(E->getNumArgs()); | |
| if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args, | |
| &ArgChanged)) | |
| return ExprError(); | |
| if (E->getReceiverKind() == ObjCMessageExpr::Class) { | |
| // Class message: transform the receiver type. | |
| TypeSourceInfo *ReceiverTypeInfo | |
| = getDerived().TransformType(E->getClassReceiverTypeInfo()); | |
| if (!ReceiverTypeInfo) | |
| return ExprError(); | |
| // If nothing changed, just retain the existing message send. | |
| if (!getDerived().AlwaysRebuild() && | |
| ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged) | |
| return SemaRef.MaybeBindToTemporary(E); | |
| // Build a new class message send. | |
| SmallVector<SourceLocation, 16> SelLocs; | |
| E->getSelectorLocs(SelLocs); | |
| return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo, | |
| E->getSelector(), | |
| SelLocs, | |
| E->getMethodDecl(), | |
| E->getLeftLoc(), | |
| Args, | |
| E->getRightLoc()); | |
| } | |
| else if (E->getReceiverKind() == ObjCMessageExpr::SuperClass || | |
| E->getReceiverKind() == ObjCMessageExpr::SuperInstance) { | |
| if (!E->getMethodDecl()) | |
| return ExprError(); | |
| // Build a new class message send to 'super'. | |
| SmallVector<SourceLocation, 16> SelLocs; | |
| E->getSelectorLocs(SelLocs); | |
| return getDerived().RebuildObjCMessageExpr(E->getSuperLoc(), | |
| E->getSelector(), | |
| SelLocs, | |
| E->getReceiverType(), | |
| E->getMethodDecl(), | |
| E->getLeftLoc(), | |
| Args, | |
| E->getRightLoc()); | |
| } | |
| // Instance message: transform the receiver | |
| assert(E->getReceiverKind() == ObjCMessageExpr::Instance && | |
| "Only class and instance messages may be instantiated"); | |
| ExprResult Receiver | |
| = getDerived().TransformExpr(E->getInstanceReceiver()); | |
| if (Receiver.isInvalid()) | |
| return ExprError(); | |
| // If nothing changed, just retain the existing message send. | |
| if (!getDerived().AlwaysRebuild() && | |
| Receiver.get() == E->getInstanceReceiver() && !ArgChanged) | |
| return SemaRef.MaybeBindToTemporary(E); | |
| // Build a new instance message send. | |
| SmallVector<SourceLocation, 16> SelLocs; | |
| E->getSelectorLocs(SelLocs); | |
| return getDerived().RebuildObjCMessageExpr(Receiver.get(), | |
| E->getSelector(), | |
| SelLocs, | |
| E->getMethodDecl(), | |
| E->getLeftLoc(), | |
| Args, | |
| E->getRightLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { | |
| return E; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { | |
| return E; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { | |
| // Transform the base expression. | |
| ExprResult Base = getDerived().TransformExpr(E->getBase()); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| // We don't need to transform the ivar; it will never change. | |
| // If nothing changed, just retain the existing expression. | |
| if (!getDerived().AlwaysRebuild() && | |
| Base.get() == E->getBase()) | |
| return E; | |
| return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(), | |
| E->getLocation(), | |
| E->isArrow(), E->isFreeIvar()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { | |
| // 'super' and types never change. Property never changes. Just | |
| // retain the existing expression. | |
| if (!E->isObjectReceiver()) | |
| return E; | |
| // Transform the base expression. | |
| ExprResult Base = getDerived().TransformExpr(E->getBase()); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| // We don't need to transform the property; it will never change. | |
| // If nothing changed, just retain the existing expression. | |
| if (!getDerived().AlwaysRebuild() && | |
| Base.get() == E->getBase()) | |
| return E; | |
| if (E->isExplicitProperty()) | |
| return getDerived().RebuildObjCPropertyRefExpr(Base.get(), | |
| E->getExplicitProperty(), | |
| E->getLocation()); | |
| return getDerived().RebuildObjCPropertyRefExpr(Base.get(), | |
| SemaRef.Context.PseudoObjectTy, | |
| E->getImplicitPropertyGetter(), | |
| E->getImplicitPropertySetter(), | |
| E->getLocation()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { | |
| // Transform the base expression. | |
| ExprResult Base = getDerived().TransformExpr(E->getBaseExpr()); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| // Transform the key expression. | |
| ExprResult Key = getDerived().TransformExpr(E->getKeyExpr()); | |
| if (Key.isInvalid()) | |
| return ExprError(); | |
| // If nothing changed, just retain the existing expression. | |
| if (!getDerived().AlwaysRebuild() && | |
| Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr()) | |
| return E; | |
| return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(), | |
| Base.get(), Key.get(), | |
| E->getAtIndexMethodDecl(), | |
| E->setAtIndexMethodDecl()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) { | |
| // Transform the base expression. | |
| ExprResult Base = getDerived().TransformExpr(E->getBase()); | |
| if (Base.isInvalid()) | |
| return ExprError(); | |
| // If nothing changed, just retain the existing expression. | |
| if (!getDerived().AlwaysRebuild() && | |
| Base.get() == E->getBase()) | |
| return E; | |
| return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(), | |
| E->getOpLoc(), | |
| E->isArrow()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { | |
| bool ArgumentChanged = false; | |
| SmallVector<Expr*, 8> SubExprs; | |
| SubExprs.reserve(E->getNumSubExprs()); | |
| if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false, | |
| SubExprs, &ArgumentChanged)) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| !ArgumentChanged) | |
| return E; | |
| return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), | |
| SubExprs, | |
| E->getRParenLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *E) { | |
| ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr()); | |
| if (SrcExpr.isInvalid()) | |
| return ExprError(); | |
| TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo()); | |
| if (!Type) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| Type == E->getTypeSourceInfo() && | |
| SrcExpr.get() == E->getSrcExpr()) | |
| return E; | |
| return getDerived().RebuildConvertVectorExpr(E->getBuiltinLoc(), | |
| SrcExpr.get(), Type, | |
| E->getRParenLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { | |
| BlockDecl *oldBlock = E->getBlockDecl(); | |
| SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/nullptr); | |
| BlockScopeInfo *blockScope = SemaRef.getCurBlock(); | |
| blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic()); | |
| blockScope->TheDecl->setBlockMissingReturnType( | |
| oldBlock->blockMissingReturnType()); | |
| SmallVector<ParmVarDecl*, 4> params; | |
| SmallVector<QualType, 4> paramTypes; | |
| const FunctionProtoType *exprFunctionType = E->getFunctionType(); | |
| // Parameter substitution. | |
| Sema::ExtParameterInfoBuilder extParamInfos; | |
| if (getDerived().TransformFunctionTypeParams( | |
| E->getCaretLocation(), oldBlock->parameters(), nullptr, | |
| exprFunctionType->getExtParameterInfosOrNull(), paramTypes, ¶ms, | |
| extParamInfos)) { | |
| getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr); | |
| return ExprError(); | |
| } | |
| QualType exprResultType = | |
| getDerived().TransformType(exprFunctionType->getReturnType()); | |
| auto epi = exprFunctionType->getExtProtoInfo(); | |
| epi.ExtParameterInfos = extParamInfos.getPointerOrNull(paramTypes.size()); | |
| QualType functionType = | |
| getDerived().RebuildFunctionProtoType(exprResultType, paramTypes, epi); | |
| blockScope->FunctionType = functionType; | |
| // Set the parameters on the block decl. | |
| if (!params.empty()) | |
| blockScope->TheDecl->setParams(params); | |
| if (!oldBlock->blockMissingReturnType()) { | |
| blockScope->HasImplicitReturnType = false; | |
| blockScope->ReturnType = exprResultType; | |
| } | |
| // Transform the body | |
| StmtResult body = getDerived().TransformStmt(E->getBody()); | |
| if (body.isInvalid()) { | |
| getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr); | |
| return ExprError(); | |
| } | |
| #ifndef NDEBUG | |
| // In builds with assertions, make sure that we captured everything we | |
| // captured before. | |
| if (!SemaRef.getDiagnostics().hasErrorOccurred()) { | |
| for (const auto &I : oldBlock->captures()) { | |
| VarDecl *oldCapture = I.getVariable(); | |
| // Ignore parameter packs. | |
| if (oldCapture->isParameterPack()) | |
| continue; | |
| VarDecl *newCapture = | |
| cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(), | |
| oldCapture)); | |
| assert(blockScope->CaptureMap.count(newCapture)); | |
| } | |
| } | |
| #endif | |
| return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(), | |
| /*Scope=*/nullptr); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) { | |
| ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr()); | |
| if (SrcExpr.isInvalid()) | |
| return ExprError(); | |
| QualType Type = getDerived().TransformType(E->getType()); | |
| return SemaRef.BuildAsTypeExpr(SrcExpr.get(), Type, E->getBuiltinLoc(), | |
| E->getRParenLoc()); | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) { | |
| bool ArgumentChanged = false; | |
| SmallVector<Expr*, 8> SubExprs; | |
| SubExprs.reserve(E->getNumSubExprs()); | |
| if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false, | |
| SubExprs, &ArgumentChanged)) | |
| return ExprError(); | |
| if (!getDerived().AlwaysRebuild() && | |
| !ArgumentChanged) | |
| return E; | |
| return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs, | |
| E->getOp(), E->getRParenLoc()); | |
| } | |
| //===----------------------------------------------------------------------===// | |
| // Type reconstruction | |
| //===----------------------------------------------------------------------===// | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType, | |
| SourceLocation Star) { | |
| return SemaRef.BuildPointerType(PointeeType, Star, | |
| getDerived().getBaseEntity()); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType, | |
| SourceLocation Star) { | |
| return SemaRef.BuildBlockPointerType(PointeeType, Star, | |
| getDerived().getBaseEntity()); | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType, | |
| bool WrittenAsLValue, | |
| SourceLocation Sigil) { | |
| return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, | |
| Sigil, getDerived().getBaseEntity()); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildMemberPointerType( | |
| QualType PointeeType, const CXXScopeSpec &SS, CXXRecordDecl *Cls, | |
| SourceLocation Sigil) { | |
| return SemaRef.BuildMemberPointerType(PointeeType, SS, Cls, Sigil, | |
| getDerived().getBaseEntity()); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::RebuildObjCTypeParamType( | |
| const ObjCTypeParamDecl *Decl, | |
| SourceLocation ProtocolLAngleLoc, | |
| ArrayRef<ObjCProtocolDecl *> Protocols, | |
| ArrayRef<SourceLocation> ProtocolLocs, | |
| SourceLocation ProtocolRAngleLoc) { | |
| return SemaRef.ObjC().BuildObjCTypeParamType( | |
| Decl, ProtocolLAngleLoc, Protocols, ProtocolLocs, ProtocolRAngleLoc, | |
| /*FailOnError=*/true); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::RebuildObjCObjectType( | |
| QualType BaseType, | |
| SourceLocation Loc, | |
| SourceLocation TypeArgsLAngleLoc, | |
| ArrayRef<TypeSourceInfo *> TypeArgs, | |
| SourceLocation TypeArgsRAngleLoc, | |
| SourceLocation ProtocolLAngleLoc, | |
| ArrayRef<ObjCProtocolDecl *> Protocols, | |
| ArrayRef<SourceLocation> ProtocolLocs, | |
| SourceLocation ProtocolRAngleLoc) { | |
| return SemaRef.ObjC().BuildObjCObjectType( | |
| BaseType, Loc, TypeArgsLAngleLoc, TypeArgs, TypeArgsRAngleLoc, | |
| ProtocolLAngleLoc, Protocols, ProtocolLocs, ProtocolRAngleLoc, | |
| /*FailOnError=*/true, | |
| /*Rebuilding=*/true); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::RebuildObjCObjectPointerType( | |
| QualType PointeeType, | |
| SourceLocation Star) { | |
| return SemaRef.Context.getObjCObjectPointerType(PointeeType); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildArrayType( | |
| QualType ElementType, ArraySizeModifier SizeMod, const llvm::APInt *Size, | |
| Expr *SizeExpr, unsigned IndexTypeQuals, SourceRange BracketsRange) { | |
| if (SizeExpr || !Size) | |
| return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, | |
| IndexTypeQuals, BracketsRange, | |
| getDerived().getBaseEntity()); | |
| QualType Types[] = { | |
| SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, | |
| SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, | |
| SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty | |
| }; | |
| QualType SizeType; | |
| for (const auto &T : Types) | |
| if (Size->getBitWidth() == SemaRef.Context.getIntWidth(T)) { | |
| SizeType = T; | |
| break; | |
| } | |
| // Note that we can return a VariableArrayType here in the case where | |
| // the element type was a dependent VariableArrayType. | |
| IntegerLiteral *ArraySize | |
| = IntegerLiteral::Create(SemaRef.Context, *Size, SizeType, | |
| /*FIXME*/BracketsRange.getBegin()); | |
| return SemaRef.BuildArrayType(ElementType, SizeMod, ArraySize, | |
| IndexTypeQuals, BracketsRange, | |
| getDerived().getBaseEntity()); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildConstantArrayType( | |
| QualType ElementType, ArraySizeModifier SizeMod, const llvm::APInt &Size, | |
| Expr *SizeExpr, unsigned IndexTypeQuals, SourceRange BracketsRange) { | |
| return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, SizeExpr, | |
| IndexTypeQuals, BracketsRange); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildIncompleteArrayType( | |
| QualType ElementType, ArraySizeModifier SizeMod, unsigned IndexTypeQuals, | |
| SourceRange BracketsRange) { | |
| return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, nullptr, | |
| IndexTypeQuals, BracketsRange); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildVariableArrayType( | |
| QualType ElementType, ArraySizeModifier SizeMod, Expr *SizeExpr, | |
| unsigned IndexTypeQuals, SourceRange BracketsRange) { | |
| return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, | |
| SizeExpr, | |
| IndexTypeQuals, BracketsRange); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildDependentSizedArrayType( | |
| QualType ElementType, ArraySizeModifier SizeMod, Expr *SizeExpr, | |
| unsigned IndexTypeQuals, SourceRange BracketsRange) { | |
| return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, | |
| SizeExpr, | |
| IndexTypeQuals, BracketsRange); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildDependentAddressSpaceType( | |
| QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttributeLoc) { | |
| return SemaRef.BuildAddressSpaceAttr(PointeeType, AddrSpaceExpr, | |
| AttributeLoc); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, | |
| unsigned NumElements, | |
| VectorKind VecKind) { | |
| // FIXME: semantic checking! | |
| return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildDependentVectorType( | |
| QualType ElementType, Expr *SizeExpr, SourceLocation AttributeLoc, | |
| VectorKind VecKind) { | |
| return SemaRef.BuildVectorType(ElementType, SizeExpr, AttributeLoc); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, | |
| unsigned NumElements, | |
| SourceLocation AttributeLoc) { | |
| llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), | |
| NumElements, true); | |
| IntegerLiteral *VectorSize | |
| = IntegerLiteral::Create(SemaRef.Context, numElements, SemaRef.Context.IntTy, | |
| AttributeLoc); | |
| return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc); | |
| } | |
| template<typename Derived> | |
| QualType | |
| TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, | |
| Expr *SizeExpr, | |
| SourceLocation AttributeLoc) { | |
| return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildConstantMatrixType( | |
| QualType ElementType, unsigned NumRows, unsigned NumColumns, | |
| SourceLocation AttributeLoc) { | |
| ASTContext &Ctx = SemaRef.Context; | |
| QualType SizeTy = Ctx.getSizeType(); | |
| unsigned SizeWidth = Ctx.getIntWidth(SizeTy); | |
| IntegerLiteral *RowExpr = IntegerLiteral::Create( | |
| Ctx, llvm::APInt(SizeWidth, NumRows), SizeTy, AttributeLoc); | |
| IntegerLiteral *ColumnExpr = IntegerLiteral::Create( | |
| Ctx, llvm::APInt(SizeWidth, NumColumns), SizeTy, AttributeLoc); | |
| return SemaRef.BuildMatrixType(ElementType, RowExpr, ColumnExpr, | |
| AttributeLoc); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildDependentSizedMatrixType( | |
| QualType ElementType, Expr *RowExpr, Expr *ColumnExpr, | |
| SourceLocation AttributeLoc) { | |
| return SemaRef.BuildMatrixType(ElementType, RowExpr, ColumnExpr, | |
| AttributeLoc); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildFunctionProtoType( | |
| QualType T, MutableArrayRef<QualType> ParamTypes, | |
| const FunctionProtoType::ExtProtoInfo &EPI) { | |
| return SemaRef.BuildFunctionType(T, ParamTypes, | |
| getDerived().getBaseLocation(), | |
| getDerived().getBaseEntity(), | |
| EPI); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) { | |
| return SemaRef.Context.getFunctionNoProtoType(T); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildUnresolvedUsingType( | |
| ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, | |
| SourceLocation NameLoc, Decl *D) { | |
| assert(D && "no decl found"); | |
| if (D->isInvalidDecl()) return QualType(); | |
| // FIXME: Doesn't account for ObjCInterfaceDecl! | |
| if (auto *UPD = dyn_cast<UsingPackDecl>(D)) { | |
| // A valid resolved using typename pack expansion decl can have multiple | |
| // UsingDecls, but they must each have exactly one type, and it must be | |
| // the same type in every case. But we must have at least one expansion! | |
| if (UPD->expansions().empty()) { | |
| getSema().Diag(NameLoc, diag::err_using_pack_expansion_empty) | |
| << UPD->isCXXClassMember() << UPD; | |
| return QualType(); | |
| } | |
| // We might still have some unresolved types. Try to pick a resolved type | |
| // if we can. The final instantiation will check that the remaining | |
| // unresolved types instantiate to the type we pick. | |
| QualType FallbackT; | |
| QualType T; | |
| for (auto *E : UPD->expansions()) { | |
| QualType ThisT = | |
| RebuildUnresolvedUsingType(Keyword, Qualifier, NameLoc, E); | |
| if (ThisT.isNull()) | |
| continue; | |
| if (ThisT->getAs<UnresolvedUsingType>()) | |
| FallbackT = ThisT; | |
| else if (T.isNull()) | |
| T = ThisT; | |
| else | |
| assert(getSema().Context.hasSameType(ThisT, T) && | |
| "mismatched resolved types in using pack expansion"); | |
| } | |
| return T.isNull() ? FallbackT : T; | |
| } | |
| if (auto *Using = dyn_cast<UsingDecl>(D)) { | |
| assert(Using->hasTypename() && | |
| "UnresolvedUsingTypenameDecl transformed to non-typename using"); | |
| // A valid resolved using typename decl points to exactly one type decl. | |
| assert(++Using->shadow_begin() == Using->shadow_end()); | |
| UsingShadowDecl *Shadow = *Using->shadow_begin(); | |
| if (SemaRef.DiagnoseUseOfDecl(Shadow->getTargetDecl(), NameLoc)) | |
| return QualType(); | |
| return SemaRef.Context.getUsingType(Keyword, Qualifier, Shadow); | |
| } | |
| assert(isa<UnresolvedUsingTypenameDecl>(D) && | |
| "UnresolvedUsingTypenameDecl transformed to non-using decl"); | |
| return SemaRef.Context.getUnresolvedUsingType( | |
| Keyword, Qualifier, cast<UnresolvedUsingTypenameDecl>(D)); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E, SourceLocation, | |
| TypeOfKind Kind) { | |
| return SemaRef.BuildTypeofExprType(E, Kind); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying, | |
| TypeOfKind Kind) { | |
| return SemaRef.Context.getTypeOfType(Underlying, Kind); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E, SourceLocation) { | |
| return SemaRef.BuildDecltypeType(E); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildPackIndexingType( | |
| QualType Pattern, Expr *IndexExpr, SourceLocation Loc, | |
| bool FullySubstituted, ArrayRef<QualType> Expansions) { | |
| return SemaRef.BuildPackIndexingType(Pattern, IndexExpr, Loc, | |
| FullySubstituted, Expansions); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::RebuildUnaryTransformType(QualType BaseType, | |
| UnaryTransformType::UTTKind UKind, | |
| SourceLocation Loc) { | |
| return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( | |
| ElaboratedTypeKeyword Keyword, TemplateName Template, | |
| SourceLocation TemplateNameLoc, TemplateArgumentListInfo &TemplateArgs) { | |
| return SemaRef.CheckTemplateIdType( | |
| Keyword, Template, TemplateNameLoc, TemplateArgs, | |
| /*Scope=*/nullptr, /*ForNestedNameSpecifier=*/false); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::RebuildAtomicType(QualType ValueType, | |
| SourceLocation KWLoc) { | |
| return SemaRef.BuildAtomicType(ValueType, KWLoc); | |
| } | |
| template<typename Derived> | |
| QualType TreeTransform<Derived>::RebuildPipeType(QualType ValueType, | |
| SourceLocation KWLoc, | |
| bool isReadPipe) { | |
| return isReadPipe ? SemaRef.BuildReadPipeType(ValueType, KWLoc) | |
| : SemaRef.BuildWritePipeType(ValueType, KWLoc); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildBitIntType(bool IsUnsigned, | |
| unsigned NumBits, | |
| SourceLocation Loc) { | |
| llvm::APInt NumBitsAP(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), | |
| NumBits, true); | |
| IntegerLiteral *Bits = IntegerLiteral::Create(SemaRef.Context, NumBitsAP, | |
| SemaRef.Context.IntTy, Loc); | |
| return SemaRef.BuildBitIntType(IsUnsigned, Bits, Loc); | |
| } | |
| template <typename Derived> | |
| QualType TreeTransform<Derived>::RebuildDependentBitIntType( | |
| bool IsUnsigned, Expr *NumBitsExpr, SourceLocation Loc) { | |
| return SemaRef.BuildBitIntType(IsUnsigned, NumBitsExpr, Loc); | |
| } | |
| template <typename Derived> | |
| TemplateName TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, | |
| bool TemplateKW, | |
| TemplateName Name) { | |
| return SemaRef.Context.getQualifiedTemplateName(SS.getScopeRep(), TemplateKW, | |
| Name); | |
| } | |
| template <typename Derived> | |
| TemplateName TreeTransform<Derived>::RebuildTemplateName( | |
| CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const IdentifierInfo &Name, | |
| SourceLocation NameLoc, QualType ObjectType, bool AllowInjectedClassName) { | |
| UnqualifiedId TemplateName; | |
| TemplateName.setIdentifier(&Name, NameLoc); | |
| Sema::TemplateTy Template; | |
| getSema().ActOnTemplateName(/*Scope=*/nullptr, SS, TemplateKWLoc, | |
| TemplateName, ParsedType::make(ObjectType), | |
| /*EnteringContext=*/false, Template, | |
| AllowInjectedClassName); | |
| return Template.get(); | |
| } | |
| template<typename Derived> | |
| TemplateName | |
| TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, | |
| SourceLocation TemplateKWLoc, | |
| OverloadedOperatorKind Operator, | |
| SourceLocation NameLoc, | |
| QualType ObjectType, | |
| bool AllowInjectedClassName) { | |
| UnqualifiedId Name; | |
| // FIXME: Bogus location information. | |
| SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc }; | |
| Name.setOperatorFunctionId(NameLoc, Operator, SymbolLocations); | |
| Sema::TemplateTy Template; | |
| getSema().ActOnTemplateName( | |
| /*Scope=*/nullptr, SS, TemplateKWLoc, Name, ParsedType::make(ObjectType), | |
| /*EnteringContext=*/false, Template, AllowInjectedClassName); | |
| return Template.get(); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::RebuildCXXOperatorCallExpr( | |
| OverloadedOperatorKind Op, SourceLocation OpLoc, SourceLocation CalleeLoc, | |
| bool RequiresADL, const UnresolvedSetImpl &Functions, Expr *First, | |
| Expr *Second) { | |
| bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus); | |
| if (First->getObjectKind() == OK_ObjCProperty) { | |
| BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); | |
| if (BinaryOperator::isAssignmentOp(Opc)) | |
| return SemaRef.PseudoObject().checkAssignment(/*Scope=*/nullptr, OpLoc, | |
| Opc, First, Second); | |
| ExprResult Result = SemaRef.CheckPlaceholderExpr(First); | |
| if (Result.isInvalid()) | |
| return ExprError(); | |
| First = Result.get(); | |
| } | |
| if (Second && Second->getObjectKind() == OK_ObjCProperty) { | |
| ExprResult Result = SemaRef.CheckPlaceholderExpr(Second); | |
| if (Result.isInvalid()) | |
| return ExprError(); | |
| Second = Result.get(); | |
| } | |
| // Determine whether this should be a builtin operation. | |
| if (Op == OO_Subscript) { | |
| if (!First->getType()->isOverloadableType() && | |
| !Second->getType()->isOverloadableType()) | |
| return getSema().CreateBuiltinArraySubscriptExpr(First, CalleeLoc, Second, | |
| OpLoc); | |
| } else if (Op == OO_Arrow) { | |
| // It is possible that the type refers to a RecoveryExpr created earlier | |
| // in the tree transformation. | |
| if (First->getType()->isDependentType()) | |
| return ExprError(); | |
| // -> is never a builtin operation. | |
| return SemaRef.BuildOverloadedArrowExpr(nullptr, First, OpLoc); | |
| } else if (Second == nullptr || isPostIncDec) { | |
| if (!First->getType()->isOverloadableType() || | |
| (Op == OO_Amp && getSema().isQualifiedMemberAccess(First))) { | |
| // The argument is not of overloadable type, or this is an expression | |
| // of the form &Class::member, so try to create a built-in unary | |
| // operation. | |
| UnaryOperatorKind Opc | |
| = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); | |
| return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First); | |
| } | |
| } else { | |
| if (!First->isTypeDependent() && !Second->isTypeDependent() && | |
| !First->getType()->isOverloadableType() && | |
| !Second->getType()->isOverloadableType()) { | |
| // Neither of the arguments is type-dependent or has an overloadable | |
| // type, so try to create a built-in binary operation. | |
| BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); | |
| ExprResult Result | |
| = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second); | |
| if (Result.isInvalid()) | |
| return ExprError(); | |
| return Result; | |
| } | |
| } | |
| // Create the overloaded operator invocation for unary operators. | |
| if (!Second || isPostIncDec) { | |
| UnaryOperatorKind Opc | |
| = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); | |
| return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First, | |
| RequiresADL); | |
| } | |
| // Create the overloaded operator invocation for binary operators. | |
| BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); | |
| ExprResult Result = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, | |
| First, Second, RequiresADL); | |
| if (Result.isInvalid()) | |
| return ExprError(); | |
| return Result; | |
| } | |
| template<typename Derived> | |
| ExprResult | |
| TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base, | |
| SourceLocation OperatorLoc, | |
| bool isArrow, | |
| CXXScopeSpec &SS, | |
| TypeSourceInfo *ScopeType, | |
| SourceLocation CCLoc, | |
| SourceLocation TildeLoc, | |
| PseudoDestructorTypeStorage Destroyed) { | |
| QualType CanonicalBaseType = Base->getType().getCanonicalType(); | |
| if (Base->isTypeDependent() || Destroyed.getIdentifier() || | |
| (!isArrow && !isa<RecordType>(CanonicalBaseType)) || | |
| (isArrow && isa<PointerType>(CanonicalBaseType) && | |
| !cast<PointerType>(CanonicalBaseType) | |
| ->getPointeeType() | |
| ->getAsCanonical<RecordType>())) { | |
| // This pseudo-destructor expression is still a pseudo-destructor. | |
| return SemaRef.BuildPseudoDestructorExpr( | |
| Base, OperatorLoc, isArrow ? tok::arrow : tok::period, SS, ScopeType, | |
| CCLoc, TildeLoc, Destroyed); | |
| } | |
| TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo(); | |
| DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName( | |
| SemaRef.Context.getCanonicalType(DestroyedType->getType()))); | |
| DeclarationNameInfo NameInfo(Name, Destroyed.getLocation()); | |
| NameInfo.setNamedTypeInfo(DestroyedType); | |
| // The scope type is now known to be a valid nested name specifier | |
| // component. Tack it on to the nested name specifier. | |
| if (ScopeType) { | |
| if (!isa<TagType>(ScopeType->getType().getCanonicalType())) { | |
| getSema().Diag(ScopeType->getTypeLoc().getBeginLoc(), | |
| diag::err_expected_class_or_namespace) | |
| << ScopeType->getType() << getSema().getLangOpts().CPlusPlus; | |
| return ExprError(); | |
| } | |
| SS.clear(); | |
| SS.Make(SemaRef.Context, ScopeType->getTypeLoc(), CCLoc); | |
| } | |
| SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller. | |
| return getSema().BuildMemberReferenceExpr( | |
| Base, Base->getType(), OperatorLoc, isArrow, SS, TemplateKWLoc, | |
| /*FIXME: FirstQualifier*/ nullptr, NameInfo, | |
| /*TemplateArgs*/ nullptr, | |
| /*S*/ nullptr); | |
| } | |
| template<typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformCapturedStmt(CapturedStmt *S) { | |
| SourceLocation Loc = S->getBeginLoc(); | |
| CapturedDecl *CD = S->getCapturedDecl(); | |
| unsigned NumParams = CD->getNumParams(); | |
| unsigned ContextParamPos = CD->getContextParamPosition(); | |
| SmallVector<Sema::CapturedParamNameType, 4> Params; | |
| for (unsigned I = 0; I < NumParams; ++I) { | |
| if (I != ContextParamPos) { | |
| Params.push_back( | |
| std::make_pair( | |
| CD->getParam(I)->getName(), | |
| getDerived().TransformType(CD->getParam(I)->getType()))); | |
| } else { | |
| Params.push_back(std::make_pair(StringRef(), QualType())); | |
| } | |
| } | |
| getSema().ActOnCapturedRegionStart(Loc, /*CurScope*/nullptr, | |
| S->getCapturedRegionKind(), Params); | |
| StmtResult Body; | |
| { | |
| Sema::CompoundScopeRAII CompoundScope(getSema()); | |
| Body = getDerived().TransformStmt(S->getCapturedStmt()); | |
| } | |
| if (Body.isInvalid()) { | |
| getSema().ActOnCapturedRegionError(); | |
| return StmtError(); | |
| } | |
| return getSema().ActOnCapturedRegionEnd(Body.get()); | |
| } | |
| template <typename Derived> | |
| StmtResult | |
| TreeTransform<Derived>::TransformSYCLKernelCallStmt(SYCLKernelCallStmt *S) { | |
| // SYCLKernelCallStmt nodes are inserted upon completion of a (non-template) | |
| // function definition or instantiation of a function template specialization | |
| // and will therefore never appear in a dependent context. | |
| llvm_unreachable("SYCL kernel call statement cannot appear in dependent " | |
| "context"); | |
| } | |
| template <typename Derived> | |
| ExprResult TreeTransform<Derived>::TransformHLSLOutArgExpr(HLSLOutArgExpr *E) { | |
| // We can transform the base expression and allow argument resolution to fill | |
| // in the rest. | |
| return getDerived().TransformExpr(E->getArgLValue()); | |
| } | |
| } // end namespace clang | |
| #endif // LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H |