diff options
Diffstat (limited to 'clang/lib/Sema/TreeTransform.h')
| -rw-r--r-- | clang/lib/Sema/TreeTransform.h | 729 |
1 files changed, 461 insertions, 268 deletions
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h index a8589191fc91..6a05ecc5370f 100644 --- a/clang/lib/Sema/TreeTransform.h +++ b/clang/lib/Sema/TreeTransform.h @@ -40,6 +40,7 @@ #include "llvm/ADT/ArrayRef.h" #include "llvm/Support/ErrorHandling.h" #include <algorithm> +#include <optional> using namespace llvm::omp; @@ -279,9 +280,8 @@ public: bool TryExpandParameterPacks(SourceLocation EllipsisLoc, SourceRange PatternRange, ArrayRef<UnexpandedParameterPack> Unexpanded, - bool &ShouldExpand, - bool &RetainExpansion, - Optional<unsigned> &NumExpansions) { + bool &ShouldExpand, bool &RetainExpansion, + std::optional<unsigned> &NumExpansions) { ShouldExpand = false; return false; } @@ -636,6 +636,14 @@ public: 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, @@ -671,13 +679,49 @@ public: /// 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 transfromation 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); + 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. @@ -686,7 +730,7 @@ public: /// scope index; can be negative ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm, int indexAdjustment, - Optional<unsigned> NumExpansions, + std::optional<unsigned> NumExpansions, bool ExpectParameterPack); /// Transform the body of a lambda-expression. @@ -963,12 +1007,13 @@ public: /// /// 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); + 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); + QualType RebuildTypeOfType(QualType Underlying, TypeOfKind Kind); /// Build a new unary transform type. QualType RebuildUnaryTransformType(QualType BaseType, @@ -1061,23 +1106,18 @@ public: // If it's still dependent, make a dependent specialization. if (InstName.getAsDependentTemplateName()) - return SemaRef.Context.getDependentTemplateSpecializationType(Keyword, - QualifierLoc.getNestedNameSpecifier(), - Name, - Args); + return SemaRef.Context.getDependentTemplateSpecializationType( + Keyword, QualifierLoc.getNestedNameSpecifier(), Name, + Args.arguments()); // Otherwise, make an elaborated type wrapping a non-dependent // specialization. QualType T = - getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args); - if (T.isNull()) return QualType(); - - if (Keyword == ETK_None && QualifierLoc.getNestedNameSpecifier() == nullptr) - return T; - - return SemaRef.Context.getElaboratedType(Keyword, - QualifierLoc.getNestedNameSpecifier(), - T); + getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args); + if (T.isNull()) + return QualType(); + return SemaRef.Context.getElaboratedType( + Keyword, QualifierLoc.getNestedNameSpecifier(), T); } /// Build a new typename type that refers to an identifier. @@ -1182,10 +1222,9 @@ public: /// /// 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, + QualType RebuildPackExpansionType(QualType Pattern, SourceRange PatternRange, SourceLocation EllipsisLoc, - Optional<unsigned> NumExpansions) { + std::optional<unsigned> NumExpansions) { return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc, NumExpansions); } @@ -1252,9 +1291,11 @@ public: /// 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(TemplateTemplateParmDecl *Param, - const TemplateArgument &ArgPack) { - return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack); + TemplateName RebuildTemplateName(const TemplateArgument &ArgPack, + Decl *AssociatedDecl, unsigned Index, + bool Final) { + return getSema().Context.getSubstTemplateTemplateParmPack( + ArgPack, AssociatedDecl, Index, Final); } /// Build a new compound statement. @@ -1946,15 +1987,16 @@ public: /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. OMPClause *RebuildOMPMapClause( - ArrayRef<OpenMPMapModifierKind> MapTypeModifiers, + 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().ActOnOpenMPMapClause( - MapTypeModifiers, MapTypeModifiersLoc, MapperIdScopeSpec, MapperId, - MapType, IsMapTypeImplicit, MapLoc, ColonLoc, VarList, Locs, + IteratorModifier, MapTypeModifiers, MapTypeModifiersLoc, + MapperIdScopeSpec, MapperId, MapType, IsMapTypeImplicit, MapLoc, + ColonLoc, VarList, Locs, /*NoDiagnose=*/false, UnresolvedMappers); } @@ -2009,22 +2051,26 @@ public: /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. - OMPClause *RebuildOMPGrainsizeClause(Expr *Grainsize, SourceLocation StartLoc, + OMPClause *RebuildOMPGrainsizeClause(OpenMPGrainsizeClauseModifier Modifier, + Expr *Device, SourceLocation StartLoc, SourceLocation LParenLoc, + SourceLocation ModifierLoc, SourceLocation EndLoc) { - return getSema().ActOnOpenMPGrainsizeClause(Grainsize, StartLoc, LParenLoc, - EndLoc); + return getSema().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(Expr *NumTasks, SourceLocation StartLoc, + OMPClause *RebuildOMPNumTasksClause(OpenMPNumTasksClauseModifier Modifier, + Expr *NumTasks, SourceLocation StartLoc, SourceLocation LParenLoc, + SourceLocation ModifierLoc, SourceLocation EndLoc) { - return getSema().ActOnOpenMPNumTasksClause(NumTasks, StartLoc, LParenLoc, - EndLoc); + return getSema().ActOnOpenMPNumTasksClause(Modifier, NumTasks, StartLoc, + LParenLoc, ModifierLoc, EndLoc); } /// Build a new OpenMP 'hint' clause. @@ -2207,28 +2253,25 @@ public: /// /// 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) { - return getSema().ActOnOpenMPOrderClause(Kind, KindKwLoc, StartLoc, - LParenLoc, EndLoc); + OMPClause *RebuildOMPOrderClause( + OpenMPOrderClauseKind Kind, SourceLocation KindKwLoc, + SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, + OpenMPOrderClauseModifier Modifier, SourceLocation ModifierKwLoc) { + return getSema().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, ArrayRef<Expr *> PrefExprs, - bool IsTarget, bool IsTargetSync, + OMPClause *RebuildOMPInitClause(Expr *InteropVar, OMPInteropInfo &InteropInfo, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation VarLoc, SourceLocation EndLoc) { - return getSema().ActOnOpenMPInitClause(InteropVar, PrefExprs, IsTarget, - IsTargetSync, StartLoc, LParenLoc, - VarLoc, EndLoc); + return getSema().ActOnOpenMPInitClause(InteropVar, InteropInfo, StartLoc, + LParenLoc, VarLoc, EndLoc); } /// Build a new OpenMP 'use' clause. @@ -2301,6 +2344,17 @@ public: 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().ActOnOpenMPXDynCGroupMemClause(Size, StartLoc, LParenLoc, + EndLoc); + } + /// Build a new OpenMP 'align' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. @@ -2311,6 +2365,41 @@ public: return getSema().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().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().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().ActOnOpenMPMessageClause(MS, StartLoc, LParenLoc, EndLoc); + } + /// Rebuild the operand to an Objective-C \@synchronized statement. /// /// By default, performs semantic analysis to build the new statement. @@ -2783,20 +2872,18 @@ public: /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. - ExprResult RebuildExtVectorElementExpr(Expr *Base, - SourceLocation OpLoc, - SourceLocation AccessorLoc, - IdentifierInfo &Accessor) { + ExprResult RebuildExtVectorElementExpr(Expr *Base, SourceLocation OpLoc, + bool IsArrow, + SourceLocation AccessorLoc, + IdentifierInfo &Accessor) { CXXScopeSpec SS; DeclarationNameInfo NameInfo(&Accessor, AccessorLoc); - return getSema().BuildMemberReferenceExpr(Base, Base->getType(), - OpLoc, /*IsArrow*/ false, - SS, SourceLocation(), - /*FirstQualifierInScope*/ nullptr, - NameInfo, - /* TemplateArgs */ nullptr, - /*S*/ nullptr); + return getSema().BuildMemberReferenceExpr( + Base, Base->getType(), OpLoc, IsArrow, SS, SourceLocation(), + /*FirstQualifierInScope*/ nullptr, NameInfo, + /* TemplateArgs */ nullptr, + /*S*/ nullptr); } /// Build a new initializer list expression. @@ -3134,9 +3221,10 @@ public: /// 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) { + ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc, ParmVarDecl *Param, + Expr *RewrittenExpr) { return CXXDefaultArgExpr::Create(getSema().Context, Loc, Param, - getSema().CurContext); + RewrittenExpr, getSema().CurContext); } /// Build a new C++11 default-initialization expression. @@ -3146,8 +3234,7 @@ public: /// routine to provide different behavior. ExprResult RebuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) { - return CXXDefaultInitExpr::Create(getSema().Context, Loc, Field, - getSema().CurContext); + return getSema().BuildCXXDefaultInitExpr(Loc, Field); } /// Build a new C++ zero-initialization expression. @@ -3157,25 +3244,23 @@ public: ExprResult RebuildCXXScalarValueInitExpr(TypeSourceInfo *TSInfo, SourceLocation LParenLoc, SourceLocation RParenLoc) { - return getSema().BuildCXXTypeConstructExpr( - TSInfo, LParenLoc, None, RParenLoc, /*ListInitialization=*/false); + return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, std::nullopt, + 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, + ExprResult RebuildCXXNewExpr(SourceLocation StartLoc, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, - SourceRange TypeIdParens, - QualType AllocatedType, + SourceRange TypeIdParens, QualType AllocatedType, TypeSourceInfo *AllocatedTypeInfo, - Optional<Expr *> ArraySize, - SourceRange DirectInitRange, - Expr *Initializer) { + std::optional<Expr *> ArraySize, + SourceRange DirectInitRange, Expr *Initializer) { return getSema().BuildCXXNew(StartLoc, UseGlobal, PlacementLParen, PlacementArgs, @@ -3397,11 +3482,10 @@ public: } /// Build a new expression to compute the length of a parameter pack. - ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc, - NamedDecl *Pack, + ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, - Optional<unsigned> Length, + std::optional<unsigned> Length, ArrayRef<TemplateArgument> PartialArgs) { return SizeOfPackExpr::Create(SemaRef.Context, OperatorLoc, Pack, PackLoc, RParenLoc, Length, PartialArgs); @@ -3479,9 +3563,10 @@ public: } concepts::NestedRequirement * - RebuildNestedRequirement( - concepts::Requirement::SubstitutionDiagnostic *SubstDiag) { - return SemaRef.BuildNestedRequirement(SubstDiag); + RebuildNestedRequirement(StringRef InvalidConstraintEntity, + const ASTConstraintSatisfaction &Satisfaction) { + return SemaRef.BuildNestedRequirement(InvalidConstraintEntity, + Satisfaction); } concepts::NestedRequirement *RebuildNestedRequirement(Expr *Constraint) { @@ -3704,9 +3789,9 @@ public: /// 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, - Optional<unsigned> NumExpansions) { + TemplateArgumentLoc + RebuildPackExpansion(TemplateArgumentLoc Pattern, SourceLocation EllipsisLoc, + std::optional<unsigned> NumExpansions) { switch (Pattern.getArgument().getKind()) { case TemplateArgument::Expression: { ExprResult Result @@ -3753,7 +3838,7 @@ public: /// for an expression. Subclasses may override this routine to provide /// different behavior. ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, - Optional<unsigned> NumExpansions) { + std::optional<unsigned> NumExpansions) { return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions); } @@ -3766,7 +3851,7 @@ public: BinaryOperatorKind Operator, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, - Optional<unsigned> NumExpansions) { + std::optional<unsigned> NumExpansions) { return getSema().BuildCXXFoldExpr(ULE, LParenLoc, LHS, Operator, EllipsisLoc, RHS, RParenLoc, NumExpansions); @@ -3781,6 +3866,16 @@ public: return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator); } + ExprResult RebuildCXXParenListInitExpr(ArrayRef<Expr *> Args, QualType T, + unsigned NumUserSpecifiedExprs, + SourceLocation InitLoc, + SourceLocation LParenLoc, + SourceLocation RParenLoc) { + return CXXParenListInitExpr::Create(getSema().Context, Args, T, + NumUserSpecifiedExprs, InitLoc, + LParenLoc, RParenLoc); + } + /// Build a new atomic operation expression. /// /// By default, performs semantic analysis to build the new expression. @@ -3931,13 +4026,13 @@ ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init, // Revert value-initialization back to empty parens. if (CXXScalarValueInitExpr *VIE = dyn_cast<CXXScalarValueInitExpr>(Init)) { SourceRange Parens = VIE->getSourceRange(); - return getDerived().RebuildParenListExpr(Parens.getBegin(), None, + return getDerived().RebuildParenListExpr(Parens.getBegin(), std::nullopt, Parens.getEnd()); } // FIXME: We shouldn't build ImplicitValueInitExprs for direct-initialization. if (isa<ImplicitValueInitExpr>(Init)) - return getDerived().RebuildParenListExpr(SourceLocation(), None, + return getDerived().RebuildParenListExpr(SourceLocation(), std::nullopt, SourceLocation()); // Revert initialization by constructor back to a parenthesized or braced list @@ -4005,8 +4100,8 @@ bool TreeTransform<Derived>::TransformExprs(Expr *const *Inputs, // be expanded. bool Expand = true; bool RetainExpansion = false; - Optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions(); - Optional<unsigned> NumExpansions = OrigNumExpansions; + std::optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions(); + std::optional<unsigned> NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded, @@ -4123,9 +4218,13 @@ NestedNameSpecifierLoc TreeTransform<Derived>::TransformNestedNameSpecifierLoc( NestedNameSpecifierLoc NNS, QualType ObjectType, NamedDecl *FirstQualifierInScope) { SmallVector<NestedNameSpecifierLoc, 4> Qualifiers; - for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier; - Qualifier = Qualifier.getPrefix()) - Qualifiers.push_back(Qualifier); + + auto insertNNS = [&Qualifiers](NestedNameSpecifierLoc NNS) { + for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier; + Qualifier = Qualifier.getPrefix()) + Qualifiers.push_back(Qualifier); + }; + insertNNS(NNS); CXXScopeSpec SS; while (!Qualifiers.empty()) { @@ -4182,24 +4281,27 @@ NestedNameSpecifierLoc TreeTransform<Derived>::TransformNestedNameSpecifierLoc( if (!TL) return NestedNameSpecifierLoc(); - if (TL.getType()->isDependentType() || TL.getType()->isRecordType() || - (SemaRef.getLangOpts().CPlusPlus11 && - TL.getType()->isEnumeralType())) { - assert(!TL.getType().hasLocalQualifiers() && - "Can't get cv-qualifiers here"); - if (TL.getType()->isEnumeralType()) + QualType T = TL.getType(); + 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); + + if (const auto ETL = TL.getAs<ElaboratedTypeLoc>()) { + SS.Adopt(ETL.getQualifierLoc()); + TL = ETL.getNamedTypeLoc(); + } SS.Extend(SemaRef.Context, /*FIXME:*/ SourceLocation(), 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.getAs<TypedefTypeLoc>(); + TypedefTypeLoc TTL = TL.getAsAdjusted<TypedefTypeLoc>(); if (!TTL || !TTL.getTypedefNameDecl()->isInvalidDecl()) { SemaRef.Diag(TL.getBeginLoc(), diag::err_nested_name_spec_non_tag) - << TL.getType() << SS.getRange(); + << T << SS.getRange(); } return NestedNameSpecifierLoc(); } @@ -4362,18 +4464,9 @@ TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS, if (SubstTemplateTemplateParmPackStorage *SubstPack = Name.getAsSubstTemplateTemplateParmPack()) { - TemplateTemplateParmDecl *TransParam - = cast_or_null<TemplateTemplateParmDecl>( - getDerived().TransformDecl(NameLoc, SubstPack->getParameterPack())); - if (!TransParam) - return TemplateName(); - - if (!getDerived().AlwaysRebuild() && - TransParam == SubstPack->getParameterPack()) - return Name; - - return getDerived().RebuildTemplateName(TransParam, - SubstPack->getArgumentPack()); + return getDerived().RebuildTemplateName( + SubstPack->getArgumentPack(), SubstPack->getAssociatedDecl(), + SubstPack->getIndex(), SubstPack->getFinal()); } // These should be getting filtered out before they reach the AST. @@ -4587,7 +4680,7 @@ bool TreeTransform<Derived>::TransformTemplateArguments( // We have a pack expansion, for which we will be substituting into // the pattern. SourceLocation Ellipsis; - Optional<unsigned> OrigNumExpansions; + std::optional<unsigned> OrigNumExpansions; TemplateArgumentLoc Pattern = getSema().getTemplateArgumentPackExpansionPattern( In, Ellipsis, OrigNumExpansions); @@ -4600,7 +4693,7 @@ bool TreeTransform<Derived>::TransformTemplateArguments( // be expanded. bool Expand = true; bool RetainExpansion = false; - Optional<unsigned> NumExpansions = OrigNumExpansions; + std::optional<unsigned> NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(Ellipsis, Pattern.getSourceRange(), Unexpanded, @@ -4787,7 +4880,20 @@ template<typename Derived> QualType TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB, QualifiedTypeLoc T) { - QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc()); + 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(); @@ -4850,16 +4956,7 @@ QualType TreeTransform<Derived>::RebuildQualifiedType(QualType T, // A lifetime qualifier applied to a substituted template parameter // overrides the lifetime qualifier from the template argument. const AutoType *AutoTy; - if (const SubstTemplateTypeParmType *SubstTypeParam - = dyn_cast<SubstTemplateTypeParmType>(T)) { - QualType Replacement = SubstTypeParam->getReplacementType(); - Qualifiers Qs = Replacement.getQualifiers(); - Qs.removeObjCLifetime(); - Replacement = SemaRef.Context.getQualifiedType( - Replacement.getUnqualifiedType(), Qs); - T = SemaRef.Context.getSubstTemplateTypeParmType( - SubstTypeParam->getReplacedParameter(), Replacement); - } else if ((AutoTy = dyn_cast<AutoType>(T)) && AutoTy->isDeduced()) { + 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(); @@ -5604,8 +5701,8 @@ QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB, template <typename Derived> ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam( - ParmVarDecl *OldParm, int indexAdjustment, Optional<unsigned> NumExpansions, - bool ExpectParameterPack) { + ParmVarDecl *OldParm, int indexAdjustment, + std::optional<unsigned> NumExpansions, bool ExpectParameterPack) { TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo(); TypeSourceInfo *NewDI = nullptr; @@ -5665,15 +5762,18 @@ bool TreeTransform<Derived>::TransformFunctionTypeParams( const FunctionProtoType::ExtParameterInfo *ParamInfos, SmallVectorImpl<QualType> &OutParamTypes, SmallVectorImpl<ParmVarDecl *> *PVars, - Sema::ExtParameterInfoBuilder &PInfos) { + 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); - Optional<unsigned> NumExpansions; + std::optional<unsigned> NumExpansions; ParmVarDecl *NewParm = nullptr; if (OldParm->isParameterPack()) { // We have a function parameter pack that may need to be expanded. @@ -5688,7 +5788,7 @@ bool TreeTransform<Derived>::TransformFunctionTypeParams( // Determine whether we should expand the parameter packs. bool ShouldExpand = false; bool RetainExpansion = false; - Optional<unsigned> OrigNumExpansions; + std::optional<unsigned> OrigNumExpansions; if (Unexpanded.size() > 0) { OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions(); NumExpansions = OrigNumExpansions; @@ -5771,7 +5871,8 @@ bool TreeTransform<Derived>::TransformFunctionTypeParams( "transformation."); } else { NewParm = getDerived().TransformFunctionTypeParam( - OldParm, indexAdjustment, None, /*ExpectParameterPack=*/ false); + OldParm, indexAdjustment, std::nullopt, + /*ExpectParameterPack=*/false); } if (!NewParm) @@ -5787,14 +5888,16 @@ bool TreeTransform<Derived>::TransformFunctionTypeParams( // Deal with the possibility that we don't have a parameter // declaration for this parameter. + assert(ParamTypes); QualType OldType = ParamTypes[i]; bool IsPackExpansion = false; - Optional<unsigned> NumExpansions; + std::optional<unsigned> NumExpansions; 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(); + NumExpansions = Expansion->getNumExpansions(); SmallVector<UnexpandedParameterPack, 2> Unexpanded; getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); @@ -5819,8 +5922,8 @@ bool TreeTransform<Derived>::TransformFunctionTypeParams( return true; if (NewType->containsUnexpandedParameterPack()) { - NewType = - getSema().getASTContext().getPackExpansionType(NewType, None); + NewType = getSema().getASTContext().getPackExpansionType( + NewType, std::nullopt); if (NewType.isNull()) return true; @@ -5965,8 +6068,8 @@ QualType TreeTransform<Derived>::TransformFunctionProtoType( if (auto NewExtParamInfos = ExtParamInfos.getPointerOrNull(ParamTypes.size())) { if (!EPI.ExtParameterInfos || - llvm::makeArrayRef(EPI.ExtParameterInfos, TL.getNumParams()) - != llvm::makeArrayRef(NewExtParamInfos, ParamTypes.size())) { + llvm::ArrayRef(EPI.ExtParameterInfos, TL.getNumParams()) != + llvm::ArrayRef(NewExtParamInfos, ParamTypes.size())) { EPIChanged = true; } EPI.ExtParameterInfos = NewExtParamInfos; @@ -5977,7 +6080,7 @@ QualType TreeTransform<Derived>::TransformFunctionProtoType( QualType Result = TL.getType(); if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType() || - T->getParamTypes() != llvm::makeArrayRef(ParamTypes) || EPIChanged) { + T->getParamTypes() != llvm::ArrayRef(ParamTypes) || EPIChanged) { Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI); if (Result.isNull()) return QualType(); @@ -6041,7 +6144,7 @@ bool TreeTransform<Derived>::TransformExceptionSpec( // be expanded. bool Expand = false; bool RetainExpansion = false; - Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions(); + std::optional<unsigned> 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( @@ -6203,13 +6306,13 @@ QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, return QualType(); QualType Result = TL.getType(); - if (getDerived().AlwaysRebuild() || - E.get() != TL.getUnderlyingExpr()) { - Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc()); + TypeOfKind Kind = Result->getAs<TypeOfExprType>()->getKind(); + if (getDerived().AlwaysRebuild() || E.get() != TL.getUnderlyingExpr()) { + Result = + getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc(), Kind); if (Result.isNull()) return QualType(); } - else E.get(); TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result); NewTL.setTypeofLoc(TL.getTypeofLoc()); @@ -6222,14 +6325,15 @@ QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, template<typename Derived> QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB, TypeOfTypeLoc TL) { - TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo(); + 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->getAs<TypeOfType>()->getKind(); if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) { - Result = getDerived().RebuildTypeOfType(New_Under_TI->getType()); + Result = getDerived().RebuildTypeOfType(New_Under_TI->getType(), Kind); if (Result.isNull()) return QualType(); } @@ -6238,7 +6342,7 @@ QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB, NewTL.setTypeofLoc(TL.getTypeofLoc()); NewTL.setLParenLoc(TL.getLParenLoc()); NewTL.setRParenLoc(TL.getRParenLoc()); - NewTL.setUnderlyingTInfo(New_Under_TI); + NewTL.setUnmodifiedTInfo(New_Under_TI); return Result; } @@ -6395,6 +6499,14 @@ 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); } @@ -6404,6 +6516,9 @@ QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( 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. @@ -6412,11 +6527,8 @@ QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( if (Replacement.isNull()) return QualType(); - // Always canonicalize the replacement type. - Replacement = SemaRef.Context.getCanonicalType(Replacement); - QualType Result - = SemaRef.Context.getSubstTemplateTypeParmType(T->getReplacedParameter(), - Replacement); + QualType Result = SemaRef.Context.getSubstTemplateTypeParmType( + Replacement, NewReplaced, T->getIndex(), T->getPackIndex()); // Propagate type-source information. SubstTemplateTypeParmTypeLoc NewTL @@ -6430,6 +6542,13 @@ 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); } @@ -6750,12 +6869,9 @@ QualType TreeTransform<Derived>::TransformDependentTemplateSpecializationType( // FIXME: maybe don't rebuild if all the template arguments are the same. if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) { - QualType Result - = getSema().Context.getDependentTemplateSpecializationType( - TL.getTypePtr()->getKeyword(), - DTN->getQualifier(), - DTN->getIdentifier(), - NewTemplateArgs); + QualType Result = getSema().Context.getDependentTemplateSpecializationType( + TL.getTypePtr()->getKeyword(), DTN->getQualifier(), + DTN->getIdentifier(), NewTemplateArgs.arguments()); DependentTemplateSpecializationTypeLoc NewTL = TLB.push<DependentTemplateSpecializationTypeLoc>(Result); @@ -7113,12 +7229,10 @@ TreeTransform<Derived>::TransformObjCTypeParamType(TypeLocBuilder &TLB, QualType Result = TL.getType(); if (getDerived().AlwaysRebuild() || OTP != T->getDecl()) { - Result = getDerived().RebuildObjCTypeParamType(OTP, - TL.getProtocolLAngleLoc(), - llvm::makeArrayRef(TL.getTypePtr()->qual_begin(), - TL.getNumProtocols()), - TL.getProtocolLocs(), - TL.getProtocolRAngleLoc()); + Result = getDerived().RebuildObjCTypeParamType( + OTP, TL.getProtocolLAngleLoc(), + llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()), + TL.getProtocolLocs(), TL.getProtocolRAngleLoc()); if (Result.isNull()) return QualType(); } @@ -7166,7 +7280,7 @@ TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB, TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc(); bool Expand = false; bool RetainExpansion = false; - Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions(); + std::optional<unsigned> NumExpansions = PackExpansion->getNumExpansions(); if (getDerived().TryExpandParameterPacks( PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(), Unexpanded, Expand, RetainExpansion, NumExpansions)) @@ -7216,7 +7330,8 @@ TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB, TypeLocBuilder TypeArgBuilder; TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize()); - QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder, TypeArgLoc); + QualType NewTypeArg = + getDerived().TransformType(TypeArgBuilder, TypeArgLoc); if (NewTypeArg.isNull()) return QualType(); @@ -7237,7 +7352,7 @@ TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB, Result = getDerived().RebuildObjCObjectType( BaseType, TL.getBeginLoc(), TL.getTypeArgsLAngleLoc(), NewTypeArgInfos, TL.getTypeArgsRAngleLoc(), TL.getProtocolLAngleLoc(), - llvm::makeArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()), + llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()), TL.getProtocolLocs(), TL.getProtocolRAngleLoc()); if (Result.isNull()) @@ -7483,7 +7598,7 @@ TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { } // If this is a constexpr if, determine which arm we should instantiate. - llvm::Optional<bool> ConstexprConditionValue; + std::optional<bool> ConstexprConditionValue; if (S->isConstexpr()) ConstexprConditionValue = Cond.getKnownValue(); @@ -7800,8 +7915,7 @@ TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) { template<typename Derived> StmtResult TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) { - ArrayRef<Token> AsmToks = - llvm::makeArrayRef(S->getAsmToks(), S->getNumAsmToks()); + ArrayRef<Token> AsmToks = llvm::ArrayRef(S->getAsmToks(), S->getNumAsmToks()); bool HadError = false, HadChange = false; @@ -8839,6 +8953,17 @@ TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) { } template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPErrorDirective(OMPErrorDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_error, DirName, nullptr, + D->getBeginLoc()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective( OMPTaskgroupDirective *D) { DeclarationNameInfo DirName; @@ -9676,17 +9801,17 @@ OMPClause *TreeTransform<Derived>::TransformOMPInitClause(OMPInitClause *C) { if (IVR.isInvalid()) return nullptr; - llvm::SmallVector<Expr *, 8> PrefExprs; - PrefExprs.reserve(C->varlist_size() - 1); + OMPInteropInfo InteropInfo(C->getIsTarget(), C->getIsTargetSync()); + InteropInfo.PreferTypes.reserve(C->varlist_size() - 1); for (Expr *E : llvm::drop_begin(C->varlists())) { ExprResult ER = getDerived().TransformExpr(cast<Expr>(E)); if (ER.isInvalid()) return nullptr; - PrefExprs.push_back(ER.get()); + InteropInfo.PreferTypes.push_back(ER.get()); } - return getDerived().RebuildOMPInitClause( - IVR.get(), PrefExprs, C->getIsTarget(), C->getIsTargetSync(), - C->getBeginLoc(), C->getLParenLoc(), C->getVarLoc(), C->getEndLoc()); + return getDerived().RebuildOMPInitClause(IVR.get(), InteropInfo, + C->getBeginLoc(), C->getLParenLoc(), + C->getVarLoc(), C->getEndLoc()); } template <typename Derived> @@ -9786,6 +9911,32 @@ OMPClause *TreeTransform<Derived>::TransformOMPAtomicDefaultMemOrderClause( } 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( + C->getMessageString(), C->getBeginLoc(), C->getLParenLoc(), + C->getEndLoc()); +} + +template <typename Derived> OMPClause * TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) { llvm::SmallVector<Expr *, 16> Vars; @@ -10168,6 +10319,13 @@ 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; @@ -10175,9 +10333,9 @@ OMPClause *TreeTransform<Derived>::TransformOMPMapClause(OMPMapClause *C) { *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers)) return nullptr; return getDerived().RebuildOMPMapClause( - C->getMapTypeModifiers(), C->getMapTypeModifiersLoc(), MapperIdScopeSpec, - MapperIdInfo, C->getMapType(), C->isImplicitMapType(), C->getMapLoc(), - C->getColonLoc(), Vars, Locs, UnresolvedMappers); + IteratorModifier, C->getMapTypeModifiers(), C->getMapTypeModifiersLoc(), + MapperIdScopeSpec, MapperIdInfo, C->getMapType(), C->isImplicitMapType(), + C->getMapLoc(), C->getColonLoc(), Vars, Locs, UnresolvedMappers); } template <typename Derived> @@ -10240,7 +10398,8 @@ TreeTransform<Derived>::TransformOMPGrainsizeClause(OMPGrainsizeClause *C) { if (E.isInvalid()) return nullptr; return getDerived().RebuildOMPGrainsizeClause( - E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); + C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(), + C->getModifierLoc(), C->getEndLoc()); } template <typename Derived> @@ -10250,7 +10409,8 @@ TreeTransform<Derived>::TransformOMPNumTasksClause(OMPNumTasksClause *C) { if (E.isInvalid()) return nullptr; return getDerived().RebuildOMPNumTasksClause( - E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); + C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(), + C->getModifierLoc(), C->getEndLoc()); } template <typename Derived> @@ -10472,9 +10632,9 @@ TreeTransform<Derived>::TransformOMPAffinityClause(OMPAffinityClause *C) { template <typename Derived> OMPClause *TreeTransform<Derived>::TransformOMPOrderClause(OMPOrderClause *C) { - return getDerived().RebuildOMPOrderClause(C->getKind(), C->getKindKwLoc(), - C->getBeginLoc(), C->getLParenLoc(), - C->getEndLoc()); + return getDerived().RebuildOMPOrderClause( + C->getKind(), C->getKindKwLoc(), C->getBeginLoc(), C->getLParenLoc(), + C->getEndLoc(), C->getModifier(), C->getModifierKwLoc()); } template <typename Derived> @@ -10484,6 +10644,16 @@ OMPClause *TreeTransform<Derived>::TransformOMPBindClause(OMPBindClause *C) { 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()); +} + //===----------------------------------------------------------------------===// // Expression transformation //===----------------------------------------------------------------------===// @@ -11190,7 +11360,7 @@ TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { return getDerived().RebuildBinaryOperator( E->getOperatorLoc(), E->getOpcode(), LHS.get(), RHS.get()); Sema::FPFeaturesStateRAII FPFeaturesState(getSema()); - FPOptionsOverride NewOverrides(E->getFPFeatures(getSema().getLangOpts())); + FPOptionsOverride NewOverrides(E->getFPFeatures()); getSema().CurFPFeatures = NewOverrides.applyOverrides(getSema().getLangOpts()); getSema().FpPragmaStack.CurrentValue = NewOverrides; @@ -11257,7 +11427,7 @@ ExprResult TreeTransform<Derived>::TransformCompoundAssignOperator( CompoundAssignOperator *E) { Sema::FPFeaturesStateRAII FPFeaturesState(getSema()); - FPOptionsOverride NewOverrides(E->getFPFeatures(getSema().getLangOpts())); + FPOptionsOverride NewOverrides(E->getFPFeatures()); getSema().CurFPFeatures = NewOverrides.applyOverrides(getSema().getLangOpts()); getSema().FpPragmaStack.CurrentValue = NewOverrides; @@ -11389,9 +11559,9 @@ TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { // FIXME: Bad source location SourceLocation FakeOperatorLoc = SemaRef.getLocForEndOfToken(E->getBase()->getEndLoc()); - return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc, - E->getAccessorLoc(), - E->getAccessor()); + return getDerived().RebuildExtVectorElementExpr( + Base.get(), FakeOperatorLoc, E->isArrow(), E->getAccessorLoc(), + E->getAccessor()); } template<typename Derived> @@ -12024,11 +12194,20 @@ TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 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) + E->getUsedContext() == SemaRef.CurContext && + InitRes.get() == E->getRewrittenExpr()) return E; - return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param); + return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param, + InitRes.get()); } template<typename Derived> @@ -12073,10 +12252,10 @@ TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { return ExprError(); // Transform the size of the array we're allocating (if any). - Optional<Expr *> ArraySize; + std::optional<Expr *> ArraySize; if (E->isArray()) { ExprResult NewArraySize; - if (Optional<Expr *> OldArraySize = E->getArraySize()) { + if (std::optional<Expr *> OldArraySize = E->getArraySize()) { NewArraySize = getDerived().TransformExpr(*OldArraySize); if (NewArraySize.isInvalid()) return ExprError(); @@ -12455,9 +12634,9 @@ TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) { // be expanded. bool Expand = true; bool RetainExpansion = false; - Optional<unsigned> OrigNumExpansions = + std::optional<unsigned> OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions(); - Optional<unsigned> NumExpansions = OrigNumExpansions; + std::optional<unsigned> NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(), PatternTL.getSourceRange(), Unexpanded, @@ -12578,7 +12757,8 @@ TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *E) { // C++2a [expr.prim.req]p2 // Expressions appearing within a requirement-body are unevaluated operands. EnterExpressionEvaluationContext Ctx( - SemaRef, Sema::ExpressionEvaluationContext::Unevaluated); + SemaRef, Sema::ExpressionEvaluationContext::Unevaluated, + Sema::ReuseLambdaContextDecl); RequiresExprBodyDecl *Body = RequiresExprBodyDecl::Create( getSema().Context, getSema().CurContext, @@ -12586,16 +12766,20 @@ TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *E) { Sema::ContextRAII SavedContext(getSema(), Body, /*NewThisContext*/false); - if (getDerived().TransformFunctionTypeParams(E->getRequiresKWLoc(), - E->getLocalParameters(), - /*ParamTypes=*/nullptr, - /*ParamInfos=*/nullptr, - TransParamTypes, &TransParams, - ExtParamInfos)) - return ExprError(); + ExprResult TypeParamResult = getDerived().TransformRequiresTypeParams( + E->getRequiresKWLoc(), E->getRBraceLoc(), E, Body, + E->getLocalParameters(), TransParamTypes, TransParams, ExtParamInfos); for (ParmVarDecl *Param : TransParams) - Param->setDeclContext(Body); + 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(), @@ -12668,7 +12852,7 @@ TreeTransform<Derived>::TransformExprRequirement(concepts::ExprRequirement *Req) TransExpr = TransExprRes.get(); } - llvm::Optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq; + std::optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq; const auto &RetReq = Req->getReturnTypeRequirement(); if (RetReq.isEmpty()) TransRetReq.emplace(); @@ -12697,10 +12881,10 @@ template<typename Derived> concepts::NestedRequirement * TreeTransform<Derived>::TransformNestedRequirement( concepts::NestedRequirement *Req) { - if (Req->isSubstitutionFailure()) { + if (Req->hasInvalidConstraint()) { if (getDerived().AlwaysRebuild()) return getDerived().RebuildNestedRequirement( - Req->getSubstitutionDiagnostic()); + Req->getInvalidConstraintEntity(), Req->getConstraintSatisfaction()); return Req; } ExprResult TransConstraint = @@ -12990,10 +13174,10 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { continue; TransformedInitCapture &Result = InitCaptures[C - E->capture_begin()]; - VarDecl *OldVD = C->getCapturedVar(); + auto *OldVD = cast<VarDecl>(C->getCapturedVar()); auto SubstInitCapture = [&](SourceLocation EllipsisLoc, - Optional<unsigned> NumExpansions) { + std::optional<unsigned> NumExpansions) { ExprResult NewExprInitResult = getDerived().TransformInitializer( OldVD->getInit(), OldVD->getInitStyle() == VarDecl::CallInit); @@ -13005,9 +13189,10 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { QualType NewInitCaptureType = getSema().buildLambdaInitCaptureInitialization( - C->getLocation(), OldVD->getType()->isReferenceType(), + C->getLocation(), C->getCaptureKind() == LCK_ByRef, EllipsisLoc, NumExpansions, OldVD->getIdentifier(), - C->getCapturedVar()->getInitStyle() != VarDecl::CInit, + cast<VarDecl>(C->getCapturedVar())->getInitStyle() != + VarDecl::CInit, NewExprInit); Result.Expansions.push_back( InitCaptureInfoTy(NewExprInit, NewInitCaptureType)); @@ -13025,9 +13210,9 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { // be expanded. bool Expand = true; bool RetainExpansion = false; - Optional<unsigned> OrigNumExpansions = + std::optional<unsigned> OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions(); - Optional<unsigned> NumExpansions = OrigNumExpansions; + std::optional<unsigned> NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks( ExpansionTL.getEllipsisLoc(), OldVD->getInit()->getSourceRange(), Unexpanded, Expand, @@ -13036,7 +13221,7 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { if (Expand) { for (unsigned I = 0; I != *NumExpansions; ++I) { Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); - SubstInitCapture(SourceLocation(), None); + SubstInitCapture(SourceLocation(), std::nullopt); } } if (!Expand || RetainExpansion) { @@ -13045,7 +13230,7 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { Result.EllipsisLoc = ExpansionTL.getEllipsisLoc(); } } else { - SubstInitCapture(SourceLocation(), None); + SubstInitCapture(SourceLocation(), std::nullopt); } } @@ -13083,23 +13268,17 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { NewCallOpType); } - // Transform the trailing requires clause - ExprResult NewTrailingRequiresClause; - if (Expr *TRC = E->getCallOperator()->getTrailingRequiresClause()) - // FIXME: Concepts: Substitution into requires clause should only happen - // when checking satisfaction. - NewTrailingRequiresClause = getDerived().TransformExpr(TRC); - // 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 isUnevaluatedContext() to distinguish the function parameter case. + // use evaluation contexts to distinguish the function parameter case. CXXRecordDecl::LambdaDependencyKind DependencyKind = CXXRecordDecl::LDK_Unknown; - if (getSema().isUnevaluatedContext() && + if ((getSema().isUnevaluatedContext() || + getSema().isConstantEvaluatedContext()) && (getSema().CurContext->isFileContext() || !getSema().CurContext->getParent()->isDependentContext())) DependencyKind = CXXRecordDecl::LDK_NeverDependent; @@ -13111,7 +13290,7 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { getDerived().transformedLocalDecl(OldClass, {Class}); - Optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling; + std::optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling; if (getDerived().ReplacingOriginal()) Mangling = std::make_tuple(OldClass->hasKnownLambdaInternalLinkage(), OldClass->getLambdaManglingNumber(), @@ -13124,7 +13303,8 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { E->getCallOperator()->getEndLoc(), NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams(), E->getCallOperator()->getConstexprKind(), - NewTrailingRequiresClause.get()); + E->getCallOperator()->getStorageClass(), + E->getCallOperator()->getTrailingRequiresClause()); LSI->CallOperator = NewCallOperator; @@ -13174,7 +13354,7 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { if (E->isInitCapture(C)) { TransformedInitCapture &NewC = InitCaptures[C - E->capture_begin()]; - VarDecl *OldVD = C->getCapturedVar(); + auto *OldVD = cast<VarDecl>(C->getCapturedVar()); llvm::SmallVector<Decl*, 4> NewVDs; for (InitCaptureInfoTy &Info : NewC.Expansions) { @@ -13192,7 +13372,7 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { break; } NewVDs.push_back(NewVD); - getSema().addInitCapture(LSI, NewVD); + getSema().addInitCapture(LSI, NewVD, C->getCaptureKind() == LCK_ByRef); } if (Invalid) @@ -13215,7 +13395,7 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation()); bool ShouldExpand = false; bool RetainExpansion = false; - Optional<unsigned> NumExpansions; + std::optional<unsigned> NumExpansions; if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(), C->getLocation(), Unexpanded, @@ -13229,7 +13409,7 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { // The transform has determined that we should perform an expansion; // transform and capture each of the arguments. // expansion of the pattern. Do so. - VarDecl *Pack = C->getCapturedVar(); + auto *Pack = cast<VarDecl>(C->getCapturedVar()); for (unsigned I = 0; I != *NumExpansions; ++I) { Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); VarDecl *CapturedVar @@ -13253,9 +13433,8 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { } // Transform the captured variable. - VarDecl *CapturedVar - = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(), - C->getCapturedVar())); + auto *CapturedVar = cast_or_null<ValueDecl>( + getDerived().TransformDecl(C->getLocation(), C->getCapturedVar())); if (!CapturedVar || CapturedVar->isInvalidDecl()) { Invalid = true; continue; @@ -13592,7 +13771,7 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc()); bool ShouldExpand = false; bool RetainExpansion = false; - Optional<unsigned> NumExpansions; + std::optional<unsigned> NumExpansions; if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(), Unexpanded, ShouldExpand, RetainExpansion, @@ -13605,9 +13784,9 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { auto *Pack = E->getPack(); if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Pack)) { ArgStorage = getSema().Context.getPackExpansionType( - getSema().Context.getTypeDeclType(TTPD), None); + getSema().Context.getTypeDeclType(TTPD), std::nullopt); } else if (auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Pack)) { - ArgStorage = TemplateArgument(TemplateName(TTPD), None); + ArgStorage = TemplateArgument(TemplateName(TTPD), std::nullopt); } else { auto *VD = cast<ValueDecl>(Pack); ExprResult DRE = getSema().BuildDeclRefExpr( @@ -13616,8 +13795,9 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { E->getPackLoc()); if (DRE.isInvalid()) return ExprError(); - ArgStorage = new (getSema().Context) PackExpansionExpr( - getSema().Context.DependentTy, DRE.get(), E->getPackLoc(), None); + ArgStorage = new (getSema().Context) + PackExpansionExpr(getSema().Context.DependentTy, DRE.get(), + E->getPackLoc(), std::nullopt); } PackArgs = ArgStorage; } @@ -13629,13 +13809,13 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { getDerived().TransformDecl(E->getPackLoc(), E->getPack())); if (!Pack) return ExprError(); - return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), Pack, - E->getPackLoc(), - E->getRParenLoc(), None, None); + return getDerived().RebuildSizeOfPackExpr( + E->getOperatorLoc(), Pack, E->getPackLoc(), E->getRParenLoc(), + std::nullopt, std::nullopt); } // Try to compute the result without performing a partial substitution. - Optional<unsigned> Result = 0; + std::optional<unsigned> Result = 0; for (const TemplateArgument &Arg : PackArgs) { if (!Arg.isPackExpansion()) { Result = *Result + 1; @@ -13647,7 +13827,7 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { // Find the pattern of the pack expansion. SourceLocation Ellipsis; - Optional<unsigned> OrigNumExpansions; + std::optional<unsigned> OrigNumExpansions; TemplateArgumentLoc Pattern = getSema().getTemplateArgumentPackExpansionPattern(ArgLoc, Ellipsis, OrigNumExpansions); @@ -13660,12 +13840,12 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { return true; // See if we can determine the number of arguments from the result. - Optional<unsigned> NumExpansions = + std::optional<unsigned> 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 = None; + Result = std::nullopt; break; } @@ -13675,9 +13855,9 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { // 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, None); + return getDerived().RebuildSizeOfPackExpr( + E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(), + *Result, std::nullopt); TemplateArgumentListInfo TransformedPackArgs(E->getPackLoc(), E->getPackLoc()); @@ -13702,13 +13882,13 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { } if (PartialSubstitution) - return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(), - E->getPackLoc(), - E->getRParenLoc(), None, Args); + 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(), - Args.size(), None); + Args.size(), std::nullopt); } template<typename Derived> @@ -13762,8 +13942,8 @@ TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) { // be expanded. bool Expand = true; bool RetainExpansion = false; - Optional<unsigned> OrigNumExpansions = E->getNumExpansions(), - NumExpansions = OrigNumExpansions; + std::optional<unsigned> OrigNumExpansions = E->getNumExpansions(), + NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(E->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded, @@ -13887,6 +14067,20 @@ TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) { return Result; } +template <typename Derived> +ExprResult +TreeTransform<Derived>::TransformCXXParenListInitExpr(CXXParenListInitExpr *E) { + SmallVector<Expr *, 4> TransformedInits; + ArrayRef<Expr *> InitExprs = E->getInitExprs(); + if (TransformExprs(InitExprs.data(), InitExprs.size(), true, + TransformedInits)) + return ExprError(); + + return getDerived().RebuildCXXParenListInitExpr( + TransformedInits, E->getType(), E->getUserSpecifiedInitExprs().size(), + E->getInitLoc(), E->getBeginLoc(), E->getEndLoc()); +} + template<typename Derived> ExprResult TreeTransform<Derived>::TransformCXXStdInitializerListExpr( @@ -13959,8 +14153,8 @@ TreeTransform<Derived>::TransformObjCDictionaryLiteral( // and should be expanded. bool Expand = true; bool RetainExpansion = false; - Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions; - Optional<unsigned> NumExpansions = OrigNumExpansions; + std::optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions; + std::optional<unsigned> NumExpansions = OrigNumExpansions; SourceRange PatternRange(OrigElement.Key->getBeginLoc(), OrigElement.Value->getEndLoc()); if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc, @@ -14047,9 +14241,8 @@ TreeTransform<Derived>::TransformObjCDictionaryLiteral( if (Value.get() != OrigElement.Value) ArgChanged = true; - ObjCDictionaryElement Element = { - Key.get(), Value.get(), SourceLocation(), None - }; + ObjCDictionaryElement Element = {Key.get(), Value.get(), SourceLocation(), + std::nullopt}; Elements.push_back(Element); } @@ -14506,11 +14699,11 @@ QualType TreeTransform<Derived>::RebuildObjCObjectType( ArrayRef<ObjCProtocolDecl *> Protocols, ArrayRef<SourceLocation> ProtocolLocs, SourceLocation ProtocolRAngleLoc) { - return SemaRef.BuildObjCObjectType(BaseType, Loc, TypeArgsLAngleLoc, - TypeArgs, TypeArgsRAngleLoc, - ProtocolLAngleLoc, Protocols, ProtocolLocs, - ProtocolRAngleLoc, - /*FailOnError=*/true); + return SemaRef.BuildObjCObjectType(BaseType, Loc, TypeArgsLAngleLoc, TypeArgs, + TypeArgsRAngleLoc, ProtocolLAngleLoc, + Protocols, ProtocolLocs, ProtocolRAngleLoc, + /*FailOnError=*/true, + /*Rebuilding=*/true); } template<typename Derived> @@ -14538,11 +14731,10 @@ TreeTransform<Derived>::RebuildArrayType(QualType ElementType, SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty }; - const unsigned NumTypes = llvm::array_lengthof(Types); QualType SizeType; - for (unsigned I = 0; I != NumTypes; ++I) - if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { - SizeType = Types[I]; + for (const auto &T : Types) + if (Size->getBitWidth() == SemaRef.Context.getIntWidth(T)) { + SizeType = T; break; } @@ -14733,14 +14925,15 @@ QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(SourceLocation Loc, } template <typename Derived> -QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E, - SourceLocation) { - return SemaRef.BuildTypeofExprType(E); +QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E, SourceLocation, + TypeOfKind Kind) { + return SemaRef.BuildTypeofExprType(E, Kind); } template<typename Derived> -QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { - return SemaRef.Context.getTypeOfType(Underlying); +QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying, + TypeOfKind Kind) { + return SemaRef.Context.getTypeOfType(Underlying, Kind); } template <typename Derived> |