From bb8ed8a4b5aa883b3c14c663e3ba320ae68fd274 Mon Sep 17 00:00:00 2001 From: Matheus Izvekov Date: Wed, 2 Apr 2025 13:21:05 -0300 Subject: [PATCH] [clang] NFC: introduce UnsignedOrNone replacement for std::optional This introduces a new class 'UnsignedOrNone', which models a lite version of std::optional, but has the same size as 'unsigned'. This replaces most uses of std::optional and of similar schemes utilizing 'int' and '-1' as sentinel. --- clang/include/clang/AST/ASTConcept.h | 12 +- clang/include/clang/AST/ASTContext.h | 9 +- clang/include/clang/AST/ASTImporter.h | 2 +- .../clang/AST/ASTStructuralEquivalence.h | 3 +- clang/include/clang/AST/Decl.h | 10 +- clang/include/clang/AST/DeclTemplate.h | 36 ++-- clang/include/clang/AST/ExprCXX.h | 33 ++-- clang/include/clang/AST/ExprObjC.h | 2 +- clang/include/clang/AST/Mangle.h | 4 +- clang/include/clang/AST/PropertiesBase.td | 14 +- clang/include/clang/AST/TemplateBase.h | 13 +- clang/include/clang/AST/TemplateName.h | 19 +-- clang/include/clang/AST/Type.h | 23 ++- clang/include/clang/AST/TypeProperties.td | 4 +- clang/include/clang/Basic/UnsignedOrNone.h | 53 ++++++ clang/include/clang/Sema/Sema.h | 59 ++++--- clang/include/clang/Sema/SemaLambda.h | 2 +- clang/include/clang/Sema/SemaOpenACC.h | 2 +- clang/include/clang/Sema/Template.h | 5 +- clang/include/clang/Sema/TemplateDeduction.h | 2 +- clang/include/clang/Serialization/ASTReader.h | 2 +- .../clang/Serialization/ASTRecordReader.h | 4 + .../clang/Serialization/ASTRecordWriter.h | 4 + clang/lib/AST/ASTContext.cpp | 41 +++-- clang/lib/AST/ASTImporter.cpp | 9 +- clang/lib/AST/ASTStructuralEquivalence.cpp | 6 +- clang/lib/AST/ComputeDependence.cpp | 2 +- clang/lib/AST/Decl.cpp | 2 +- clang/lib/AST/DeclTemplate.cpp | 12 +- clang/lib/AST/Expr.cpp | 2 +- clang/lib/AST/ExprCXX.cpp | 13 +- clang/lib/AST/ItaniumMangle.cpp | 6 +- clang/lib/AST/JSONNodeDumper.cpp | 2 +- clang/lib/AST/TemplateBase.cpp | 9 +- clang/lib/AST/TemplateName.cpp | 4 +- clang/lib/AST/TextNodeDumper.cpp | 2 +- clang/lib/AST/Type.cpp | 18 +- clang/lib/Sema/Sema.cpp | 2 +- clang/lib/Sema/SemaConcept.cpp | 16 +- clang/lib/Sema/SemaDecl.cpp | 2 +- clang/lib/Sema/SemaDeclCXX.cpp | 10 +- clang/lib/Sema/SemaExprCXX.cpp | 8 +- clang/lib/Sema/SemaLambda.cpp | 25 ++- clang/lib/Sema/SemaOpenACC.cpp | 5 +- clang/lib/Sema/SemaOverload.cpp | 5 +- clang/lib/Sema/SemaTemplate.cpp | 12 +- clang/lib/Sema/SemaTemplateDeduction.cpp | 60 +++---- clang/lib/Sema/SemaTemplateDeductionGuide.cpp | 28 ++-- clang/lib/Sema/SemaTemplateInstantiate.cpp | 100 +++++------ .../lib/Sema/SemaTemplateInstantiateDecl.cpp | 59 ++++--- clang/lib/Sema/SemaTemplateVariadic.cpp | 26 +-- clang/lib/Sema/SemaType.cpp | 14 +- clang/lib/Sema/TreeTransform.h | 155 +++++++++--------- clang/lib/Serialization/ASTReader.cpp | 4 +- clang/lib/Serialization/ASTReaderDecl.cpp | 13 +- clang/lib/Serialization/ASTReaderStmt.cpp | 2 +- clang/lib/Serialization/ASTWriter.cpp | 2 +- clang/lib/Serialization/ASTWriterDecl.cpp | 9 +- clang/lib/Serialization/ASTWriterStmt.cpp | 2 +- clang/unittests/AST/ASTImporterTest.cpp | 12 +- 60 files changed, 509 insertions(+), 507 deletions(-) create mode 100644 clang/include/clang/Basic/UnsignedOrNone.h diff --git a/clang/include/clang/AST/ASTConcept.h b/clang/include/clang/AST/ASTConcept.h index f89899c3ea7b1..078e1e848f393 100644 --- a/clang/include/clang/AST/ASTConcept.h +++ b/clang/include/clang/AST/ASTConcept.h @@ -18,6 +18,7 @@ #include "clang/AST/NestedNameSpecifier.h" #include "clang/AST/TemplateBase.h" #include "clang/Basic/SourceLocation.h" +#include "clang/Basic/UnsignedOrNone.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/PointerUnion.h" #include "llvm/ADT/SmallVector.h" @@ -229,15 +230,14 @@ class TypeConstraint { /// type-constraint. Expr *ImmediatelyDeclaredConstraint = nullptr; ConceptReference *ConceptRef; - int ArgumentPackSubstitutionIndex; + UnsignedOrNone ArgPackSubstIndex; public: TypeConstraint(ConceptReference *ConceptRef, Expr *ImmediatelyDeclaredConstraint, - int ArgumentPackSubstitutionIndex) + UnsignedOrNone ArgPackSubstIndex) : ImmediatelyDeclaredConstraint(ImmediatelyDeclaredConstraint), - ConceptRef(ConceptRef), - ArgumentPackSubstitutionIndex(ArgumentPackSubstitutionIndex) {} + ConceptRef(ConceptRef), ArgPackSubstIndex(ArgPackSubstIndex) {} /// \brief Get the immediately-declared constraint expression introduced by /// this type-constraint, that is - the constraint expression that is added to @@ -248,9 +248,7 @@ class TypeConstraint { ConceptReference *getConceptReference() const { return ConceptRef; } - int getArgumentPackSubstitutionIndex() const { - return ArgumentPackSubstitutionIndex; - } + UnsignedOrNone getArgPackSubstIndex() const { return ArgPackSubstIndex; } // FIXME: Instead of using these concept related functions the callers should // directly work with the corresponding ConceptReference. diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h index 6bdafbdafda94..3ff9f308f3a5e 100644 --- a/clang/include/clang/AST/ASTContext.h +++ b/clang/include/clang/AST/ASTContext.h @@ -1797,7 +1797,7 @@ class ASTContext : public RefCountedBase { QualType getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl, unsigned Index, - std::optional PackIndex, + UnsignedOrNone PackIndex, bool Final) const; QualType getSubstTemplateTypeParmPackType(Decl *AssociatedDecl, unsigned Index, bool Final, @@ -1853,8 +1853,7 @@ class ASTContext : public RefCountedBase { /// expansion is used in a context where the arity is inferred from /// elsewhere, such as if the pattern contains a placeholder type or /// if this is the canonical type of another pack expansion type. - QualType getPackExpansionType(QualType Pattern, - std::optional NumExpansions, + QualType getPackExpansionType(QualType Pattern, UnsignedOrNone NumExpansions, bool ExpectPackInType = true) const; QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, @@ -1898,7 +1897,7 @@ class ASTContext : public RefCountedBase { QualType getPackIndexingType(QualType Pattern, Expr *IndexExpr, bool FullySubstituted = false, ArrayRef Expansions = {}, - int Index = -1) const; + UnsignedOrNone Index = std::nullopt) const; /// Unary type transforms QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType, @@ -2396,7 +2395,7 @@ class ASTContext : public RefCountedBase { TemplateName getSubstTemplateTemplateParm(TemplateName replacement, Decl *AssociatedDecl, unsigned Index, - std::optional PackIndex, + UnsignedOrNone PackIndex, bool Final) const; TemplateName getSubstTemplateTemplateParmPack(const TemplateArgument &ArgPack, Decl *AssociatedDecl, diff --git a/clang/include/clang/AST/ASTImporter.h b/clang/include/clang/AST/ASTImporter.h index a2550716e3c7f..c40b92666a2ff 100644 --- a/clang/include/clang/AST/ASTImporter.h +++ b/clang/include/clang/AST/ASTImporter.h @@ -592,7 +592,7 @@ class TypeSourceInfo; /// F should be a field (or indirect field) declaration. /// \returns The index of the field in its parent context (starting from 0). /// On error `std::nullopt` is returned (parent context is non-record). - static std::optional getFieldIndex(Decl *F); + static UnsignedOrNone getFieldIndex(Decl *F); }; } // namespace clang diff --git a/clang/include/clang/AST/ASTStructuralEquivalence.h b/clang/include/clang/AST/ASTStructuralEquivalence.h index 67aa0023c25d0..b0caded2f49a6 100644 --- a/clang/include/clang/AST/ASTStructuralEquivalence.h +++ b/clang/include/clang/AST/ASTStructuralEquivalence.h @@ -123,8 +123,7 @@ struct StructuralEquivalenceContext { /// /// FIXME: This is needed by ASTImporter and ASTStructureEquivalence. It /// probably makes more sense in some other common place then here. - static std::optional - findUntaggedStructOrUnionIndex(RecordDecl *Anon); + static UnsignedOrNone findUntaggedStructOrUnionIndex(RecordDecl *Anon); // If ErrorOnTagTypeMismatch is set, return the error, otherwise get the // relevant warning for the input error diagnostic. diff --git a/clang/include/clang/AST/Decl.h b/clang/include/clang/AST/Decl.h index e4f1e2921bef8..ff1d3497b77c3 100644 --- a/clang/include/clang/AST/Decl.h +++ b/clang/include/clang/AST/Decl.h @@ -33,6 +33,7 @@ #include "clang/Basic/PragmaKinds.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/Specifiers.h" +#include "clang/Basic/UnsignedOrNone.h" #include "clang/Basic/Visibility.h" #include "llvm/ADT/APSInt.h" #include "llvm/ADT/ArrayRef.h" @@ -82,14 +83,13 @@ enum class ImplicitParamKind; // expanded. struct AssociatedConstraint { const Expr *ConstraintExpr = nullptr; - int ArgumentPackSubstitutionIndex = -1; + UnsignedOrNone ArgPackSubstIndex = std::nullopt; constexpr AssociatedConstraint() = default; explicit AssociatedConstraint(const Expr *ConstraintExpr, - int ArgumentPackSubstitutionIndex = -1) - : ConstraintExpr(ConstraintExpr), - ArgumentPackSubstitutionIndex(ArgumentPackSubstitutionIndex) {} + UnsignedOrNone ArgPackSubstIndex = std::nullopt) + : ConstraintExpr(ConstraintExpr), ArgPackSubstIndex(ArgPackSubstIndex) {} explicit operator bool() const { return ConstraintExpr != nullptr; } @@ -2540,7 +2540,7 @@ class FunctionDecl : public DeclaratorDecl, /// If this function is an allocation/deallocation function that takes /// the `std::nothrow_t` tag, return true through IsNothrow, bool isReplaceableGlobalAllocationFunction( - std::optional *AlignmentParam = nullptr, + UnsignedOrNone *AlignmentParam = nullptr, bool *IsNothrow = nullptr) const; /// Determine if this function provides an inline implementation of a builtin. diff --git a/clang/include/clang/AST/DeclTemplate.h b/clang/include/clang/AST/DeclTemplate.h index 37fe0acf5d4d5..a8100b642e04c 100644 --- a/clang/include/clang/AST/DeclTemplate.h +++ b/clang/include/clang/AST/DeclTemplate.h @@ -1198,13 +1198,8 @@ class TemplateTypeParmDecl final : public TypeDecl, /// type constraint. bool TypeConstraintInitialized : 1; - /// Whether this type template parameter is an "expanded" - /// parameter pack, meaning that its type is a pack expansion and we - /// already know the set of types that expansion expands to. - bool ExpandedParameterPack : 1; - - /// The number of type parameters in an expanded parameter pack. - unsigned NumExpanded = 0; + /// The number of type parameters in an expanded parameter pack, if any. + UnsignedOrNone NumExpanded = std::nullopt; /// The default template argument, if any. using DefArgStorage = @@ -1213,19 +1208,17 @@ class TemplateTypeParmDecl final : public TypeDecl, TemplateTypeParmDecl(DeclContext *DC, SourceLocation KeyLoc, SourceLocation IdLoc, IdentifierInfo *Id, bool Typename, - bool HasTypeConstraint, - std::optional NumExpanded) + bool HasTypeConstraint, UnsignedOrNone NumExpanded) : TypeDecl(TemplateTypeParm, DC, IdLoc, Id, KeyLoc), Typename(Typename), HasTypeConstraint(HasTypeConstraint), TypeConstraintInitialized(false), - ExpandedParameterPack(NumExpanded), - NumExpanded(NumExpanded.value_or(0)) {} + NumExpanded(NumExpanded) {} public: static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint = false, - std::optional NumExpanded = std::nullopt); + UnsignedOrNone NumExpanded = std::nullopt); static TemplateTypeParmDecl *CreateDeserialized(const ASTContext &C, GlobalDeclID ID); static TemplateTypeParmDecl *CreateDeserialized(const ASTContext &C, @@ -1327,13 +1320,8 @@ class TemplateTypeParmDecl final : public TypeDecl, /// expanded parameter pack. For example, instantiating /// \c X results in \c Convertibles being an expanded /// parameter pack of size 2 (use getNumExpansionTypes() to get this number). - bool isExpandedParameterPack() const { return ExpandedParameterPack; } - - /// Retrieves the number of parameters in an expanded parameter pack. - unsigned getNumExpansionParameters() const { - assert(ExpandedParameterPack && "Not an expansion parameter pack"); - return NumExpanded; - } + /// Retrieves the number of parameters in an expanded parameter pack, if any. + UnsignedOrNone getNumExpansionParameters() const { return NumExpanded; } /// Returns the type constraint associated with this template parameter (if /// any). @@ -1344,7 +1332,7 @@ class TemplateTypeParmDecl final : public TypeDecl, void setTypeConstraint(ConceptReference *CR, Expr *ImmediatelyDeclaredConstraint, - int ArgumentPackSubstitutionIndex); + UnsignedOrNone ArgPackSubstIndex); /// Determine whether this template parameter has a type-constraint. bool hasTypeConstraint() const { @@ -1360,7 +1348,7 @@ class TemplateTypeParmDecl final : public TypeDecl, llvm::SmallVectorImpl &AC) const { if (HasTypeConstraint) AC.emplace_back(getTypeConstraint()->getImmediatelyDeclaredConstraint(), - getTypeConstraint()->getArgumentPackSubstitutionIndex()); + getTypeConstraint()->getArgPackSubstIndex()); } SourceRange getSourceRange() const override LLVM_READONLY; @@ -3379,10 +3367,10 @@ inline TemplateDecl *getAsTypeTemplateDecl(Decl *D) { /// /// In \c A::B, \c NTs and \c TTs have expanded pack size 2, and \c Us /// is not a pack expansion, so returns an empty Optional. -inline std::optional getExpandedPackSize(const NamedDecl *Param) { +inline UnsignedOrNone getExpandedPackSize(const NamedDecl *Param) { if (const auto *TTP = dyn_cast(Param)) { - if (TTP->isExpandedParameterPack()) - return TTP->getNumExpansionParameters(); + if (UnsignedOrNone Num = TTP->getNumExpansionParameters()) + return Num; } if (const auto *NTTP = dyn_cast(Param)) { diff --git a/clang/include/clang/AST/ExprCXX.h b/clang/include/clang/AST/ExprCXX.h index 0f1455d8be3ca..ac78d2faefe42 100644 --- a/clang/include/clang/AST/ExprCXX.h +++ b/clang/include/clang/AST/ExprCXX.h @@ -4210,7 +4210,7 @@ class PackExpansionExpr : public Expr { public: PackExpansionExpr(QualType T, Expr *Pattern, SourceLocation EllipsisLoc, - std::optional NumExpansions) + UnsignedOrNone NumExpansions) : Expr(PackExpansionExprClass, T, Pattern->getValueKind(), Pattern->getObjectKind()), EllipsisLoc(EllipsisLoc), @@ -4233,7 +4233,7 @@ class PackExpansionExpr : public Expr { /// Determine the number of expansions that will be produced when /// this pack expansion is instantiated, if already known. - std::optional getNumExpansions() const { + UnsignedOrNone getNumExpansions() const { if (NumExpansions) return NumExpansions - 1; @@ -4304,8 +4304,7 @@ class SizeOfPackExpr final /// the given parameter pack. SizeOfPackExpr(QualType SizeType, SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, - std::optional Length, - ArrayRef PartialArgs) + UnsignedOrNone Length, ArrayRef PartialArgs) : Expr(SizeOfPackExprClass, SizeType, VK_PRValue, OK_Ordinary), OperatorLoc(OperatorLoc), PackLoc(PackLoc), RParenLoc(RParenLoc), Length(Length ? *Length : PartialArgs.size()), Pack(Pack) { @@ -4325,7 +4324,7 @@ class SizeOfPackExpr final static SizeOfPackExpr *Create(ASTContext &Context, SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, - std::optional Length = std::nullopt, + UnsignedOrNone Length = std::nullopt, ArrayRef PartialArgs = {}); static SizeOfPackExpr *CreateDeserialized(ASTContext &Context, unsigned NumPartialArgs); @@ -4467,7 +4466,7 @@ class PackIndexingExpr final Expr *getIndexExpr() const { return cast(SubExprs[1]); } - std::optional getSelectedIndex() const { + UnsignedOrNone getSelectedIndex() const { if (isInstantiationDependent()) return std::nullopt; ConstantExpr *CE = cast(getIndexExpr()); @@ -4477,7 +4476,7 @@ class PackIndexingExpr final } Expr *getSelectedExpr() const { - std::optional Index = getSelectedIndex(); + UnsignedOrNone Index = getSelectedIndex(); assert(Index && "extracting the indexed expression of a dependant pack"); return getTrailingObjects()[*Index]; } @@ -4525,12 +4524,12 @@ class SubstNonTypeTemplateParmExpr : public Expr { SubstNonTypeTemplateParmExpr(QualType Ty, ExprValueKind ValueKind, SourceLocation Loc, Expr *Replacement, Decl *AssociatedDecl, unsigned Index, - std::optional PackIndex, bool RefParam, + UnsignedOrNone PackIndex, bool RefParam, bool Final) : Expr(SubstNonTypeTemplateParmExprClass, Ty, ValueKind, OK_Ordinary), Replacement(Replacement), AssociatedDeclAndRef(AssociatedDecl, RefParam), Index(Index), - PackIndex(PackIndex ? *PackIndex + 1 : 0), Final(Final) { + PackIndex(PackIndex.toInternalRepresentation()), Final(Final) { assert(AssociatedDecl != nullptr); SubstNonTypeTemplateParmExprBits.NameLoc = Loc; setDependence(computeDependence(this)); @@ -4552,10 +4551,8 @@ class SubstNonTypeTemplateParmExpr : public Expr { /// This should match the result of `getParameter()->getIndex()`. unsigned getIndex() const { return Index; } - std::optional getPackIndex() const { - if (PackIndex == 0) - return std::nullopt; - return PackIndex - 1; + UnsignedOrNone getPackIndex() const { + return UnsignedOrNone::fromInternalRepresentation(PackIndex); } // This substitution is Final, which means the substitution is fully @@ -4882,7 +4879,7 @@ class CXXFoldExpr : public Expr { SourceLocation RParenLoc; // When 0, the number of expansions is not known. Otherwise, this is one more // than the number of expansions. - unsigned NumExpansions; + UnsignedOrNone NumExpansions = std::nullopt; Stmt *SubExprs[SubExpr::Count]; BinaryOperatorKind Opcode; @@ -4890,7 +4887,7 @@ class CXXFoldExpr : public Expr { CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee, SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Opcode, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, - std::optional NumExpansions); + UnsignedOrNone NumExpansions); CXXFoldExpr(EmptyShell Empty) : Expr(CXXFoldExprClass, Empty) {} @@ -4919,11 +4916,7 @@ class CXXFoldExpr : public Expr { SourceLocation getEllipsisLoc() const { return EllipsisLoc; } BinaryOperatorKind getOperator() const { return Opcode; } - std::optional getNumExpansions() const { - if (NumExpansions) - return NumExpansions - 1; - return std::nullopt; - } + UnsignedOrNone getNumExpansions() const { return NumExpansions; } SourceLocation getBeginLoc() const LLVM_READONLY { if (LParenLoc.isValid()) diff --git a/clang/include/clang/AST/ExprObjC.h b/clang/include/clang/AST/ExprObjC.h index 1fccc26069582..f87fa85569c44 100644 --- a/clang/include/clang/AST/ExprObjC.h +++ b/clang/include/clang/AST/ExprObjC.h @@ -271,7 +271,7 @@ struct ObjCDictionaryElement { /// The number of elements this pack expansion will expand to, if /// this is a pack expansion and is known. - std::optional NumExpansions; + UnsignedOrNone NumExpansions; /// Determines whether this dictionary element is a pack expansion. bool isPackExpansion() const { return EllipsisLoc.isValid(); } diff --git a/clang/include/clang/AST/Mangle.h b/clang/include/clang/AST/Mangle.h index 9ed8895cbfff1..a0162fb7125fe 100644 --- a/clang/include/clang/AST/Mangle.h +++ b/clang/include/clang/AST/Mangle.h @@ -182,8 +182,8 @@ class MangleContext { class ItaniumMangleContext : public MangleContext { public: - using DiscriminatorOverrideTy = - std::optional (*)(ASTContext &, const NamedDecl *); + using DiscriminatorOverrideTy = UnsignedOrNone (*)(ASTContext &, + const NamedDecl *); explicit ItaniumMangleContext(ASTContext &C, DiagnosticsEngine &D, bool IsAux = false) : MangleContext(C, D, MK_Itanium, IsAux) {} diff --git a/clang/include/clang/AST/PropertiesBase.td b/clang/include/clang/AST/PropertiesBase.td index 0e360de16fdd6..90537d47dd9c9 100644 --- a/clang/include/clang/AST/PropertiesBase.td +++ b/clang/include/clang/AST/PropertiesBase.td @@ -144,6 +144,7 @@ def TemplateNameKind : EnumPropertyType<"TemplateName::NameKind">; def TypeOfKind : EnumPropertyType<"TypeOfKind">; def UInt32 : CountPropertyType<"uint32_t">; def UInt64 : CountPropertyType<"uint64_t">; +def UnsignedOrNone : PropertyType; def UnaryTypeTransformKind : EnumPropertyType<"UnaryTransformType::UTTKind">; def VectorKind : EnumPropertyType<"VectorKind">; def TypeCoupledDeclRefInfo : PropertyType; @@ -727,7 +728,7 @@ let Class = PropertyTypeCase in { def : Property<"index", UInt32> { let Read = [{ parm->getIndex() }]; } - def : Property<"packIndex", Optional> { + def : Property<"packIndex", UnsignedOrNone> { let Read = [{ parm->getPackIndex() }]; } def : Property<"final", Bool> { let Read = [{ parm->getFinal() }]; } @@ -860,21 +861,16 @@ let Class = PropertyTypeCase in { def : Property<"name", TemplateName> { let Read = [{ node.getAsTemplateOrTemplatePattern() }]; } - def : Property<"numExpansions", Optional> { + def : Property<"numExpansions", UnsignedOrNone> { let Read = [{ - // Translate unsigned -> uint32_t just in case. - llvm::transformOptional(node.getNumTemplateExpansions(), - [](unsigned i) { return uint32_t(i); }) + node.getNumTemplateExpansions() }]; } def : Property<"isDefaulted", Bool> { let Read = [{ node.getIsDefaulted() }]; } def : Creator<[{ - auto numExpansionsUnsigned = llvm::transformOptional( - numExpansions, [](uint32_t i) { return unsigned(i); }); - - return TemplateArgument(name, numExpansionsUnsigned, isDefaulted); + return TemplateArgument(name, numExpansions, isDefaulted); }]>; } let Class = PropertyTypeCase in { diff --git a/clang/include/clang/AST/TemplateBase.h b/clang/include/clang/AST/TemplateBase.h index 9d0ee24a4f5e3..a800a16fc3e7a 100644 --- a/clang/include/clang/AST/TemplateBase.h +++ b/clang/include/clang/AST/TemplateBase.h @@ -159,7 +159,7 @@ class TemplateArgument { unsigned Kind : 31; LLVM_PREFERRED_TYPE(bool) unsigned IsDefaulted : 1; - unsigned NumExpansions; + UnsignedOrNone NumExpansions; void *Name; }; struct TV { @@ -232,7 +232,7 @@ class TemplateArgument { TemplateArg.Kind = Template; TemplateArg.IsDefaulted = IsDefaulted; TemplateArg.Name = Name.getAsVoidPointer(); - TemplateArg.NumExpansions = 0; + TemplateArg.NumExpansions = std::nullopt; } /// Construct a template argument that is a template pack expansion. @@ -249,15 +249,12 @@ class TemplateArgument { /// /// \param IsDefaulted If 'true', implies that this TemplateArgument /// corresponds to a default template parameter - TemplateArgument(TemplateName Name, std::optional NumExpansions, + TemplateArgument(TemplateName Name, UnsignedOrNone NumExpansions, bool IsDefaulted = false) { TemplateArg.Kind = TemplateExpansion; TemplateArg.IsDefaulted = IsDefaulted; TemplateArg.Name = Name.getAsVoidPointer(); - if (NumExpansions) - TemplateArg.NumExpansions = *NumExpansions + 1; - else - TemplateArg.NumExpansions = 0; + TemplateArg.NumExpansions = NumExpansions; } /// Construct a template argument that is an expression. @@ -356,7 +353,7 @@ class TemplateArgument { /// Retrieve the number of expansions that a template template argument /// expansion will produce, if known. - std::optional getNumTemplateExpansions() const; + UnsignedOrNone getNumTemplateExpansions() const; /// Retrieve the template argument as an integral value. // FIXME: Provide a way to read the integral data without copying the value. diff --git a/clang/include/clang/AST/TemplateName.h b/clang/include/clang/AST/TemplateName.h index ece2afcfa72ab..63949f898f6a2 100644 --- a/clang/include/clang/AST/TemplateName.h +++ b/clang/include/clang/AST/TemplateName.h @@ -17,6 +17,7 @@ #include "clang/AST/NestedNameSpecifier.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/OperatorKinds.h" +#include "clang/Basic/UnsignedOrNone.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/PointerIntPair.h" #include "llvm/ADT/PointerUnion.h" @@ -414,11 +415,10 @@ class SubstTemplateTemplateParmStorage SubstTemplateTemplateParmStorage(TemplateName Replacement, Decl *AssociatedDecl, unsigned Index, - std::optional PackIndex, - bool Final) - : UncommonTemplateNameStorage(SubstTemplateTemplateParm, Index, - ((PackIndex ? *PackIndex + 1 : 0) << 1) | - Final), + UnsignedOrNone PackIndex, bool Final) + : UncommonTemplateNameStorage( + SubstTemplateTemplateParm, Index, + ((PackIndex.toInternalRepresentation()) << 1) | Final), Replacement(Replacement), AssociatedDecl(AssociatedDecl) { assert(AssociatedDecl != nullptr); } @@ -436,11 +436,8 @@ class SubstTemplateTemplateParmStorage // sugared: it doesn't need to be resugared later. bool getFinal() const { return Bits.Data & 1; } - std::optional getPackIndex() const { - auto Data = Bits.Data >> 1; - if (Data == 0) - return std::nullopt; - return Data - 1; + UnsignedOrNone getPackIndex() const { + return UnsignedOrNone::fromInternalRepresentation(Bits.Data >> 1); } TemplateTemplateParmDecl *getParameter() const; @@ -450,7 +447,7 @@ class SubstTemplateTemplateParmStorage static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Replacement, Decl *AssociatedDecl, unsigned Index, - std::optional PackIndex, bool Final); + UnsignedOrNone PackIndex, bool Final); }; class DeducedTemplateStorage : public UncommonTemplateNameStorage, diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h index 86ae335452980..06d60f618ddcb 100644 --- a/clang/include/clang/AST/Type.h +++ b/clang/include/clang/AST/Type.h @@ -5962,7 +5962,7 @@ class PackIndexingType final return *(getExpansionsPtr() + *getSelectedIndex()); } - std::optional getSelectedIndex() const; + UnsignedOrNone getSelectedIndex() const; bool hasSelectedType() const { return getSelectedIndex() != std::nullopt; } @@ -6400,7 +6400,7 @@ class SubstTemplateTypeParmType final Decl *AssociatedDecl; SubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl, - unsigned Index, std::optional PackIndex, + unsigned Index, UnsignedOrNone PackIndex, bool Final); public: @@ -6428,10 +6428,9 @@ class SubstTemplateTypeParmType final // sugared: it doesn't need to be resugared later. unsigned getFinal() const { return SubstTemplateTypeParmTypeBits.Final; } - std::optional getPackIndex() const { - if (SubstTemplateTypeParmTypeBits.PackIndex == 0) - return std::nullopt; - return SubstTemplateTypeParmTypeBits.PackIndex - 1; + UnsignedOrNone getPackIndex() const { + return UnsignedOrNone::fromInternalRepresentation( + SubstTemplateTypeParmTypeBits.PackIndex); } bool isSugared() const { return true; } @@ -6444,7 +6443,7 @@ class SubstTemplateTypeParmType final static void Profile(llvm::FoldingSetNodeID &ID, QualType Replacement, const Decl *AssociatedDecl, unsigned Index, - std::optional PackIndex, bool Final); + UnsignedOrNone PackIndex, bool Final); static bool classof(const Type *T) { return T->getTypeClass() == SubstTemplateTypeParm; @@ -7142,7 +7141,7 @@ class PackExpansionType : public Type, public llvm::FoldingSetNode { QualType Pattern; PackExpansionType(QualType Pattern, QualType Canon, - std::optional NumExpansions) + UnsignedOrNone NumExpansions) : Type(PackExpansion, Canon, (Pattern->getDependence() | TypeDependence::Dependent | TypeDependence::Instantiation) & @@ -7160,7 +7159,7 @@ class PackExpansionType : public Type, public llvm::FoldingSetNode { /// Retrieve the number of expansions that this pack expansion will /// generate, if known. - std::optional getNumExpansions() const { + UnsignedOrNone getNumExpansions() const { if (PackExpansionTypeBits.NumExpansions) return PackExpansionTypeBits.NumExpansions - 1; return std::nullopt; @@ -7174,11 +7173,9 @@ class PackExpansionType : public Type, public llvm::FoldingSetNode { } static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern, - std::optional NumExpansions) { + UnsignedOrNone NumExpansions) { ID.AddPointer(Pattern.getAsOpaquePtr()); - ID.AddBoolean(NumExpansions.has_value()); - if (NumExpansions) - ID.AddInteger(*NumExpansions); + ID.AddInteger(NumExpansions.toInternalRepresentation()); } static bool classof(const Type *T) { diff --git a/clang/include/clang/AST/TypeProperties.td b/clang/include/clang/AST/TypeProperties.td index 477106a152188..66d490850678a 100644 --- a/clang/include/clang/AST/TypeProperties.td +++ b/clang/include/clang/AST/TypeProperties.td @@ -839,7 +839,7 @@ let Class = SubstTemplateTypeParmType in { def : Property<"Index", UInt32> { let Read = [{ node->getIndex() }]; } - def : Property<"PackIndex", Optional> { + def : Property<"PackIndex", UnsignedOrNone> { let Read = [{ node->getPackIndex() }]; } def : Property<"Final", Bool> { let Read = [{ node->getFinal() }]; } @@ -854,7 +854,7 @@ let Class = PackExpansionType in { def : Property<"pattern", QualType> { let Read = [{ node->getPattern() }]; } - def : Property<"numExpansions", Optional> { + def : Property<"numExpansions", UnsignedOrNone> { let Read = [{ node->getNumExpansions() }]; } diff --git a/clang/include/clang/Basic/UnsignedOrNone.h b/clang/include/clang/Basic/UnsignedOrNone.h new file mode 100644 index 0000000000000..659fd8c6487d2 --- /dev/null +++ b/clang/include/clang/Basic/UnsignedOrNone.h @@ -0,0 +1,53 @@ +//===- UnsignedOrNone.h - simple optional index-----*- 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 +// +//===----------------------------------------------------------------------===// +// +/// \file +/// Defines clang::UnsignedOrNone. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_UNSIGNED_OR_NONE_H +#define LLVM_CLANG_BASIC_UNSIGNED_OR_NONE_H + +#include +#include + +namespace clang { + +struct UnsignedOrNone { + constexpr UnsignedOrNone(std::nullopt_t) : Rep(0) {} + UnsignedOrNone(unsigned Val) : Rep(Val + 1) { assert(operator bool()); } + UnsignedOrNone(int) = delete; + + constexpr static UnsignedOrNone fromInternalRepresentation(unsigned Rep) { + return {std::nullopt, Rep}; + } + constexpr unsigned toInternalRepresentation() const { return Rep; } + + explicit constexpr operator bool() const { return Rep != 0; } + unsigned operator*() const { + assert(operator bool()); + return Rep - 1; + } + + friend constexpr bool operator==(UnsignedOrNone LHS, UnsignedOrNone RHS) { + return LHS.Rep == RHS.Rep; + } + friend constexpr bool operator!=(UnsignedOrNone LHS, UnsignedOrNone RHS) { + return LHS.Rep != RHS.Rep; + } + +private: + constexpr UnsignedOrNone(std::nullopt_t, unsigned Rep) : Rep(Rep) {}; + + unsigned Rep; +}; + +} // namespace clang + +#endif // LLVM_CLANG_BASIC_UNSIGNED_OR_NONE_H diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index 1aa0e4a9917de..b835697f99670 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -6124,8 +6124,8 @@ class Sema final : public SemaBase { RecordDecl *ClassDecl, const IdentifierInfo *Name); - std::optional GetDecompositionElementCount(QualType DecompType, - SourceLocation Loc); + UnsignedOrNone GetDecompositionElementCount(QualType DecompType, + SourceLocation Loc); void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD); /// Stack containing information needed when in C++2a an 'auto' is encountered @@ -8890,10 +8890,11 @@ class Sema final : public SemaBase { Loc, ByRef, EllipsisLoc, std::nullopt, Id, InitKind != LambdaCaptureInitKind::CopyInit, Init)); } - QualType buildLambdaInitCaptureInitialization( - SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc, - std::optional NumExpansions, IdentifierInfo *Id, - bool DirectInit, Expr *&Init); + QualType buildLambdaInitCaptureInitialization(SourceLocation Loc, bool ByRef, + SourceLocation EllipsisLoc, + UnsignedOrNone NumExpansions, + IdentifierInfo *Id, + bool DirectInit, Expr *&Init); /// Create a dummy variable within the declcontext of the lambda's /// call operator, for name lookup purposes for a lambda init capture. @@ -13344,28 +13345,25 @@ class Sema final : public SemaBase { /// The current index into pack expansion arguments that will be /// used for substitution of parameter packs. /// - /// The pack expansion index will be -1 to indicate that parameter packs + /// The pack expansion index will be none to indicate that parameter packs /// should be instantiated as themselves. Otherwise, the index specifies /// which argument within the parameter pack will be used for substitution. - int ArgumentPackSubstitutionIndex; + UnsignedOrNone ArgPackSubstIndex; /// RAII object used to change the argument pack substitution index /// within a \c Sema object. /// - /// See \c ArgumentPackSubstitutionIndex for more information. - class ArgumentPackSubstitutionIndexRAII { + /// See \c ArgPackSubstIndex for more information. + class ArgPackSubstIndexRAII { Sema &Self; - int OldSubstitutionIndex; + UnsignedOrNone OldSubstIndex; public: - ArgumentPackSubstitutionIndexRAII(Sema &Self, int NewSubstitutionIndex) - : Self(Self), OldSubstitutionIndex(Self.ArgumentPackSubstitutionIndex) { - Self.ArgumentPackSubstitutionIndex = NewSubstitutionIndex; - } + ArgPackSubstIndexRAII(Sema &Self, UnsignedOrNone NewSubstIndex) + : Self(Self), + OldSubstIndex(std::exchange(Self.ArgPackSubstIndex, NewSubstIndex)) {} - ~ArgumentPackSubstitutionIndexRAII() { - Self.ArgumentPackSubstitutionIndex = OldSubstitutionIndex; - } + ~ArgPackSubstIndexRAII() { Self.ArgPackSubstIndex = OldSubstIndex; } }; friend class ArgumentPackSubstitutionRAII; @@ -13465,7 +13463,7 @@ class Sema final : public SemaBase { ParmVarDecl * SubstParmVarDecl(ParmVarDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, - int indexAdjustment, std::optional NumExpansions, + int indexAdjustment, UnsignedOrNone NumExpansions, bool ExpectParameterPack, bool EvaluateConstraints = true); /// Substitute the given template arguments into the given set of @@ -14315,13 +14313,13 @@ class Sema final : public SemaBase { /// expansion. TypeSourceInfo *CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, - std::optional NumExpansions); + UnsignedOrNone NumExpansions); /// Construct a pack expansion type from the pattern of the pack /// expansion. QualType CheckPackExpansion(QualType Pattern, SourceRange PatternRange, SourceLocation EllipsisLoc, - std::optional NumExpansions); + UnsignedOrNone NumExpansions); /// Invoked when parsing an expression followed by an ellipsis, which /// creates a pack expansion. @@ -14340,7 +14338,7 @@ class Sema final : public SemaBase { /// /// \param EllipsisLoc The location of the ellipsis. ExprResult CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, - std::optional NumExpansions); + UnsignedOrNone NumExpansions); /// Determine whether we could expand a pack expansion with the /// given set of parameter packs into separate arguments by repeatedly @@ -14380,7 +14378,7 @@ class Sema final : public SemaBase { SourceLocation EllipsisLoc, SourceRange PatternRange, ArrayRef Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand, - bool &RetainExpansion, std::optional &NumExpansions); + bool &RetainExpansion, UnsignedOrNone &NumExpansions); /// Determine the number of arguments in the given pack expansion /// type. @@ -14389,10 +14387,10 @@ class Sema final : public SemaBase { /// consistent across all of the unexpanded parameter packs in its pattern. /// /// Returns an empty Optional if the type can't be expanded. - std::optional getNumArgumentsInExpansion( + UnsignedOrNone getNumArgumentsInExpansion( QualType T, const MultiLevelTemplateArgumentList &TemplateArgs); - std::optional getNumArgumentsInExpansionFromUnexpanded( + UnsignedOrNone getNumArgumentsInExpansionFromUnexpanded( llvm::ArrayRef Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs); @@ -14421,9 +14419,10 @@ class Sema final : public SemaBase { /// /// \param NumExpansions Will be set to the number of expansions that will /// be generated from this pack expansion, if known a priori. - TemplateArgumentLoc getTemplateArgumentPackExpansionPattern( - TemplateArgumentLoc OrigLoc, SourceLocation &Ellipsis, - std::optional &NumExpansions) const; + TemplateArgumentLoc + getTemplateArgumentPackExpansionPattern(TemplateArgumentLoc OrigLoc, + SourceLocation &Ellipsis, + UnsignedOrNone &NumExpansions) const; /// Given a template argument that contains an unexpanded parameter pack, but /// which has already been substituted, attempt to determine the number of @@ -14431,7 +14430,7 @@ class Sema final : public SemaBase { /// /// This is intended for use when transforming 'sizeof...(Arg)' in order to /// avoid actually expanding the pack where possible. - std::optional getFullyPackExpandedSize(TemplateArgument Arg); + UnsignedOrNone getFullyPackExpandedSize(TemplateArgument Arg); /// Called when an expression computing the size of a parameter pack /// is parsed. @@ -14473,7 +14472,7 @@ class Sema final : public SemaBase { BinaryOperatorKind Operator, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, - std::optional NumExpansions); + UnsignedOrNone NumExpansions); ExprResult BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc, BinaryOperatorKind Operator); diff --git a/clang/include/clang/Sema/SemaLambda.h b/clang/include/clang/Sema/SemaLambda.h index 3c9d22df70c0d..a1d016f6ca289 100644 --- a/clang/include/clang/Sema/SemaLambda.h +++ b/clang/include/clang/Sema/SemaLambda.h @@ -31,7 +31,7 @@ class Sema; /// of the capture-capable lambda's LambdaScopeInfo. /// See Implementation for more detailed comments. -std::optional getStackIndexOfNearestEnclosingCaptureCapableLambda( +UnsignedOrNone getStackIndexOfNearestEnclosingCaptureCapableLambda( ArrayRef FunctionScopes, ValueDecl *VarToCapture, Sema &S); diff --git a/clang/include/clang/Sema/SemaOpenACC.h b/clang/include/clang/Sema/SemaOpenACC.h index 3291028c1b621..18d92e62d71a7 100644 --- a/clang/include/clang/Sema/SemaOpenACC.h +++ b/clang/include/clang/Sema/SemaOpenACC.h @@ -105,7 +105,7 @@ class SemaOpenACC : public SemaBase { /// This is the number of expressions on a 'tile' clause. This doesn't have /// to be an APSInt because it isn't the result of a constexpr, just by our /// own counting of elements. - std::optional CurTileCount; + UnsignedOrNone CurTileCount = std::nullopt; /// Records whether we've hit a 'CurTileCount' of '0' on the wya down, /// which allows us to diagnose if the number of arguments is too large for diff --git a/clang/include/clang/Sema/Template.h b/clang/include/clang/Sema/Template.h index 647c4cfa341e1..f9a10cfafb1f7 100644 --- a/clang/include/clang/Sema/Template.h +++ b/clang/include/clang/Sema/Template.h @@ -569,7 +569,7 @@ enum class TemplateSubstitutionKind : char { : public DeclVisitor { Sema &SemaRef; - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex; + Sema::ArgPackSubstIndexRAII SubstIndex; DeclContext *Owner; const MultiLevelTemplateArgumentList &TemplateArgs; Sema::LateInstantiatedAttrVec* LateAttrs = nullptr; @@ -595,8 +595,7 @@ enum class TemplateSubstitutionKind : char { public: TemplateDeclInstantiator(Sema &SemaRef, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs) - : SemaRef(SemaRef), - SubstIndex(SemaRef, SemaRef.ArgumentPackSubstitutionIndex), + : SemaRef(SemaRef), SubstIndex(SemaRef, SemaRef.ArgPackSubstIndex), Owner(Owner), TemplateArgs(TemplateArgs) {} void setEvaluateConstraints(bool B) { diff --git a/clang/include/clang/Sema/TemplateDeduction.h b/clang/include/clang/Sema/TemplateDeduction.h index 020e19bc7a608..39c909d73f565 100644 --- a/clang/include/clang/Sema/TemplateDeduction.h +++ b/clang/include/clang/Sema/TemplateDeduction.h @@ -301,7 +301,7 @@ struct DeductionFailureInfo { /// Return the index of the call argument that this deduction /// failure refers to, if any. - std::optional getCallArgIndex(); + UnsignedOrNone getCallArgIndex(); /// Free any memory associated with this deduction failure. void Destroy(); diff --git a/clang/include/clang/Serialization/ASTReader.h b/clang/include/clang/Serialization/ASTReader.h index 58fcc06c3696d..57ae4aa104d9a 100644 --- a/clang/include/clang/Serialization/ASTReader.h +++ b/clang/include/clang/Serialization/ASTReader.h @@ -2659,7 +2659,7 @@ inline bool shouldSkipCheckingODR(const Decl *D) { /// Calculate a hash value for the primary module name of the given module. /// \returns std::nullopt if M is not a C++ standard module. -std::optional getPrimaryModuleHash(const Module *M); +UnsignedOrNone getPrimaryModuleHash(const Module *M); } // namespace clang diff --git a/clang/include/clang/Serialization/ASTRecordReader.h b/clang/include/clang/Serialization/ASTRecordReader.h index 7117b7246739b..141804185083f 100644 --- a/clang/include/clang/Serialization/ASTRecordReader.h +++ b/clang/include/clang/Serialization/ASTRecordReader.h @@ -319,6 +319,10 @@ class ASTRecordReader return readInt(); } + UnsignedOrNone readUnsignedOrNone() { + return UnsignedOrNone::fromInternalRepresentation(unsigned(readInt())); + } + /// Read a string, advancing Idx. std::string readString() { return Reader->ReadString(Record, Idx); diff --git a/clang/include/clang/Serialization/ASTRecordWriter.h b/clang/include/clang/Serialization/ASTRecordWriter.h index 84d77e46016b7..e1fb239a9ce49 100644 --- a/clang/include/clang/Serialization/ASTRecordWriter.h +++ b/clang/include/clang/Serialization/ASTRecordWriter.h @@ -168,6 +168,10 @@ class ASTRecordWriter Record->push_back(Value); } + void writeUnsignedOrNone(UnsignedOrNone Value) { + Record->push_back(Value.toInternalRepresentation()); + } + /// Emit an integral value. void AddAPInt(const llvm::APInt &Value) { writeAPInt(Value); diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp index a73c15ae6bcc7..1b6b3d06ddc1e 100644 --- a/clang/lib/AST/ASTContext.cpp +++ b/clang/lib/AST/ASTContext.cpp @@ -732,11 +732,8 @@ ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID, if (const auto *TTP = dyn_cast(*P)) { ID.AddInteger(0); ID.AddBoolean(TTP->isParameterPack()); - if (TTP->isExpandedParameterPack()) { - ID.AddBoolean(true); - ID.AddInteger(TTP->getNumExpansionParameters()); - } else - ID.AddBoolean(false); + ID.AddInteger( + TTP->getNumExpansionParameters().toInternalRepresentation()); continue; } @@ -789,9 +786,7 @@ ASTContext::getCanonicalTemplateTemplateParmDecl( *this, getTranslationUnitDecl(), SourceLocation(), SourceLocation(), TTP->getDepth(), TTP->getIndex(), nullptr, false, TTP->isParameterPack(), /*HasTypeConstraint=*/false, - TTP->isExpandedParameterPack() - ? std::optional(TTP->getNumExpansionParameters()) - : std::nullopt); + TTP->getNumExpansionParameters()); CanonParams.push_back(NewTTP); } else if (const auto *NTTP = dyn_cast(*P)) { QualType T = getUnconstrainedType(getCanonicalType(NTTP->getType())); @@ -5445,9 +5440,11 @@ QualType ASTContext::getHLSLAttributedResourceType( return QualType(Ty, 0); } /// Retrieve a substitution-result type. -QualType ASTContext::getSubstTemplateTypeParmType( - QualType Replacement, Decl *AssociatedDecl, unsigned Index, - std::optional PackIndex, bool Final) const { +QualType ASTContext::getSubstTemplateTypeParmType(QualType Replacement, + Decl *AssociatedDecl, + unsigned Index, + UnsignedOrNone PackIndex, + bool Final) const { llvm::FoldingSetNodeID ID; SubstTemplateTypeParmType::Profile(ID, Replacement, AssociatedDecl, Index, PackIndex, Final); @@ -5863,7 +5860,7 @@ TemplateArgument ASTContext::getInjectedTemplateArg(NamedDecl *Param) const { TemplateName Name = getQualifiedTemplateName( nullptr, /*TemplateKeyword=*/false, TemplateName(TTP)); if (TTP->isParameterPack()) - Arg = TemplateArgument(Name, std::optional()); + Arg = TemplateArgument(Name, /*NumExpansions=*/std::nullopt); else Arg = TemplateArgument(Name); } @@ -5876,7 +5873,7 @@ TemplateArgument ASTContext::getInjectedTemplateArg(NamedDecl *Param) const { } QualType ASTContext::getPackExpansionType(QualType Pattern, - std::optional NumExpansions, + UnsignedOrNone NumExpansions, bool ExpectPackInType) const { assert((!ExpectPackInType || Pattern->containsUnexpandedParameterPack()) && "Pack expansions must expand one or more parameter packs"); @@ -6371,10 +6368,10 @@ QualType ASTContext::getDecltypeType(Expr *e, QualType UnderlyingType) const { QualType ASTContext::getPackIndexingType(QualType Pattern, Expr *IndexExpr, bool FullySubstituted, ArrayRef Expansions, - int Index) const { + UnsignedOrNone Index) const { QualType Canonical; - if (FullySubstituted && Index != -1) { - Canonical = getCanonicalType(Expansions[Index]); + if (FullySubstituted && Index) { + Canonical = getCanonicalType(Expansions[*Index]); } else { llvm::FoldingSetNodeID ID; PackIndexingType::Profile(ID, *this, Pattern.getCanonicalType(), IndexExpr, @@ -7072,7 +7069,7 @@ bool ASTContext::hasSameTemplateName(const TemplateName &X, bool ASTContext::isSameAssociatedConstraint( const AssociatedConstraint &ACX, const AssociatedConstraint &ACY) const { - if (ACX.ArgumentPackSubstitutionIndex != ACY.ArgumentPackSubstitutionIndex) + if (ACX.ArgPackSubstIndex != ACY.ArgPackSubstIndex) return false; if (!isSameConstraintExpr(ACX.ConstraintExpr, ACY.ConstraintExpr)) return false; @@ -10097,9 +10094,11 @@ ASTContext::getDependentTemplateName(const DependentTemplateStorage &S) const { return TemplateName(QTN); } -TemplateName ASTContext::getSubstTemplateTemplateParm( - TemplateName Replacement, Decl *AssociatedDecl, unsigned Index, - std::optional PackIndex, bool Final) const { +TemplateName ASTContext::getSubstTemplateTemplateParm(TemplateName Replacement, + Decl *AssociatedDecl, + unsigned Index, + UnsignedOrNone PackIndex, + bool Final) const { llvm::FoldingSetNodeID ID; SubstTemplateTemplateParmStorage::Profile(ID, Replacement, AssociatedDecl, Index, PackIndex, Final); @@ -12974,7 +12973,7 @@ MangleContext *ASTContext::createDeviceMangleContext(const TargetInfo &T) { case TargetCXXABI::XL: return ItaniumMangleContext::create( *this, getDiagnostics(), - [](ASTContext &, const NamedDecl *ND) -> std::optional { + [](ASTContext &, const NamedDecl *ND) -> UnsignedOrNone { if (const auto *RD = dyn_cast(ND)) return RD->getDeviceLambdaManglingNumber(); return std::nullopt; diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp index 73dc355003e6b..8c91cce22f78e 100644 --- a/clang/lib/AST/ASTImporter.cpp +++ b/clang/lib/AST/ASTImporter.cpp @@ -4354,7 +4354,7 @@ static bool IsEquivalentFriend(ASTImporter &Importer, FriendDecl *FD1, static FriendCountAndPosition getFriendCountAndPosition(ASTImporter &Importer, FriendDecl *FD) { unsigned int FriendCount = 0; - std::optional FriendPosition; + UnsignedOrNone FriendPosition = std::nullopt; const auto *RD = cast(FD->getLexicalDeclContext()); for (FriendDecl *FoundFriend : RD->friends()) { @@ -5976,8 +5976,7 @@ ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { if (Err) return std::move(Err); - ToD->setTypeConstraint(ToConceptRef, ToIDC, - TC->getArgumentPackSubstitutionIndex()); + ToD->setTypeConstraint(ToConceptRef, ToIDC, TC->getArgPackSubstIndex()); } if (Error Err = importTemplateParameterDefaultArgument(D, ToD)) @@ -8293,7 +8292,7 @@ ExpectedStmt ASTNodeImporter::VisitSizeOfPackExpr(SizeOfPackExpr *E) { if (Err) return std::move(Err); - std::optional Length; + UnsignedOrNone Length = std::nullopt; if (!E->isValueDependent()) Length = E->getPackLength(); @@ -9043,7 +9042,7 @@ ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager, ASTImporter::~ASTImporter() = default; -std::optional ASTImporter::getFieldIndex(Decl *F) { +UnsignedOrNone ASTImporter::getFieldIndex(Decl *F) { assert(F && (isa(*F) || isa(*F)) && "Try to get field index for non-field."); diff --git a/clang/lib/AST/ASTStructuralEquivalence.cpp b/clang/lib/AST/ASTStructuralEquivalence.cpp index c769722521d9c..2c7cb581ccfaa 100644 --- a/clang/lib/AST/ASTStructuralEquivalence.cpp +++ b/clang/lib/AST/ASTStructuralEquivalence.cpp @@ -1656,9 +1656,9 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, if (!D1->getDeclName() && !D2->getDeclName()) { // If both anonymous structs/unions are in a record context, make sure // they occur in the same location in the context records. - if (std::optional Index1 = + if (UnsignedOrNone Index1 = StructuralEquivalenceContext::findUntaggedStructOrUnionIndex(D1)) { - if (std::optional Index2 = + if (UnsignedOrNone Index2 = StructuralEquivalenceContext::findUntaggedStructOrUnionIndex( D2)) { if (*Index1 != *Index2) @@ -2345,7 +2345,7 @@ DiagnosticBuilder StructuralEquivalenceContext::Diag2(SourceLocation Loc, return ToCtx.getDiagnostics().Report(Loc, DiagID); } -std::optional +UnsignedOrNone StructuralEquivalenceContext::findUntaggedStructOrUnionIndex(RecordDecl *Anon) { ASTContext &Context = Anon->getASTContext(); QualType AnonTy = Context.getRecordType(Anon); diff --git a/clang/lib/AST/ComputeDependence.cpp b/clang/lib/AST/ComputeDependence.cpp index 07c4419e3cf40..fd2eefa1cf076 100644 --- a/clang/lib/AST/ComputeDependence.cpp +++ b/clang/lib/AST/ComputeDependence.cpp @@ -391,7 +391,7 @@ ExprDependence clang::computeDependence(PackIndexingExpr *E) { if (Exprs.empty() || !E->isFullySubstituted()) D |= PatternDep | ExprDependence::Instantiation; else if (!E->getIndexExpr()->isInstantiationDependent()) { - std::optional Index = E->getSelectedIndex(); + UnsignedOrNone Index = E->getSelectedIndex(); assert(Index && *Index < Exprs.size() && "pack index out of bound"); D |= Exprs[*Index]->getDependence(); } diff --git a/clang/lib/AST/Decl.cpp b/clang/lib/AST/Decl.cpp index 568d74cc7df0b..0e4d69392e8c7 100644 --- a/clang/lib/AST/Decl.cpp +++ b/clang/lib/AST/Decl.cpp @@ -3386,7 +3386,7 @@ bool FunctionDecl::isReservedGlobalPlacementOperator() const { } bool FunctionDecl::isReplaceableGlobalAllocationFunction( - std::optional *AlignmentParam, bool *IsNothrow) const { + UnsignedOrNone *AlignmentParam, bool *IsNothrow) const { if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName) return false; if (getDeclName().getCXXOverloadedOperator() != OO_New && diff --git a/clang/lib/AST/DeclTemplate.cpp b/clang/lib/AST/DeclTemplate.cpp index b0bba8408f2b9..e8e2cad721981 100644 --- a/clang/lib/AST/DeclTemplate.cpp +++ b/clang/lib/AST/DeclTemplate.cpp @@ -172,7 +172,7 @@ unsigned TemplateParameterList::getMinRequiredArguments() const { unsigned NumRequiredArgs = 0; for (const NamedDecl *P : asArray()) { if (P->isTemplateParameterPack()) { - if (std::optional Expansions = getExpandedPackSize(P)) { + if (UnsignedOrNone Expansions = getExpandedPackSize(P)) { NumRequiredArgs += *Expansions; continue; } @@ -230,7 +230,7 @@ void TemplateParameterList::getAssociatedConstraints( if (const auto *TTP = dyn_cast(Param)) { if (const auto *TC = TTP->getTypeConstraint()) ACs.emplace_back(TC->getImmediatelyDeclaredConstraint(), - TC->getArgumentPackSubstitutionIndex()); + TC->getArgPackSubstIndex()); } else if (const auto *NTTP = dyn_cast(Param)) { if (const Expr *E = NTTP->getPlaceholderTypeConstraint()) ACs.emplace_back(E); @@ -684,7 +684,7 @@ TemplateTypeParmDecl *TemplateTypeParmDecl::Create( const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint, - std::optional NumExpanded) { + UnsignedOrNone NumExpanded) { auto *TTPDecl = new (C, DC, additionalSizeToAlloc(HasTypeConstraint ? 1 : 0)) @@ -750,14 +750,14 @@ bool TemplateTypeParmDecl::isParameterPack() const { void TemplateTypeParmDecl::setTypeConstraint( ConceptReference *Loc, Expr *ImmediatelyDeclaredConstraint, - int ArgumentPackSubstitutionIndex) { + UnsignedOrNone ArgPackSubstIndex) { assert(HasTypeConstraint && "HasTypeConstraint=true must be passed at construction in order to " "call setTypeConstraint"); assert(!TypeConstraintInitialized && "TypeConstraint was already initialized!"); - new (getTrailingObjects()) TypeConstraint( - Loc, ImmediatelyDeclaredConstraint, ArgumentPackSubstitutionIndex); + new (getTrailingObjects()) + TypeConstraint(Loc, ImmediatelyDeclaredConstraint, ArgPackSubstIndex); TypeConstraintInitialized = true; } diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp index 9d5b4a60c9fe7..389fa70a61b4b 100644 --- a/clang/lib/AST/Expr.cpp +++ b/clang/lib/AST/Expr.cpp @@ -596,7 +596,7 @@ std::string SYCLUniqueStableNameExpr::ComputeName(ASTContext &Context) const { std::string SYCLUniqueStableNameExpr::ComputeName(ASTContext &Context, QualType Ty) { auto MangleCallback = [](ASTContext &Ctx, - const NamedDecl *ND) -> std::optional { + const NamedDecl *ND) -> UnsignedOrNone { if (const auto *RD = dyn_cast(ND)) return RD->getDeviceLambdaManglingNumber(); return std::nullopt; diff --git a/clang/lib/AST/ExprCXX.cpp b/clang/lib/AST/ExprCXX.cpp index 77add7b0b6abe..b12f655c4b386 100644 --- a/clang/lib/AST/ExprCXX.cpp +++ b/clang/lib/AST/ExprCXX.cpp @@ -1694,7 +1694,7 @@ SizeOfPackExpr *SizeOfPackExpr::Create(ASTContext &Context, SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, - std::optional Length, + UnsignedOrNone Length, ArrayRef PartialArgs) { void *Storage = Context.Allocate(totalSizeToAlloc(PartialArgs.size())); @@ -1981,14 +1981,13 @@ CXXParenListInitExpr *CXXParenListInitExpr::CreateEmpty(ASTContext &C, } CXXFoldExpr::CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee, - SourceLocation LParenLoc, Expr *LHS, - BinaryOperatorKind Opcode, - SourceLocation EllipsisLoc, Expr *RHS, - SourceLocation RParenLoc, - std::optional NumExpansions) + SourceLocation LParenLoc, Expr *LHS, + BinaryOperatorKind Opcode, SourceLocation EllipsisLoc, + Expr *RHS, SourceLocation RParenLoc, + UnsignedOrNone NumExpansions) : Expr(CXXFoldExprClass, T, VK_PRValue, OK_Ordinary), LParenLoc(LParenLoc), EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc), - NumExpansions(NumExpansions ? *NumExpansions + 1 : 0), Opcode(Opcode) { + NumExpansions(NumExpansions), Opcode(Opcode) { // We rely on asserted invariant to distinguish left and right folds. assert(((LHS && LHS->containsUnexpandedParameterPack()) != (RHS && RHS->containsUnexpandedParameterPack())) && diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp index eb9c9c30622ad..fdd84d0bf7c5c 100644 --- a/clang/lib/AST/ItaniumMangle.cpp +++ b/clang/lib/AST/ItaniumMangle.cpp @@ -1641,7 +1641,7 @@ void CXXNameMangler::mangleUnqualifiedName( // ::= * + // # Parameter types or 'v' for 'void'. if (const CXXRecordDecl *Record = dyn_cast(TD)) { - std::optional DeviceNumber = + UnsignedOrNone DeviceNumber = Context.getDiscriminatorOverride()(Context.getASTContext(), Record); // If we have a device-number via the discriminator, use that to mangle @@ -2136,7 +2136,7 @@ void CXXNameMangler::mangleLambda(const CXXRecordDecl *Lambda) { // if the host-side CXX ABI has different numbering for lambda. In such case, // if the mangle context is that device-side one, use the device-side lambda // mangling number for this lambda. - std::optional DeviceNumber = + UnsignedOrNone DeviceNumber = Context.getDiscriminatorOverride()(Context.getASTContext(), Lambda); unsigned Number = DeviceNumber ? *DeviceNumber : Lambda->getLambdaManglingNumber(); @@ -7540,7 +7540,7 @@ ItaniumMangleContext *ItaniumMangleContext::create(ASTContext &Context, bool IsAux) { return new ItaniumMangleContextImpl( Context, Diags, - [](ASTContext &, const NamedDecl *) -> std::optional { + [](ASTContext &, const NamedDecl *) -> UnsignedOrNone { return std::nullopt; }, IsAux); diff --git a/clang/lib/AST/JSONNodeDumper.cpp b/clang/lib/AST/JSONNodeDumper.cpp index e5e7bd31f73e9..3420c1f343cf5 100644 --- a/clang/lib/AST/JSONNodeDumper.cpp +++ b/clang/lib/AST/JSONNodeDumper.cpp @@ -818,7 +818,7 @@ void JSONNodeDumper::VisitObjCInterfaceType(const ObjCInterfaceType *OIT) { } void JSONNodeDumper::VisitPackExpansionType(const PackExpansionType *PET) { - if (std::optional N = PET->getNumExpansions()) + if (UnsignedOrNone N = PET->getNumExpansions()) JOS.attribute("numExpansions", *N); } diff --git a/clang/lib/AST/TemplateBase.cpp b/clang/lib/AST/TemplateBase.cpp index 0eef8f305fcb3..0be0a83b7010d 100644 --- a/clang/lib/AST/TemplateBase.cpp +++ b/clang/lib/AST/TemplateBase.cpp @@ -344,12 +344,9 @@ bool TemplateArgument::containsUnexpandedParameterPack() const { return getDependence() & TemplateArgumentDependence::UnexpandedPack; } -std::optional TemplateArgument::getNumTemplateExpansions() const { +UnsignedOrNone TemplateArgument::getNumTemplateExpansions() const { assert(getKind() == TemplateExpansion); - if (TemplateArg.NumExpansions) - return TemplateArg.NumExpansions - 1; - - return std::nullopt; + return TemplateArg.NumExpansions; } QualType TemplateArgument::getNonTypeTemplateArgumentType() const { @@ -401,7 +398,7 @@ void TemplateArgument::Profile(llvm::FoldingSetNodeID &ID, break; case TemplateExpansion: - ID.AddInteger(TemplateArg.NumExpansions); + ID.AddInteger(TemplateArg.NumExpansions.toInternalRepresentation()); [[fallthrough]]; case Template: ID.AddPointer(TemplateArg.Name); diff --git a/clang/lib/AST/TemplateName.cpp b/clang/lib/AST/TemplateName.cpp index f8ba5a24c7519..4404552f84fbb 100644 --- a/clang/lib/AST/TemplateName.cpp +++ b/clang/lib/AST/TemplateName.cpp @@ -83,11 +83,11 @@ void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID) { void SubstTemplateTemplateParmStorage::Profile( llvm::FoldingSetNodeID &ID, TemplateName Replacement, Decl *AssociatedDecl, - unsigned Index, std::optional PackIndex, bool Final) { + unsigned Index, UnsignedOrNone PackIndex, bool Final) { Replacement.Profile(ID); ID.AddPointer(AssociatedDecl); ID.AddInteger(Index); - ID.AddInteger(PackIndex ? *PackIndex + 1 : 0); + ID.AddInteger(PackIndex.toInternalRepresentation()); ID.AddBoolean(Final); } diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp index d35b2f5d9ab6d..05f1953aa473c 100644 --- a/clang/lib/AST/TextNodeDumper.cpp +++ b/clang/lib/AST/TextNodeDumper.cpp @@ -1296,7 +1296,7 @@ void TextNodeDumper::dumpBareTemplateName(TemplateName TN) { const SubstTemplateTemplateParmStorage *STS = TN.getAsSubstTemplateTemplateParm(); OS << " index " << STS->getIndex(); - if (std::optional PackIndex = STS->getPackIndex()) + if (UnsignedOrNone PackIndex = STS->getPackIndex()) OS << " pack_index " << *PackIndex; if (STS->getFinal()) OS << " final"; diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp index 4669bf5541493..879ad1a7eaa84 100644 --- a/clang/lib/AST/Type.cpp +++ b/clang/lib/AST/Type.cpp @@ -4059,7 +4059,7 @@ PackIndexingType::PackIndexingType(const ASTContext &Context, getTrailingObjects()); } -std::optional PackIndexingType::getSelectedIndex() const { +UnsignedOrNone PackIndexingType::getSelectedIndex() const { if (isInstantiationDependentType()) return std::nullopt; // Should only be not a constant for error recovery. @@ -4261,9 +4261,11 @@ static const TemplateTypeParmDecl *getReplacedParameter(Decl *D, getReplacedTemplateParameterList(D)->getParam(Index)); } -SubstTemplateTypeParmType::SubstTemplateTypeParmType( - QualType Replacement, Decl *AssociatedDecl, unsigned Index, - std::optional PackIndex, bool Final) +SubstTemplateTypeParmType::SubstTemplateTypeParmType(QualType Replacement, + Decl *AssociatedDecl, + unsigned Index, + UnsignedOrNone PackIndex, + bool Final) : Type(SubstTemplateTypeParm, Replacement.getCanonicalType(), Replacement->getDependence()), AssociatedDecl(AssociatedDecl) { @@ -4274,7 +4276,8 @@ SubstTemplateTypeParmType::SubstTemplateTypeParmType( SubstTemplateTypeParmTypeBits.Index = Index; SubstTemplateTypeParmTypeBits.Final = Final; - SubstTemplateTypeParmTypeBits.PackIndex = PackIndex ? *PackIndex + 1 : 0; + SubstTemplateTypeParmTypeBits.PackIndex = + PackIndex.toInternalRepresentation(); assert(AssociatedDecl != nullptr); } @@ -4287,12 +4290,11 @@ void SubstTemplateTypeParmType::Profile(llvm::FoldingSetNodeID &ID, QualType Replacement, const Decl *AssociatedDecl, unsigned Index, - std::optional PackIndex, - bool Final) { + UnsignedOrNone PackIndex, bool Final) { Replacement.Profile(ID); ID.AddPointer(AssociatedDecl); ID.AddInteger(Index); - ID.AddInteger(PackIndex ? *PackIndex - 1 : 0); + ID.AddInteger(PackIndex.toInternalRepresentation()); ID.AddBoolean(Final); } diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp index 93a2d797679d4..64f5633f380ec 100644 --- a/clang/lib/Sema/Sema.cpp +++ b/clang/lib/Sema/Sema.cpp @@ -263,7 +263,7 @@ Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, TyposCorrected(0), IsBuildingRecoveryCallExpr(false), NumSFINAEErrors(0), AccessCheckingSFINAE(false), CurrentInstantiationScope(nullptr), InNonInstantiationSFINAEContext(false), NonInstantiationEntries(0), - ArgumentPackSubstitutionIndex(-1), SatisfactionCache(Context) { + ArgPackSubstIndex(std::nullopt), SatisfactionCache(Context) { assert(pp.TUKind == TUKind); TUScope = nullptr; diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp index e10c49203725f..011a6d072d35c 100644 --- a/clang/lib/Sema/SemaConcept.cpp +++ b/clang/lib/Sema/SemaConcept.cpp @@ -289,7 +289,7 @@ static ExprResult EvaluateAtomicConstraint( return SubstitutedExpression; } -std::optional static EvaluateFoldExpandedConstraintSize( +static UnsignedOrNone EvaluateFoldExpandedConstraintSize( Sema &S, const CXXFoldExpr *FE, const NamedDecl *Template, SourceLocation TemplateNameLoc, const MultiLevelTemplateArgumentList &MLTAL, ConstraintSatisfaction &Satisfaction) { @@ -304,15 +304,14 @@ std::optional static EvaluateFoldExpandedConstraintSize( assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); bool Expand = true; bool RetainExpansion = false; - std::optional OrigNumExpansions = FE->getNumExpansions(), - NumExpansions = OrigNumExpansions; + UnsignedOrNone NumExpansions = FE->getNumExpansions(); if (S.CheckParameterPacksForExpansion( FE->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded, MLTAL, Expand, RetainExpansion, NumExpansions) || !Expand || RetainExpansion) return std::nullopt; - if (NumExpansions && S.getLangOpts().BracketDepth < NumExpansions) { + if (NumExpansions && S.getLangOpts().BracketDepth < *NumExpansions) { S.Diag(FE->getEllipsisLoc(), clang::diag::err_fold_expression_limit_exceeded) << *NumExpansions << S.getLangOpts().BracketDepth @@ -413,12 +412,12 @@ static ExprResult calculateConstraintSatisfaction( if (Conjunction != Satisfaction.IsSatisfied) return Out; } - std::optional NumExpansions = EvaluateFoldExpandedConstraintSize( + UnsignedOrNone NumExpansions = EvaluateFoldExpandedConstraintSize( S, FE, Template, TemplateNameLoc, MLTAL, Satisfaction); if (!NumExpansions) return ExprError(); for (unsigned I = 0; I < *NumExpansions; I++) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, I); + Sema::ArgPackSubstIndexRAII SubstIndex(S, I); ExprResult Res = calculateConstraintSatisfaction( S, FE->getPattern(), Template, TemplateNameLoc, MLTAL, Satisfaction); if (Res.isInvalid()) @@ -589,8 +588,7 @@ static bool CheckConstraintSatisfaction( return true; for (const AssociatedConstraint &AC : AssociatedConstraints) { - Sema::ArgumentPackSubstitutionIndexRAII _(S, - AC.ArgumentPackSubstitutionIndex); + Sema::ArgPackSubstIndexRAII _(S, AC.ArgPackSubstIndex); ExprResult Res = calculateConstraintSatisfaction( S, Template, TemplateIDRange.getBegin(), TemplateArgsLists, AC.ConstraintExpr, Satisfaction); @@ -1406,7 +1404,7 @@ substituteParameterMappings(Sema &S, NormalizedConstraint &N, } if (N.isFoldExpanded()) { - Sema::ArgumentPackSubstitutionIndexRAII _(S, -1); + Sema::ArgPackSubstIndexRAII _(S, std::nullopt); return substituteParameterMappings( S, N.getFoldExpandedConstraint()->Constraint, Concept, MLTAL, ArgsAsWritten); diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index a675feaf50ce3..d630f9bd409fd 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -16749,7 +16749,7 @@ void Sema::AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction( FD->getDeclName().getCXXOverloadedOperator() != OO_Array_New) return; - std::optional AlignmentParam; + UnsignedOrNone AlignmentParam = std::nullopt; bool IsNothrow = false; if (!FD->isReplaceableGlobalAllocationFunction(&AlignmentParam, &IsNothrow)) return; diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp index 47c472b35463e..07379c6876731 100644 --- a/clang/lib/Sema/SemaDeclCXX.cpp +++ b/clang/lib/Sema/SemaDeclCXX.cpp @@ -1660,8 +1660,8 @@ void Sema::CheckCompleteDecompositionDeclaration(DecompositionDecl *DD) { DD->setInvalidDecl(); } -std::optional Sema::GetDecompositionElementCount(QualType T, - SourceLocation Loc) { +UnsignedOrNone Sema::GetDecompositionElementCount(QualType T, + SourceLocation Loc) { const ASTContext &Ctx = getASTContext(); assert(!T->isDependentType()); @@ -1671,18 +1671,18 @@ std::optional Sema::GetDecompositionElementCount(QualType T, T = Context.getQualifiedType(Unqual, Quals); if (auto *CAT = Ctx.getAsConstantArrayType(T)) - return CAT->getSize().getZExtValue(); + return static_cast(CAT->getSize().getZExtValue()); if (auto *VT = T->getAs()) return VT->getNumElements(); if (T->getAs()) - return 2; + return 2u; llvm::APSInt TupleSize(Ctx.getTypeSize(Ctx.getSizeType())); switch (isTupleLike(*this, Loc, T, TupleSize)) { case IsTupleLike::Error: return std::nullopt; case IsTupleLike::TupleLike: - return TupleSize.getExtValue(); + return static_cast(TupleSize.getExtValue()); case IsTupleLike::NotTupleLike: break; } diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp index 78eba8e262771..e43f5e3f75bfe 100644 --- a/clang/lib/Sema/SemaExprCXX.cpp +++ b/clang/lib/Sema/SemaExprCXX.cpp @@ -1995,7 +1995,7 @@ Sema::isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const { return false; if (FD.isDefined()) return false; - std::optional AlignmentParam; + UnsignedOrNone AlignmentParam = std::nullopt; if (FD.isReplaceableGlobalAllocationFunction(&AlignmentParam) && AlignmentParam) return true; @@ -5818,7 +5818,7 @@ static APValue EvaluateSizeTTypeTrait(Sema &S, TypeTrait Kind, case TypeTrait::UTT_StructuredBindingSize: { QualType T = Args[0]->getType(); SourceRange ArgRange = Args[0]->getTypeLoc().getSourceRange(); - std::optional Size = + UnsignedOrNone Size = S.GetDecompositionElementCount(T, ArgRange.getBegin()); if (!Size) { S.Diag(KWLoc, diag::err_arg_is_not_destructurable) << T << ArgRange; @@ -8777,7 +8777,7 @@ static void CheckIfAnyEnclosingLambdasMustCaptureAnyPotentialCaptures( // If we have a capture-capable lambda for the variable, go ahead and // capture the variable in that lambda (and all its enclosing lambdas). - if (const std::optional Index = + if (const UnsignedOrNone Index = getStackIndexOfNearestEnclosingCaptureCapableLambda( S.FunctionScopes, Var, S)) S.MarkCaptureUsedInEnclosingContext(Var, VarExpr->getExprLoc(), *Index); @@ -8810,7 +8810,7 @@ static void CheckIfAnyEnclosingLambdasMustCaptureAnyPotentialCaptures( if (CurrentLSI->hasPotentialThisCapture()) { // If we have a capture-capable lambda for 'this', go ahead and capture // 'this' in that lambda (and all its enclosing lambdas). - if (const std::optional Index = + if (const UnsignedOrNone Index = getStackIndexOfNearestEnclosingCaptureCapableLambda( S.FunctionScopes, /*0 is 'this'*/ nullptr, S)) { const unsigned FunctionScopeIndexOfCapturableLambda = *Index; diff --git a/clang/lib/Sema/SemaLambda.cpp b/clang/lib/Sema/SemaLambda.cpp index f38198e1feab8..1183a04d3bf33 100644 --- a/clang/lib/Sema/SemaLambda.cpp +++ b/clang/lib/Sema/SemaLambda.cpp @@ -62,17 +62,16 @@ using namespace sema; /// is at the top of the stack and has the highest index. /// \param VarToCapture - the variable to capture. If NULL, capture 'this'. /// -/// \returns An std::optional Index that if evaluates to 'true' +/// \returns An UnsignedOrNone Index that if evaluates to 'true' /// contains the index (into Sema's FunctionScopeInfo stack) of the innermost /// lambda which is capture-ready. If the return value evaluates to 'false' /// then no lambda is capture-ready for \p VarToCapture. -static inline std::optional -getStackIndexOfNearestEnclosingCaptureReadyLambda( +static inline UnsignedOrNone getStackIndexOfNearestEnclosingCaptureReadyLambda( ArrayRef FunctionScopes, ValueDecl *VarToCapture) { // Label failure to capture. - const std::optional NoLambdaIsCaptureReady; + const UnsignedOrNone NoLambdaIsCaptureReady = std::nullopt; // Ignore all inner captured regions. unsigned CurScopeIndex = FunctionScopes.size() - 1; @@ -173,19 +172,18 @@ getStackIndexOfNearestEnclosingCaptureReadyLambda( /// \param VarToCapture - the variable to capture. If NULL, capture 'this'. /// /// -/// \returns An std::optional Index that if evaluates to 'true' +/// \returns An UnsignedOrNone Index that if evaluates to 'true' /// contains the index (into Sema's FunctionScopeInfo stack) of the innermost /// lambda which is capture-capable. If the return value evaluates to 'false' /// then no lambda is capture-capable for \p VarToCapture. -std::optional -clang::getStackIndexOfNearestEnclosingCaptureCapableLambda( +UnsignedOrNone clang::getStackIndexOfNearestEnclosingCaptureCapableLambda( ArrayRef FunctionScopes, ValueDecl *VarToCapture, Sema &S) { - const std::optional NoLambdaIsCaptureCapable; + const UnsignedOrNone NoLambdaIsCaptureCapable = std::nullopt; - const std::optional OptionalStackIndex = + const UnsignedOrNone OptionalStackIndex = getStackIndexOfNearestEnclosingCaptureReadyLambda(FunctionScopes, VarToCapture); if (!OptionalStackIndex) @@ -808,8 +806,8 @@ void Sema::deduceClosureReturnType(CapturingScopeInfo &CSI) { QualType Sema::buildLambdaInitCaptureInitialization( SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc, - std::optional NumExpansions, IdentifierInfo *Id, - bool IsDirectInit, Expr *&Init) { + UnsignedOrNone NumExpansions, IdentifierInfo *Id, bool IsDirectInit, + Expr *&Init) { // Create an 'auto' or 'auto&' TypeSourceInfo that we can use to // deduce against. QualType DeductType = Context.getAutoDeductType(); @@ -1462,9 +1460,8 @@ void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro, CompleteLambdaCallOperator( Method, Intro.Range.getBegin(), CallOperatorLoc, - AssociatedConstraint(ParamInfo.getTrailingRequiresClause(), - /*ArgumentPackSubstitutionIndex=*/-1), - MethodTyInfo, ParamInfo.getDeclSpec().getConstexprSpecifier(), + AssociatedConstraint(ParamInfo.getTrailingRequiresClause()), MethodTyInfo, + ParamInfo.getDeclSpec().getConstexprSpecifier(), IsLambdaStatic ? SC_Static : SC_None, Params, ExplicitResultType); CheckCXXDefaultArguments(Method); diff --git a/clang/lib/Sema/SemaOpenACC.cpp b/clang/lib/Sema/SemaOpenACC.cpp index 231e73fdbc9ec..819fb0853e8f5 100644 --- a/clang/lib/Sema/SemaOpenACC.cpp +++ b/clang/lib/Sema/SemaOpenACC.cpp @@ -285,7 +285,8 @@ void SemaOpenACC::AssociatedStmtRAII::SetTileInfoBeforeAssociatedStmt( OpenACCTileClause *TileClause = cast(*TileClauseItr); SemaRef.TileInfo.ActiveTile = TileClause; SemaRef.TileInfo.TileDepthSatisfied = false; - SemaRef.TileInfo.CurTileCount = TileClause->getSizeExprs().size(); + SemaRef.TileInfo.CurTileCount = + static_cast(TileClause->getSizeExprs().size()); SemaRef.TileInfo.DirectiveKind = DirKind; } @@ -911,7 +912,7 @@ void SemaOpenACC::ForStmtBeginHelper(SourceLocation ForLoc, diag::note_acc_active_clause_here) << OpenACCClauseKind::Tile; } else { - --(*TileInfo.CurTileCount); + TileInfo.CurTileCount = *TileInfo.CurTileCount - 1; // Once we've hit zero here, we know we have deep enough 'for' loops to // get to the bottom. if (*TileInfo.CurTileCount == 0) diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp index d9a79bc802b56..0564557738170 100644 --- a/clang/lib/Sema/SemaOverload.cpp +++ b/clang/lib/Sema/SemaOverload.cpp @@ -1002,7 +1002,7 @@ const TemplateArgument *DeductionFailureInfo::getSecondArg() { return nullptr; } -std::optional DeductionFailureInfo::getCallArgIndex() { +UnsignedOrNone DeductionFailureInfo::getCallArgIndex() { switch (static_cast(Result)) { case TemplateDeductionResult::DeducedMismatch: case TemplateDeductionResult::DeducedMismatchNested: @@ -1555,8 +1555,7 @@ static bool IsOverloadOrOverrideImpl(Sema &SemaRef, FunctionDecl *New, OldRC = Old->getTrailingRequiresClause(); if (!NewRC != !OldRC) return true; - if (NewRC.ArgumentPackSubstitutionIndex != - OldRC.ArgumentPackSubstitutionIndex) + if (NewRC.ArgPackSubstIndex != OldRC.ArgPackSubstIndex) return true; if (NewRC && !SemaRef.AreConstraintExpressionsEqual(OldDecl, OldRC.ConstraintExpr, diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp index 8cf65ebe03c07..153f44f8ec67a 100644 --- a/clang/lib/Sema/SemaTemplate.cpp +++ b/clang/lib/Sema/SemaTemplate.cpp @@ -916,7 +916,7 @@ static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef, TemplateName Template = Arg.getAsTemplate().get(); TemplateArgument TArg; if (Arg.getEllipsisLoc().isValid()) - TArg = TemplateArgument(Template, std::optional()); + TArg = TemplateArgument(Template, /*NumExpansions=*/std::nullopt); else TArg = Template; return TemplateArgumentLoc( @@ -1220,9 +1220,8 @@ bool Sema::AttachTypeConstraint(NestedNameSpecifierLoc NS, /*FoundDecl=*/FoundDecl, /*NamedConcept=*/NamedConcept, /*ArgsWritten=*/ArgsAsWritten); - ConstrainedParameter->setTypeConstraint(CL, - ImmediatelyDeclaredConstraint.get(), - /*ArgumentPackSubstitutionIndex=*/-1); + ConstrainedParameter->setTypeConstraint( + CL, ImmediatelyDeclaredConstraint.get(), std::nullopt); return false; } @@ -5244,8 +5243,7 @@ bool Sema::CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &ArgLoc, /*Final=*/true); // If the parameter is a pack expansion, expand this slice of the pack. if (auto *PET = NTTPType->getAs()) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, - ArgumentPackIndex); + Sema::ArgPackSubstIndexRAII SubstIndex(*this, ArgumentPackIndex); NTTPType = SubstType(PET->getPattern(), MLTAL, NTTP->getLocation(), NTTP->getDeclName()); } else { @@ -5563,7 +5561,7 @@ bool Sema::CheckTemplateArgumentList( // If we have an expanded parameter pack, make sure we don't have too // many arguments. - if (std::optional Expansions = getExpandedPackSize(*Param)) { + if (UnsignedOrNone Expansions = getExpandedPackSize(*Param)) { if (*Expansions == SugaredArgumentPack.size()) { // We're done with this parameter pack. Pack up its arguments and add // them to the list. diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp index 9969f1762fe36..ab6e18aee7206 100644 --- a/clang/lib/Sema/SemaTemplateDeduction.cpp +++ b/clang/lib/Sema/SemaTemplateDeduction.cpp @@ -834,7 +834,7 @@ class PackDeductionScope { // FIXME: What if we encounter multiple packs with different numbers of // pre-expanded expansions? (This should already have been diagnosed // during substitution.) - if (std::optional ExpandedPackExpansions = + if (UnsignedOrNone ExpandedPackExpansions = getExpandedPackSize(TemplateParams->getParam(Index))) FixedNumExpansions = ExpandedPackExpansions; @@ -961,14 +961,14 @@ class PackDeductionScope { } // Return the size of the saved packs if all of them has the same size. - std::optional getSavedPackSizeIfAllEqual() const { + UnsignedOrNone getSavedPackSizeIfAllEqual() const { unsigned PackSize = Packs[0].Saved.pack_size(); if (std::all_of(Packs.begin() + 1, Packs.end(), [&PackSize](const auto &P) { return P.Saved.pack_size() == PackSize; })) return PackSize; - return {}; + return std::nullopt; } /// Determine whether this pack has already been deduced from a previous @@ -984,7 +984,7 @@ class PackDeductionScope { /// Determine whether this pack expansion scope has a known, fixed arity. /// This happens if it involves a pack from an outer template that has /// (notionally) already been expanded. - bool hasFixedArity() { return FixedNumExpansions.has_value(); } + bool hasFixedArity() { return static_cast(FixedNumExpansions); } /// Determine whether the next element of the argument is still part of this /// pack. This is the case unless the pack is already expanded to a fixed @@ -1105,7 +1105,7 @@ class PackDeductionScope { // If we have a pre-expanded pack and we didn't deduce enough elements // for it, fail deduction. - if (std::optional Expansions = getExpandedPackSize(Param)) { + if (UnsignedOrNone Expansions = getExpandedPackSize(Param)) { if (*Expansions != PackElements) { Info.Param = makeTemplateParameter(Param); Info.FirstArg = Result; @@ -1130,7 +1130,7 @@ class PackDeductionScope { bool DeducedFromEarlierParameter = false; bool FinishingDeduction = false; /// The number of expansions, if we have a fully-expanded pack in this scope. - std::optional FixedNumExpansions; + UnsignedOrNone FixedNumExpansions = std::nullopt; SmallVector Packs; }; @@ -1222,7 +1222,7 @@ static TemplateDeductionResult DeduceForEachType( // If the parameter type contains an explicitly-specified pack that we // could not expand, skip the number of parameters notionally created // by the expansion. - std::optional NumExpansions = Expansion->getNumExpansions(); + UnsignedOrNone NumExpansions = Expansion->getNumExpansions(); if (NumExpansions && !PackScope.isPartiallyExpanded()) { for (unsigned I = 0; I != *NumExpansions && ArgIdx < Args.size(); ++I, ++ArgIdx) @@ -3735,7 +3735,7 @@ TemplateDeductionResult Sema::SubstituteExplicitTemplateArguments( auto *Param = TemplateParams->getParam(CTAI.SugaredConverted.size() - 1); // If this is a fully-saturated fixed-size pack, it should be // fully-substituted, not partially-substituted. - std::optional Expansions = getExpandedPackSize(Param); + UnsignedOrNone Expansions = getExpandedPackSize(Param); if (!Expansions || Arg.pack_size() < *Expansions) { PartiallySubstitutedPackIndex = CTAI.SugaredConverted.size() - 1; CurrentInstantiationScope->SetPartiallySubstitutedPack( @@ -3967,21 +3967,22 @@ CheckOriginalCallArgDeduction(Sema &S, TemplateDeductionInfo &Info, /// ArgumentPackSubstitutionIndex for further substitutions. // FIXME: We should track this in OriginalCallArgs so we don't need to // reconstruct it here. -static unsigned getPackIndexForParam(Sema &S, - FunctionTemplateDecl *FunctionTemplate, - const MultiLevelTemplateArgumentList &Args, - unsigned ParamIdx) { +static UnsignedOrNone +getPackIndexForParam(Sema &S, FunctionTemplateDecl *FunctionTemplate, + const MultiLevelTemplateArgumentList &Args, + unsigned ParamIdx) { unsigned Idx = 0; for (auto *PD : FunctionTemplate->getTemplatedDecl()->parameters()) { if (PD->isParameterPack()) { - unsigned NumExpansions = - S.getNumArgumentsInExpansion(PD->getType(), Args).value_or(1); + UnsignedOrNone NumArgs = + S.getNumArgumentsInExpansion(PD->getType(), Args); + unsigned NumExpansions = NumArgs ? *NumArgs : 1; if (Idx + NumExpansions > ParamIdx) return ParamIdx - Idx; Idx += NumExpansions; } else { if (Idx == ParamIdx) - return -1; // Not a pack expansion + return std::nullopt; // Not a pack expansion ++Idx; } } @@ -4183,7 +4184,7 @@ TemplateDeductionResult Sema::FinishTemplateArgumentDeduction( QualType &CacheEntry = DeducedATypes[{ParamIdx, OriginalArg.OriginalParamType}]; if (CacheEntry.isNull()) { - ArgumentPackSubstitutionIndexRAII PackIndex( + ArgPackSubstIndexRAII PackIndex( *this, getPackIndexForParam(*this, FunctionTemplate, SubstArgs, ParamIdx)); CacheEntry = @@ -4743,8 +4744,7 @@ TemplateDeductionResult Sema::DeduceTemplateArguments( // If the parameter type contains an explicitly-specified pack that we // could not expand, skip the number of parameters notionally created // by the expansion. - std::optional NumExpansions = - ParamExpansion->getNumExpansions(); + UnsignedOrNone NumExpansions = ParamExpansion->getNumExpansions(); if (NumExpansions && !PackScope.isPartiallyExpanded()) { for (unsigned I = 0; I != *NumExpansions && ArgIdx < Args.size(); ++I, ++ArgIdx) { @@ -4767,7 +4767,7 @@ TemplateDeductionResult Sema::DeduceTemplateArguments( // that, in this case we are not processing all of the remaining // arguments. We are only process as many arguments as we have in // the already deduced parameter. - std::optional ArgPosAfterSubstitution = + UnsignedOrNone ArgPosAfterSubstitution = PackScope.getSavedPackSizeIfAllEqual(); if (!ArgPosAfterSubstitution) continue; @@ -5628,12 +5628,13 @@ static QualType GetImplicitObjectParameterType(ASTContext &Context, } static TemplateDeductionResult CheckDeductionConsistency( - Sema &S, FunctionTemplateDecl *FTD, int ArgIdx, QualType P, QualType A, - ArrayRef DeducedArgs, bool CheckConsistency) { + Sema &S, FunctionTemplateDecl *FTD, UnsignedOrNone ArgIdx, QualType P, + QualType A, ArrayRef DeducedArgs, bool CheckConsistency) { MultiLevelTemplateArgumentList MLTAL(FTD, DeducedArgs, /*Final=*/true); - Sema::ArgumentPackSubstitutionIndexRAII PackIndex( - S, ArgIdx != -1 ? ::getPackIndexForParam(S, FTD, MLTAL, ArgIdx) : -1); + Sema::ArgPackSubstIndexRAII PackIndex( + S, + ArgIdx ? ::getPackIndexForParam(S, FTD, MLTAL, *ArgIdx) : std::nullopt); bool IsIncompleteSubstitution = false; // FIXME: A substitution can be incomplete on a non-structural part of the // type. Use the canonical type for now, until the TemplateInstantiator can @@ -5785,8 +5786,9 @@ static bool isAtLeastAsSpecializedAs( // in deduction. We will still try to substitute them though. if (TPOC != TPOC_Call) { if (auto TDR = ::CheckDeductionConsistency( - S, FTD, /*ArgIdx=*/-1, Proto2->getReturnType(), - Proto1->getReturnType(), DeducedArgs, + S, FTD, /*ArgIdx=*/std::nullopt, + Proto2->getReturnType(), Proto1->getReturnType(), + DeducedArgs, /*CheckConsistency=*/HasDeducedAnyParamFromReturnType); TDR != TemplateDeductionResult::Success) return TDR; @@ -5799,12 +5801,14 @@ static bool isAtLeastAsSpecializedAs( S, TemplateParams, Args2, Args1, Info, Deduced, PartialOrderingKind::Call, /*FinishingDeduction=*/true, [&](Sema &S, TemplateParameterList *, int ParamIdx, - int ArgIdx, QualType P, QualType A, + UnsignedOrNone ArgIdx, QualType P, QualType A, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced, PartialOrderingKind) { - if (ArgIdx != -1) - ArgIdx -= Args1Offset; + if (ArgIdx && *ArgIdx >= Args1Offset) + ArgIdx = *ArgIdx - Args1Offset; + else + ArgIdx = std::nullopt; return ::CheckDeductionConsistency( S, FTD, ArgIdx, P, A, DeducedArgs, /*CheckConsistency=*/HasDeducedParam[ParamIdx]); diff --git a/clang/lib/Sema/SemaTemplateDeductionGuide.cpp b/clang/lib/Sema/SemaTemplateDeductionGuide.cpp index 99bd9d0fb79af..b4863cefc3fb4 100644 --- a/clang/lib/Sema/SemaTemplateDeductionGuide.cpp +++ b/clang/lib/Sema/SemaTemplateDeductionGuide.cpp @@ -252,9 +252,7 @@ TemplateTypeParmDecl *transformTemplateTypeParam( SemaRef.Context, DC, TTP->getBeginLoc(), TTP->getLocation(), NewDepth, NewIndex, TTP->getIdentifier(), TTP->wasDeclaredWithTypename(), TTP->isParameterPack(), TTP->hasTypeConstraint(), - TTP->isExpandedParameterPack() - ? std::optional(TTP->getNumExpansionParameters()) - : std::nullopt); + TTP->getNumExpansionParameters()); if (const auto *TC = TTP->getTypeConstraint()) SemaRef.SubstTypeConstraint(NewTTP, TC, Args, /*EvaluateConstraint=*/EvaluateConstraint); @@ -356,8 +354,7 @@ struct ConvertConstructorToDeductionGuideTransform { TemplateParameterList *TemplateParams = SemaRef.GetTemplateParameterList(Template); SmallVector Depth1Args; - AssociatedConstraint OuterRC(TemplateParams->getRequiresClause(), - /*ArgumentPackSubstitutionIndex=*/-1); + AssociatedConstraint OuterRC(TemplateParams->getRequiresClause()); if (FTD) { TemplateParameterList *InnerParams = FTD->getTemplateParameters(); SmallVector AllParams; @@ -469,8 +466,7 @@ struct ConvertConstructorToDeductionGuideTransform { const_cast(RC.ConstraintExpr), Args); if (!E.isUsable()) return nullptr; - FunctionTrailingRC = - AssociatedConstraint(E.get(), RC.ArgumentPackSubstitutionIndex); + FunctionTrailingRC = AssociatedConstraint(E.get(), RC.ArgPackSubstIndex); } // C++ [over.match.class.deduct]p1: @@ -495,7 +491,7 @@ struct ConvertConstructorToDeductionGuideTransform { /*rhs=*/const_cast(FunctionTrailingRC.ConstraintExpr), BO_LAnd, SemaRef.Context.BoolTy, VK_PRValue, OK_Ordinary, TemplateParams->getTemplateLoc(), FPOptionsOverride()), - FunctionTrailingRC.ArgumentPackSubstitutionIndex); + FunctionTrailingRC.ArgPackSubstIndex); } return buildDeductionGuide( @@ -630,7 +626,7 @@ struct ConvertConstructorToDeductionGuideTransform { TypeSourceInfo *NewDI; if (auto PackTL = OldDI->getTypeLoc().getAs()) { // Expand out the one and only element in each inner pack. - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, 0); + Sema::ArgPackSubstIndexRAII SubstIndex(SemaRef, 0u); NewDI = SemaRef.SubstType(PackTL.getPatternLoc(), Args, OldParam->getLocation(), OldParam->getDeclName()); @@ -1247,10 +1243,8 @@ void DeclareImplicitDeductionGuidesForTypeAlias( // FIXME: Here the synthesized deduction guide is not a templated // function. Per [dcl.decl]p4, the requires-clause shall be present only // if the declarator declares a templated function, a bug in standard? - AssociatedConstraint Constraint( - buildIsDeducibleConstraint(SemaRef, AliasTemplate, - Transformed->getReturnType(), {}), - /*ArgumentPackSubstitutionIndex=*/-1); + AssociatedConstraint Constraint(buildIsDeducibleConstraint( + SemaRef, AliasTemplate, Transformed->getReturnType(), {})); if (const AssociatedConstraint &RC = DG->getTrailingRequiresClause()) { auto Conjunction = SemaRef.BuildBinOp( SemaRef.getCurScope(), SourceLocation{}, @@ -1258,8 +1252,7 @@ void DeclareImplicitDeductionGuidesForTypeAlias( const_cast(Constraint.ConstraintExpr)); if (!Conjunction.isInvalid()) { Constraint.ConstraintExpr = Conjunction.getAs(); - Constraint.ArgumentPackSubstitutionIndex = - RC.ArgumentPackSubstitutionIndex; + Constraint.ArgPackSubstIndex = RC.ArgPackSubstIndex; } } Transformed->setTrailingRequiresClause(Constraint); @@ -1355,8 +1348,7 @@ FunctionTemplateDecl *Sema::DeclareAggregateDeductionGuideFromInitList( // In case we were expanding a pack when we attempted to declare deduction // guides, turn off pack expansion for everything we're about to do. - ArgumentPackSubstitutionIndexRAII SubstIndex(*this, - /*NewSubstitutionIndex=*/-1); + ArgPackSubstIndexRAII SubstIndex(*this, std::nullopt); // Create a template instantiation record to track the "instantiation" of // constructors into deduction guides. InstantiatingTemplate BuildingDeductionGuides( @@ -1405,7 +1397,7 @@ void Sema::DeclareImplicitDeductionGuides(TemplateDecl *Template, // In case we were expanding a pack when we attempted to declare deduction // guides, turn off pack expansion for everything we're about to do. - ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1); + ArgPackSubstIndexRAII SubstIndex(*this, std::nullopt); // Create a template instantiation record to track the "instantiation" of // constructors into deduction guides. InstantiatingTemplate BuildingDeductionGuides( diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp index d835b3b06893d..dd493a083d86d 100644 --- a/clang/lib/Sema/SemaTemplateInstantiate.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp @@ -1350,9 +1350,9 @@ std::optional Sema::isSFINAEContext() const { static TemplateArgument getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg) { - assert(S.ArgumentPackSubstitutionIndex >= 0); - assert(S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size()); - Arg = Arg.pack_begin()[S.ArgumentPackSubstitutionIndex]; + assert(S.ArgPackSubstIndex); + assert(*S.ArgPackSubstIndex < Arg.pack_size()); + Arg = Arg.pack_begin()[*S.ArgPackSubstIndex]; if (Arg.isPackExpansion()) Arg = Arg.getPackExpansionPattern(); return Arg; @@ -1418,18 +1418,18 @@ namespace { return TemplateArgs.getNewDepth(Depth); } - std::optional getPackIndex(TemplateArgument Pack) { - int Index = getSema().ArgumentPackSubstitutionIndex; - if (Index == -1) + UnsignedOrNone getPackIndex(TemplateArgument Pack) { + UnsignedOrNone Index = getSema().ArgPackSubstIndex; + if (!Index) return std::nullopt; - return Pack.pack_size() - 1 - Index; + return Pack.pack_size() - 1 - *Index; } bool TryExpandParameterPacks(SourceLocation EllipsisLoc, SourceRange PatternRange, ArrayRef Unexpanded, bool &ShouldExpand, bool &RetainExpansion, - std::optional &NumExpansions) { + UnsignedOrNone &NumExpansions) { return getSema().CheckParameterPacksForExpansion(EllipsisLoc, PatternRange, Unexpanded, TemplateArgs, @@ -1481,7 +1481,7 @@ namespace { getTemplateArgumentPackPatternForRewrite(const TemplateArgument &TA) { if (TA.getKind() != TemplateArgument::Pack) return TA; - if (SemaRef.ArgumentPackSubstitutionIndex != -1) + if (SemaRef.ArgPackSubstIndex) return getPackSubstitutedTemplateArgument(SemaRef, TA); assert(TA.pack_size() == 1 && TA.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"); @@ -1667,7 +1667,7 @@ namespace { return inherited::TransformTemplateArgument(Input, Output, Uneval); } - std::optional ComputeSizeOfPackExprWithoutSubstitution( + UnsignedOrNone ComputeSizeOfPackExprWithoutSubstitution( ArrayRef PackArgs) { // Don't do this when rewriting template parameters for CTAD: // 1) The heuristic needs the unpacked Subst* nodes to figure out the @@ -1691,10 +1691,10 @@ namespace { Qualifiers ThisTypeQuals, Fn TransformExceptionSpec); - ParmVarDecl * - TransformFunctionTypeParam(ParmVarDecl *OldParm, int indexAdjustment, - std::optional NumExpansions, - bool ExpectParameterPack); + ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm, + int indexAdjustment, + UnsignedOrNone NumExpansions, + bool ExpectParameterPack); using inherited::TransformTemplateTypeParmType; /// Transforms a template type parameter type by performing @@ -1705,7 +1705,7 @@ namespace { QualType BuildSubstTemplateTypeParmType( TypeLocBuilder &TLB, bool SuppressObjCLifetime, bool Final, - Decl *AssociatedDecl, unsigned Index, std::optional PackIndex, + Decl *AssociatedDecl, unsigned Index, UnsignedOrNone PackIndex, TemplateArgument Arg, SourceLocation NameLoc); /// Transforms an already-substituted template type parameter pack @@ -1865,10 +1865,11 @@ namespace { Sema::ExtParameterInfoBuilder &PInfos); private: - ExprResult transformNonTypeTemplateParmRef( - Decl *AssociatedDecl, const NonTypeTemplateParmDecl *parm, - SourceLocation loc, TemplateArgument arg, - std::optional PackIndex, bool Final); + ExprResult + transformNonTypeTemplateParmRef(Decl *AssociatedDecl, + const NonTypeTemplateParmDecl *parm, + SourceLocation loc, TemplateArgument arg, + UnsignedOrNone PackIndex, bool Final); }; } @@ -1957,7 +1958,7 @@ TemplateInstantiator::TransformFirstQualifierInScope(NamedDecl *D, assert(Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"); - if (getSema().ArgumentPackSubstitutionIndex == -1) + if (!getSema().ArgPackSubstIndex) return nullptr; Arg = getPackSubstitutedTemplateArgument(getSema(), Arg); @@ -2062,12 +2063,12 @@ TemplateName TemplateInstantiator::TransformTemplateName( auto [AssociatedDecl, Final] = TemplateArgs.getAssociatedDecl(TTP->getDepth()); - std::optional PackIndex; + UnsignedOrNone PackIndex = std::nullopt; if (TTP->isParameterPack()) { assert(Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"); - if (getSema().ArgumentPackSubstitutionIndex == -1) { + if (!getSema().ArgPackSubstIndex) { // We have the template argument pack to substitute, but we're not // actually expanding the enclosing pack expansion yet. So, just // keep the entire argument pack. @@ -2089,7 +2090,7 @@ TemplateName TemplateInstantiator::TransformTemplateName( if (SubstTemplateTemplateParmPackStorage *SubstPack = Name.getAsSubstTemplateTemplateParmPack()) { - if (getSema().ArgumentPackSubstitutionIndex == -1) + if (!getSema().ArgPackSubstIndex) return Name; TemplateArgument Pack = SubstPack->getArgumentPack(); @@ -2141,12 +2142,12 @@ TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E, auto [AssociatedDecl, Final] = TemplateArgs.getAssociatedDecl(NTTP->getDepth()); - std::optional PackIndex; + UnsignedOrNone PackIndex = std::nullopt; if (NTTP->isParameterPack()) { assert(Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"); - if (getSema().ArgumentPackSubstitutionIndex == -1) { + if (!getSema().ArgPackSubstIndex) { // We have an argument pack, but we can't select a particular argument // out of it yet. Therefore, we'll build an expression to hold on to that // argument pack. @@ -2262,7 +2263,7 @@ TemplateInstantiator::TransformOpenACCRoutineDeclAttr( ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef( Decl *AssociatedDecl, const NonTypeTemplateParmDecl *parm, - SourceLocation loc, TemplateArgument arg, std::optional PackIndex, + SourceLocation loc, TemplateArgument arg, UnsignedOrNone PackIndex, bool Final) { ExprResult result; @@ -2271,7 +2272,7 @@ ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef( auto SubstParamType = [&] { QualType T; if (parm->isExpandedParameterPack()) - T = parm->getExpansionType(SemaRef.ArgumentPackSubstitutionIndex); + T = parm->getExpansionType(*SemaRef.ArgPackSubstIndex); else T = parm->getType(); if (parm->isParameterPack() && isa(T)) @@ -2337,7 +2338,7 @@ ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef( ExprResult TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr( SubstNonTypeTemplateParmPackExpr *E) { - if (getSema().ArgumentPackSubstitutionIndex == -1) { + if (!getSema().ArgPackSubstIndex) { // We aren't expanding the parameter pack, so just return ourselves. return E; } @@ -2401,9 +2402,9 @@ ExprResult TemplateInstantiator::RebuildVarDeclRefExpr(ValueDecl *PD, ExprResult TemplateInstantiator::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) { - if (getSema().ArgumentPackSubstitutionIndex != -1) { + if (getSema().ArgPackSubstIndex) { // We can expand this parameter pack now. - ValueDecl *D = E->getExpansion(getSema().ArgumentPackSubstitutionIndex); + ValueDecl *D = E->getExpansion(*getSema().ArgPackSubstIndex); ValueDecl *VD = cast_or_null(TransformDecl(E->getExprLoc(), D)); if (!VD) return ExprError(); @@ -2445,7 +2446,7 @@ TemplateInstantiator::TransformFunctionParmPackRefExpr(DeclRefExpr *E, if (DeclArgumentPack *Pack = dyn_cast(*Found)) { // If this is a reference to a function parameter pack which we can // substitute but can't yet expand, build a FunctionParmPackExpr for it. - if (getSema().ArgumentPackSubstitutionIndex == -1) { + if (!getSema().ArgPackSubstIndex) { QualType T = TransformType(E->getType()); if (T.isNull()) return ExprError(); @@ -2455,7 +2456,7 @@ TemplateInstantiator::TransformFunctionParmPackRefExpr(DeclRefExpr *E, return PackExpr; } - TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex]; + TransformedDecl = (*Pack)[*getSema().ArgPackSubstIndex]; } else { TransformedDecl = cast(*Found); } @@ -2520,8 +2521,8 @@ QualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB, } ParmVarDecl *TemplateInstantiator::TransformFunctionTypeParam( - ParmVarDecl *OldParm, int indexAdjustment, - std::optional NumExpansions, bool ExpectParameterPack) { + ParmVarDecl *OldParm, int indexAdjustment, UnsignedOrNone NumExpansions, + bool ExpectParameterPack) { auto NewParm = SemaRef.SubstParmVarDecl( OldParm, TemplateArgs, indexAdjustment, NumExpansions, ExpectParameterPack, EvaluateConstraints); @@ -2532,7 +2533,7 @@ ParmVarDecl *TemplateInstantiator::TransformFunctionTypeParam( QualType TemplateInstantiator::BuildSubstTemplateTypeParmType( TypeLocBuilder &TLB, bool SuppressObjCLifetime, bool Final, - Decl *AssociatedDecl, unsigned Index, std::optional PackIndex, + Decl *AssociatedDecl, unsigned Index, UnsignedOrNone PackIndex, TemplateArgument Arg, SourceLocation NameLoc) { QualType Replacement = Arg.getAsType(); @@ -2594,12 +2595,12 @@ TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB, auto [AssociatedDecl, Final] = TemplateArgs.getAssociatedDecl(T->getDepth()); - std::optional PackIndex; + UnsignedOrNone PackIndex = std::nullopt; if (T->isParameterPack()) { assert(Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"); - if (getSema().ArgumentPackSubstitutionIndex == -1) { + if (!getSema().ArgPackSubstIndex) { // We have the template argument pack, but we're not expanding the // enclosing pack expansion yet. Just save the template argument // pack for later substitution. @@ -2647,7 +2648,7 @@ QualType TemplateInstantiator::TransformSubstTemplateTypeParmPackType( Decl *NewReplaced = TransformDecl(TL.getNameLoc(), T->getAssociatedDecl()); - if (getSema().ArgumentPackSubstitutionIndex == -1) { + if (!getSema().ArgPackSubstIndex) { // We aren't expanding the parameter pack, so just return ourselves. QualType Result = TL.getType(); if (NewReplaced != T->getAssociatedDecl()) @@ -2866,7 +2867,7 @@ TemplateInstantiator::TransformNestedRequirement( if (!SemaRef.CheckConstraintSatisfaction( nullptr, AssociatedConstraint(Req->getConstraintExpr(), - SemaRef.ArgumentPackSubstitutionIndex), + SemaRef.ArgPackSubstIndex), Result, TemplateArgs, Req->getConstraintExpr()->getSourceRange(), Satisfaction) && !Result.empty()) @@ -3150,9 +3151,9 @@ bool Sema::SubstTypeConstraint( TC->getTemplateArgsAsWritten(); if (!EvaluateConstraints) { - auto Index = TC->getArgumentPackSubstitutionIndex(); - if (Index == -1) - Index = SemaRef.ArgumentPackSubstitutionIndex; + UnsignedOrNone Index = TC->getArgPackSubstIndex(); + if (!Index) + Index = SemaRef.ArgPackSubstIndex; Inst->setTypeConstraint(TC->getConceptReference(), TC->getImmediatelyDeclaredConstraint(), Index); return false; @@ -3177,10 +3178,11 @@ bool Sema::SubstTypeConstraint( : SourceLocation()); } -ParmVarDecl *Sema::SubstParmVarDecl( - ParmVarDecl *OldParm, const MultiLevelTemplateArgumentList &TemplateArgs, - int indexAdjustment, std::optional NumExpansions, - bool ExpectParameterPack, bool EvaluateConstraint) { +ParmVarDecl * +Sema::SubstParmVarDecl(ParmVarDecl *OldParm, + const MultiLevelTemplateArgumentList &TemplateArgs, + int indexAdjustment, UnsignedOrNone NumExpansions, + bool ExpectParameterPack, bool EvaluateConstraint) { TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo(); TypeSourceInfo *NewDI = nullptr; @@ -3422,7 +3424,7 @@ Sema::SubstBaseSpecifiers(CXXRecordDecl *Instantiation, Unexpanded); bool ShouldExpand = false; bool RetainExpansion = false; - std::optional NumExpansions; + UnsignedOrNone NumExpansions = std::nullopt; if (CheckParameterPacksForExpansion(Base.getEllipsisLoc(), Base.getSourceRange(), Unexpanded, @@ -3436,7 +3438,7 @@ Sema::SubstBaseSpecifiers(CXXRecordDecl *Instantiation, // If we should expand this pack expansion now, do so. if (ShouldExpand) { for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I); + Sema::ArgPackSubstIndexRAII SubstIndex(*this, I); TypeSourceInfo *BaseTypeLoc = SubstType(Base.getTypeSourceInfo(), TemplateArgs, @@ -3464,7 +3466,7 @@ Sema::SubstBaseSpecifiers(CXXRecordDecl *Instantiation, // The resulting base specifier will (still) be a pack expansion. EllipsisLoc = Base.getEllipsisLoc(); - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1); + Sema::ArgPackSubstIndexRAII SubstIndex(*this, std::nullopt); BaseTypeLoc = SubstType(Base.getTypeSourceInfo(), TemplateArgs, Base.getSourceRange().getBegin(), diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp index fcb4ee5650f91..2d6f2ca67af8a 100644 --- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -130,7 +130,7 @@ static void instantiateDependentAlignedAttr( // Determine whether we can expand this attribute pack yet. bool Expand = true, RetainExpansion = false; - std::optional NumExpansions; + UnsignedOrNone NumExpansions = std::nullopt; // FIXME: Use the actual location of the ellipsis. SourceLocation EllipsisLoc = Aligned->getLocation(); if (S.CheckParameterPacksForExpansion(EllipsisLoc, Aligned->getRange(), @@ -139,11 +139,11 @@ static void instantiateDependentAlignedAttr( return; if (!Expand) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, -1); + Sema::ArgPackSubstIndexRAII SubstIndex(S, std::nullopt); instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, true); } else { for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, I); + Sema::ArgPackSubstIndexRAII SubstIndex(S, I); instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false); } } @@ -1888,7 +1888,7 @@ Decl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) { bool ShouldExpand = true; bool RetainExpansion = false; - std::optional NumExpansions; + UnsignedOrNone NumExpansions = std::nullopt; if (SemaRef.CheckParameterPacksForExpansion( D->getEllipsisLoc(), D->getSourceRange(), Unexpanded, TemplateArgs, ShouldExpand, RetainExpansion, NumExpansions)) @@ -1900,7 +1900,7 @@ Decl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) { if (ShouldExpand) { SmallVector Decls; for (unsigned I = 0; I != *NumExpansions; I++) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I); + Sema::ArgPackSubstIndexRAII SubstIndex(SemaRef, I); TypeSourceInfo *TSI = SemaRef.SubstType( Ty, TemplateArgs, D->getEllipsisLoc(), DeclarationName()); if (!TSI) @@ -3418,10 +3418,10 @@ Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl( TemplateTypeParmDecl *D) { assert(D->getTypeForDecl()->isTemplateTypeParmType()); - std::optional NumExpanded; + UnsignedOrNone NumExpanded = std::nullopt; if (const TypeConstraint *TC = D->getTypeConstraint()) { - if (D->isPackExpansion() && !D->isExpandedParameterPack()) { + if (D->isPackExpansion() && !D->getNumExpansionParameters()) { assert(TC->getTemplateArgsAsWritten() && "type parameter can only be an expansion when explicit arguments " "are specified"); @@ -3528,9 +3528,9 @@ Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl( // be expanded. bool Expand = true; bool RetainExpansion = false; - std::optional OrigNumExpansions = + UnsignedOrNone OrigNumExpansions = Expansion.getTypePtr()->getNumExpansions(); - std::optional NumExpansions = OrigNumExpansions; + UnsignedOrNone NumExpansions = OrigNumExpansions; if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(), Pattern.getSourceRange(), Unexpanded, @@ -3541,7 +3541,7 @@ Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl( if (Expand) { for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I); + Sema::ArgPackSubstIndexRAII SubstIndex(SemaRef, I); TypeSourceInfo *NewDI = SemaRef.SubstType(Pattern, TemplateArgs, D->getLocation(), D->getDeclName()); @@ -3566,7 +3566,7 @@ Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl( } else { // We cannot fully expand the pack expansion now, so substitute into the // pattern and create a new pack expansion type. - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1); + Sema::ArgPackSubstIndexRAII SubstIndex(SemaRef, std::nullopt); TypeSourceInfo *NewPattern = SemaRef.SubstType(Pattern, TemplateArgs, D->getLocation(), D->getDeclName()); @@ -3701,7 +3701,7 @@ TemplateDeclInstantiator::VisitTemplateTemplateParmDecl( // be expanded. bool Expand = true; bool RetainExpansion = false; - std::optional NumExpansions; + UnsignedOrNone NumExpansions = std::nullopt; if (SemaRef.CheckParameterPacksForExpansion(D->getLocation(), TempParams->getSourceRange(), Unexpanded, @@ -3712,7 +3712,7 @@ TemplateDeclInstantiator::VisitTemplateTemplateParmDecl( if (Expand) { for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I); + Sema::ArgPackSubstIndexRAII SubstIndex(SemaRef, I); LocalInstantiationScope Scope(SemaRef); TemplateParameterList *Expansion = SubstTemplateParams(TempParams); if (!Expansion) @@ -3728,7 +3728,7 @@ TemplateDeclInstantiator::VisitTemplateTemplateParmDecl( } else { // We cannot fully expand the pack expansion now, so just substitute // into the pattern. - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1); + Sema::ArgPackSubstIndexRAII SubstIndex(SemaRef, std::nullopt); LocalInstantiationScope Scope(SemaRef); InstParams = SubstTemplateParams(TempParams); @@ -3978,7 +3978,7 @@ Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl( // be expanded. bool Expand = true; bool RetainExpansion = false; - std::optional NumExpansions; + UnsignedOrNone NumExpansions = std::nullopt; if (SemaRef.CheckParameterPacksForExpansion( D->getEllipsisLoc(), D->getSourceRange(), Unexpanded, TemplateArgs, Expand, RetainExpansion, NumExpansions)) @@ -3992,7 +3992,7 @@ Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl( if (!Expand) { // We cannot fully expand the pack expansion now, so substitute into the // pattern and create a new pack expansion. - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1); + Sema::ArgPackSubstIndexRAII SubstIndex(SemaRef, std::nullopt); return instantiateUnresolvedUsingDecl(D, true); } @@ -4012,7 +4012,7 @@ Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl( // Instantiate the slices of this pack and build a UsingPackDecl. SmallVector Expansions; for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I); + Sema::ArgPackSubstIndexRAII SubstIndex(SemaRef, I); Decl *Slice = instantiateUnresolvedUsingDecl(D, true); if (!Slice) return nullptr; @@ -4046,8 +4046,8 @@ Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl( // Produce a pack expansion only if we're not instantiating a particular // slice of a pack expansion. - bool InstantiatingSlice = D->getEllipsisLoc().isValid() && - SemaRef.ArgumentPackSubstitutionIndex != -1; + bool InstantiatingSlice = + D->getEllipsisLoc().isValid() && SemaRef.ArgPackSubstIndex; SourceLocation EllipsisLoc = InstantiatingSlice ? SourceLocation() : D->getEllipsisLoc(); @@ -4998,7 +4998,7 @@ TemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D, LocalInstantiationScope *Scope = SemaRef.CurrentInstantiationScope; - std::optional NumArgumentsInExpansion; + UnsignedOrNone NumArgumentsInExpansion = std::nullopt; if (OldParam->isParameterPack()) NumArgumentsInExpansion = SemaRef.getNumArgumentsInExpansion(OldParam->getType(), @@ -5125,7 +5125,7 @@ bool Sema::addInstantiatedParametersToScope( // Expand the parameter pack. Scope.MakeInstantiatedLocalArgPack(PatternParam); - std::optional NumArgumentsInExpansion = + UnsignedOrNone NumArgumentsInExpansion = getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs); if (NumArgumentsInExpansion) { QualType PatternType = @@ -5134,7 +5134,7 @@ bool Sema::addInstantiatedParametersToScope( ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx); FunctionParam->setDeclName(PatternParam->getDeclName()); if (!PatternDecl->getType()->isDependentType()) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, Arg); + Sema::ArgPackSubstIndexRAII SubstIndex(*this, Arg); QualType T = SubstType(PatternType, TemplateArgs, FunctionParam->getLocation(), FunctionParam->getDeclName()); @@ -6306,7 +6306,7 @@ Sema::InstantiateMemInitializers(CXXConstructorDecl *New, collectUnexpandedParameterPacks(Init->getInit(), Unexpanded); bool ShouldExpand = false; bool RetainExpansion = false; - std::optional NumExpansions; + UnsignedOrNone NumExpansions = std::nullopt; if (CheckParameterPacksForExpansion(Init->getEllipsisLoc(), BaseTL.getSourceRange(), Unexpanded, @@ -6321,7 +6321,7 @@ Sema::InstantiateMemInitializers(CXXConstructorDecl *New, // Loop over all of the arguments in the argument pack(s), for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I); + Sema::ArgPackSubstIndexRAII SubstIndex(*this, I); // Instantiate the initializer. ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs, @@ -6694,18 +6694,17 @@ NamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, if (auto Found = CurrentInstantiationScope->findInstantiationOf(D)) { if (Decl *FD = Found->dyn_cast()) { if (auto *BD = dyn_cast(FD); - BD && BD->isParameterPack() && - ArgumentPackSubstitutionIndex != -1) { - return BD->getBindingPackDecls()[ArgumentPackSubstitutionIndex]; + BD && BD->isParameterPack() && ArgPackSubstIndex) { + return BD->getBindingPackDecls()[*ArgPackSubstIndex]; } return cast(FD); } - int PackIdx = ArgumentPackSubstitutionIndex; - assert(PackIdx != -1 && + assert(ArgPackSubstIndex && "found declaration pack but not pack expanding"); typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack; - return cast((*cast(*Found))[PackIdx]); + return cast( + (*cast(*Found))[*ArgPackSubstIndex]); } } diff --git a/clang/lib/Sema/SemaTemplateVariadic.cpp b/clang/lib/Sema/SemaTemplateVariadic.cpp index d9256dbd07d7a..ef0e6ee23e942 100644 --- a/clang/lib/Sema/SemaTemplateVariadic.cpp +++ b/clang/lib/Sema/SemaTemplateVariadic.cpp @@ -685,9 +685,9 @@ TypeResult Sema::ActOnPackExpansion(ParsedType Type, return CreateParsedType(TSResult->getType(), TSResult); } -TypeSourceInfo * -Sema::CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, - std::optional NumExpansions) { +TypeSourceInfo *Sema::CheckPackExpansion(TypeSourceInfo *Pattern, + SourceLocation EllipsisLoc, + UnsignedOrNone NumExpansions) { // Create the pack expansion type and source-location information. QualType Result = CheckPackExpansion(Pattern->getType(), Pattern->getTypeLoc().getSourceRange(), @@ -705,7 +705,7 @@ Sema::CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, QualType Sema::CheckPackExpansion(QualType Pattern, SourceRange PatternRange, SourceLocation EllipsisLoc, - std::optional NumExpansions) { + UnsignedOrNone NumExpansions) { // C++11 [temp.variadic]p5: // The pattern of a pack expansion shall name one or more // parameter packs that are not expanded by a nested pack @@ -729,7 +729,7 @@ ExprResult Sema::ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc) { } ExprResult Sema::CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, - std::optional NumExpansions) { + UnsignedOrNone NumExpansions) { if (!Pattern) return ExprError(); @@ -753,12 +753,12 @@ bool Sema::CheckParameterPacksForExpansion( SourceLocation EllipsisLoc, SourceRange PatternRange, ArrayRef Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand, - bool &RetainExpansion, std::optional &NumExpansions) { + bool &RetainExpansion, UnsignedOrNone &NumExpansions) { ShouldExpand = true; RetainExpansion = false; std::pair FirstPack; bool HaveFirstPack = false; - std::optional NumPartialExpansions; + UnsignedOrNone NumPartialExpansions = std::nullopt; SourceLocation PartiallySubstitutedPackLoc; typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack; @@ -942,10 +942,10 @@ bool Sema::CheckParameterPacksForExpansion( return false; } -std::optional Sema::getNumArgumentsInExpansionFromUnexpanded( +UnsignedOrNone Sema::getNumArgumentsInExpansionFromUnexpanded( llvm::ArrayRef Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs) { - std::optional Result; + UnsignedOrNone Result = std::nullopt; for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { // Compute the depth and index for this parameter pack. unsigned Depth; @@ -992,7 +992,7 @@ std::optional Sema::getNumArgumentsInExpansionFromUnexpanded( return Result; } -std::optional Sema::getNumArgumentsInExpansion( +UnsignedOrNone Sema::getNumArgumentsInExpansion( QualType T, const MultiLevelTemplateArgumentList &TemplateArgs) { QualType Pattern = cast(T)->getPattern(); SmallVector Unexpanded; @@ -1252,7 +1252,7 @@ ExprResult Sema::BuildPackIndexingExpr(Expr *PackExpression, TemplateArgumentLoc Sema::getTemplateArgumentPackExpansionPattern( TemplateArgumentLoc OrigLoc, SourceLocation &Ellipsis, - std::optional &NumExpansions) const { + UnsignedOrNone &NumExpansions) const { const TemplateArgument &Argument = OrigLoc.getArgument(); assert(Argument.isPackExpansion()); switch (Argument.getKind()) { @@ -1310,7 +1310,7 @@ TemplateArgumentLoc Sema::getTemplateArgumentPackExpansionPattern( llvm_unreachable("Invalid TemplateArgument Kind!"); } -std::optional Sema::getFullyPackExpandedSize(TemplateArgument Arg) { +UnsignedOrNone Sema::getFullyPackExpandedSize(TemplateArgument Arg) { assert(Arg.containsUnexpandedParameterPack()); // If this is a substituted pack, grab that pack. If not, we don't know @@ -1464,7 +1464,7 @@ ExprResult Sema::BuildCXXFoldExpr(UnresolvedLookupExpr *Callee, BinaryOperatorKind Operator, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, - std::optional NumExpansions) { + UnsignedOrNone NumExpansions) { return new (Context) CXXFoldExpr(Context.DependentTy, Callee, LParenLoc, LHS, Operator, EllipsisLoc, RHS, RParenLoc, NumExpansions); diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp index 20240fdaf2bbb..4e7726e258110 100644 --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -9685,7 +9685,7 @@ QualType Sema::BuildPackIndexingType(QualType Pattern, Expr *IndexExpr, bool FullySubstituted, ArrayRef Expansions) { - std::optional Index; + UnsignedOrNone Index = std::nullopt; if (FullySubstituted && !IndexExpr->isValueDependent() && !IndexExpr->isTypeDependent()) { llvm::APSInt Value(Context.getIntWidth(Context.getSizeType())); @@ -9693,20 +9693,18 @@ QualType Sema::BuildPackIndexingType(QualType Pattern, Expr *IndexExpr, IndexExpr, Context.getSizeType(), Value, CCEK_ArrayBound); if (!Res.isUsable()) return QualType(); - Index = Value.getExtValue(); IndexExpr = Res.get(); - } - - if (FullySubstituted && Index) { - if (*Index < 0 || *Index >= int64_t(Expansions.size())) { + int64_t V = Value.getExtValue(); + if (FullySubstituted && (V < 0 || V >= int64_t(Expansions.size()))) { Diag(IndexExpr->getBeginLoc(), diag::err_pack_index_out_of_bound) - << *Index << Pattern << Expansions.size(); + << V << Pattern << Expansions.size(); return QualType(); } + Index = static_cast(V); } return Context.getPackIndexingType(Pattern, IndexExpr, FullySubstituted, - Expansions, Index.value_or(-1)); + Expansions, Index); } static QualType GetEnumUnderlyingType(Sema &S, QualType BaseType, diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h index 12ec97ca8c3e0..237c5a9ef501b 100644 --- a/clang/lib/Sema/TreeTransform.h +++ b/clang/lib/Sema/TreeTransform.h @@ -116,11 +116,11 @@ class TreeTransform { TemplateArgument Old; // Set the pack expansion index to -1 to avoid pack substitution and // indicate that parameter packs should be instantiated as themselves. - Sema::ArgumentPackSubstitutionIndexRAII ResetPackSubstIndex; + Sema::ArgPackSubstIndexRAII ResetPackSubstIndex; public: ForgetPartiallySubstitutedPackRAII(Derived &Self) - : Self(Self), ResetPackSubstIndex(Self.getSema(), -1) { + : Self(Self), ResetPackSubstIndex(Self.getSema(), std::nullopt) { Old = Self.ForgetPartiallySubstitutedPack(); } @@ -165,7 +165,7 @@ class TreeTransform { /// 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 SemaRef.ArgumentPackSubstitutionIndex != -1; } + bool AlwaysRebuild() { return static_cast(SemaRef.ArgPackSubstIndex); } /// Whether the transformation is forming an expression or statement that /// replaces the original. In this case, we'll reuse mangling numbers from @@ -293,7 +293,7 @@ class TreeTransform { SourceRange PatternRange, ArrayRef Unexpanded, bool &ShouldExpand, bool &RetainExpansion, - std::optional &NumExpansions) { + UnsignedOrNone &NumExpansions) { ShouldExpand = false; return false; } @@ -764,7 +764,7 @@ class TreeTransform { /// scope index; can be negative ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm, int indexAdjustment, - std::optional NumExpansions, + UnsignedOrNone NumExpansions, bool ExpectParameterPack); /// Transform the body of a lambda-expression. @@ -1255,7 +1255,7 @@ class TreeTransform { /// Subclasses may override this routine to provide different behavior. QualType RebuildPackExpansionType(QualType Pattern, SourceRange PatternRange, SourceLocation EllipsisLoc, - std::optional NumExpansions) { + UnsignedOrNone NumExpansions) { return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc, NumExpansions); } @@ -3653,14 +3653,14 @@ class TreeTransform { return SemaRef.BuildCXXNoexceptExpr(Range.getBegin(), Arg, Range.getEnd()); } - std::optional + UnsignedOrNone ComputeSizeOfPackExprWithoutSubstitution(ArrayRef PackArgs); /// Build a new expression to compute the length of a parameter pack. ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, - std::optional Length, + UnsignedOrNone Length, ArrayRef PartialArgs) { return SizeOfPackExpr::Create(SemaRef.Context, OperatorLoc, Pack, PackLoc, RParenLoc, Length, PartialArgs); @@ -3970,9 +3970,9 @@ class TreeTransform { /// 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, - std::optional NumExpansions) { + TemplateArgumentLoc RebuildPackExpansion(TemplateArgumentLoc Pattern, + SourceLocation EllipsisLoc, + UnsignedOrNone NumExpansions) { switch (Pattern.getArgument().getKind()) { case TemplateArgument::Expression: { ExprResult Result @@ -4020,7 +4020,7 @@ class TreeTransform { /// for an expression. Subclasses may override this routine to provide /// different behavior. ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, - std::optional NumExpansions) { + UnsignedOrNone NumExpansions) { return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions); } @@ -4033,7 +4033,7 @@ class TreeTransform { BinaryOperatorKind Operator, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, - std::optional NumExpansions) { + UnsignedOrNone NumExpansions) { return getSema().BuildCXXFoldExpr(ULE, LParenLoc, LHS, Operator, EllipsisLoc, RHS, RParenLoc, NumExpansions); @@ -4452,8 +4452,8 @@ bool TreeTransform::TransformExprs(Expr *const *Inputs, // be expanded. bool Expand = true; bool RetainExpansion = false; - std::optional OrigNumExpansions = Expansion->getNumExpansions(); - std::optional NumExpansions = OrigNumExpansions; + UnsignedOrNone OrigNumExpansions = Expansion->getNumExpansions(); + UnsignedOrNone NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded, @@ -4465,7 +4465,7 @@ bool TreeTransform::TransformExprs(Expr *const *Inputs, // The transform has determined that we should perform a simple // transformation on the pack expansion, producing another pack // expansion. - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); ExprResult OutPattern = getDerived().TransformExpr(Pattern); if (OutPattern.isInvalid()) return true; @@ -4489,7 +4489,7 @@ bool TreeTransform::TransformExprs(Expr *const *Inputs, // The transform has determined that we should perform an elementwise // expansion of the pattern. Do so. for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); ExprResult Out = getDerived().TransformExpr(Pattern); if (Out.isInvalid()) return true; @@ -5039,7 +5039,7 @@ bool TreeTransform::TransformTemplateArguments( // We have a pack expansion, for which we will be substituting into // the pattern. SourceLocation Ellipsis; - std::optional OrigNumExpansions; + UnsignedOrNone OrigNumExpansions = std::nullopt; TemplateArgumentLoc Pattern = getSema().getTemplateArgumentPackExpansionPattern( In, Ellipsis, OrigNumExpansions); @@ -5052,7 +5052,7 @@ bool TreeTransform::TransformTemplateArguments( // be expanded. bool Expand = true; bool RetainExpansion = false; - std::optional NumExpansions = OrigNumExpansions; + UnsignedOrNone NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(Ellipsis, Pattern.getSourceRange(), Unexpanded, @@ -5066,7 +5066,7 @@ bool TreeTransform::TransformTemplateArguments( // transformation on the pack expansion, producing another pack // expansion. TemplateArgumentLoc OutPattern; - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval)) return true; @@ -5082,7 +5082,7 @@ bool TreeTransform::TransformTemplateArguments( // The transform has determined that we should perform an elementwise // expansion of the pattern. Do so. for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval)) return true; @@ -6080,8 +6080,8 @@ QualType TreeTransform::TransformExtVectorType(TypeLocBuilder &TLB, template ParmVarDecl *TreeTransform::TransformFunctionTypeParam( - ParmVarDecl *OldParm, int indexAdjustment, - std::optional NumExpansions, bool ExpectParameterPack) { + ParmVarDecl *OldParm, int indexAdjustment, UnsignedOrNone NumExpansions, + bool ExpectParameterPack) { TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo(); TypeSourceInfo *NewDI = nullptr; @@ -6152,7 +6152,7 @@ bool TreeTransform::TransformFunctionTypeParams( if (ParmVarDecl *OldParm = Params[i]) { assert(OldParm->getFunctionScopeIndex() == i); - std::optional NumExpansions; + UnsignedOrNone NumExpansions = std::nullopt; ParmVarDecl *NewParm = nullptr; if (OldParm->isParameterPack()) { // We have a function parameter pack that may need to be expanded. @@ -6167,7 +6167,7 @@ bool TreeTransform::TransformFunctionTypeParams( // Determine whether we should expand the parameter packs. bool ShouldExpand = false; bool RetainExpansion = false; - std::optional OrigNumExpansions; + UnsignedOrNone OrigNumExpansions = std::nullopt; if (Unexpanded.size() > 0) { OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions(); NumExpansions = OrigNumExpansions; @@ -6193,7 +6193,7 @@ bool TreeTransform::TransformFunctionTypeParams( // parameters. getDerived().ExpandingFunctionParameterPack(OldParm); for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); ParmVarDecl *NewParm = getDerived().TransformFunctionTypeParam(OldParm, indexAdjustment++, @@ -6240,7 +6240,7 @@ bool TreeTransform::TransformFunctionTypeParams( // We'll substitute the parameter now without expanding the pack // expansion. - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); NewParm = getDerived().TransformFunctionTypeParam(OldParm, indexAdjustment, NumExpansions, @@ -6270,7 +6270,7 @@ bool TreeTransform::TransformFunctionTypeParams( assert(ParamTypes); QualType OldType = ParamTypes[i]; bool IsPackExpansion = false; - std::optional NumExpansions; + UnsignedOrNone NumExpansions = std::nullopt; QualType NewType; if (const PackExpansionType *Expansion = dyn_cast(OldType)) { @@ -6294,7 +6294,7 @@ bool TreeTransform::TransformFunctionTypeParams( // Expand the function parameter pack into multiple, separate // parameters. for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); QualType NewType = getDerived().TransformType(Pattern); if (NewType.isNull()) return true; @@ -6337,7 +6337,7 @@ bool TreeTransform::TransformFunctionTypeParams( // expansion. OldType = Expansion->getPattern(); IsPackExpansion = true; - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); NewType = getDerived().TransformType(OldType); } else { NewType = getDerived().TransformType(OldType); @@ -6579,7 +6579,7 @@ bool TreeTransform::TransformExceptionSpec( // be expanded. bool Expand = false; bool RetainExpansion = false; - std::optional NumExpansions = PackExpansion->getNumExpansions(); + 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( @@ -6591,7 +6591,7 @@ bool TreeTransform::TransformExceptionSpec( // We can't expand this pack expansion into separate arguments yet; // just substitute into the pattern and create a new pack expansion // type. - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); QualType U = getDerived().TransformType(PackExpansion->getPattern()); if (U.isNull()) return true; @@ -6604,7 +6604,7 @@ bool TreeTransform::TransformExceptionSpec( // Substitute into the pack expansion pattern for each slice of the // pack. for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), ArgIdx); QualType U = getDerived().TransformType(PackExpansion->getPattern()); if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc)) @@ -6857,14 +6857,13 @@ TreeTransform::TransformPackIndexingType(TypeLocBuilder &TLB, // be expanded. bool ShouldExpand = true; bool RetainExpansion = false; - std::optional OrigNumExpansions; - std::optional NumExpansions = OrigNumExpansions; + UnsignedOrNone NumExpansions = std::nullopt; if (getDerived().TryExpandParameterPacks(TL.getEllipsisLoc(), SourceRange(), Unexpanded, ShouldExpand, RetainExpansion, NumExpansions)) return QualType(); if (!ShouldExpand) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); // FIXME: should we keep TypeLoc for individual expansions in // PackIndexingTypeLoc? TypeSourceInfo *TI = @@ -6888,7 +6887,7 @@ TreeTransform::TransformPackIndexingType(TypeLocBuilder &TLB, continue; } for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); QualType Out = getDerived().TransformType(T); if (Out.isNull()) return QualType(); @@ -6910,7 +6909,7 @@ TreeTransform::TransformPackIndexingType(TypeLocBuilder &TLB, // 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::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); QualType Result = getDerived().TransformType(TLB, TL.getPatternLoc()); QualType Out = getDerived().RebuildPackIndexingType( @@ -7922,7 +7921,7 @@ TreeTransform::TransformObjCObjectType(TypeLocBuilder &TLB, TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc(); bool Expand = false; bool RetainExpansion = false; - std::optional NumExpansions = PackExpansion->getNumExpansions(); + UnsignedOrNone NumExpansions = PackExpansion->getNumExpansions(); if (getDerived().TryExpandParameterPacks( PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(), Unexpanded, Expand, RetainExpansion, NumExpansions)) @@ -7932,7 +7931,7 @@ TreeTransform::TransformObjCObjectType(TypeLocBuilder &TLB, // We can't expand this pack expansion into separate arguments yet; // just substitute into the pattern and create a new pack expansion // type. - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); TypeLocBuilder TypeArgBuilder; TypeArgBuilder.reserve(PatternLoc.getFullDataSize()); @@ -7953,7 +7952,7 @@ TreeTransform::TransformObjCObjectType(TypeLocBuilder &TLB, // Substitute into the pack expansion pattern for each slice of the // pack. for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), ArgIdx); TypeLocBuilder TypeArgBuilder; TypeArgBuilder.reserve(PatternLoc.getFullDataSize()); @@ -14833,9 +14832,9 @@ TreeTransform::TransformTypeTraitExpr(TypeTraitExpr *E) { // be expanded. bool Expand = true; bool RetainExpansion = false; - std::optional OrigNumExpansions = + UnsignedOrNone OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions(); - std::optional NumExpansions = OrigNumExpansions; + UnsignedOrNone NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(), PatternTL.getSourceRange(), Unexpanded, @@ -14847,7 +14846,7 @@ TreeTransform::TransformTypeTraitExpr(TypeTraitExpr *E) { // The transform has determined that we should perform a simple // transformation on the pack expansion, producing another pack // expansion. - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); TypeLocBuilder TLB; TLB.reserve(From->getTypeLoc().getFullDataSize()); @@ -14873,7 +14872,7 @@ TreeTransform::TransformTypeTraitExpr(TypeTraitExpr *E) { // Expand the pack expansion by substituting for each argument in the // pack(s). for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I); + Sema::ArgPackSubstIndexRAII SubstIndex(SemaRef, I); TypeLocBuilder TLB; TLB.reserve(PatternTL.getFullDataSize()); QualType To = getDerived().TransformType(TLB, PatternTL); @@ -15377,7 +15376,7 @@ TreeTransform::TransformLambdaExpr(LambdaExpr *E) { auto *OldVD = cast(C->getCapturedVar()); auto SubstInitCapture = [&](SourceLocation EllipsisLoc, - std::optional NumExpansions) { + UnsignedOrNone NumExpansions) { ExprResult NewExprInitResult = getDerived().TransformInitializer( OldVD->getInit(), OldVD->getInitStyle() == VarDecl::CallInit); @@ -15410,9 +15409,9 @@ TreeTransform::TransformLambdaExpr(LambdaExpr *E) { // be expanded. bool Expand = true; bool RetainExpansion = false; - std::optional OrigNumExpansions = + UnsignedOrNone OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions(); - std::optional NumExpansions = OrigNumExpansions; + UnsignedOrNone NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks( ExpansionTL.getEllipsisLoc(), OldVD->getInit()->getSourceRange(), Unexpanded, Expand, @@ -15422,7 +15421,7 @@ TreeTransform::TransformLambdaExpr(LambdaExpr *E) { "capture since it cannot be extended"); if (Expand) { for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); SubstInitCapture(SourceLocation(), std::nullopt); } } else { @@ -15575,7 +15574,7 @@ TreeTransform::TransformLambdaExpr(LambdaExpr *E) { UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation()); bool ShouldExpand = false; bool RetainExpansion = false; - std::optional NumExpansions; + UnsignedOrNone NumExpansions = std::nullopt; if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(), C->getLocation(), Unexpanded, @@ -15591,7 +15590,7 @@ TreeTransform::TransformLambdaExpr(LambdaExpr *E) { // expansion of the pattern. Do so. auto *Pack = cast(C->getCapturedVar()); for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); ValueDecl *CapturedVar = cast_if_present( getDerived().TransformDecl(C->getLocation(), Pack)); if (!CapturedVar) { @@ -15660,8 +15659,8 @@ TreeTransform::TransformLambdaExpr(LambdaExpr *E) { assert(FPTL && "Not a FunctionProtoType?"); AssociatedConstraint TRC = E->getCallOperator()->getTrailingRequiresClause(); - if (TRC.ArgumentPackSubstitutionIndex == -1) - TRC.ArgumentPackSubstitutionIndex = SemaRef.ArgumentPackSubstitutionIndex; + if (!TRC.ArgPackSubstIndex) + TRC.ArgPackSubstIndex = SemaRef.ArgPackSubstIndex; getSema().CompleteLambdaCallOperator( NewCallOperator, E->getCallOperator()->getLocation(), @@ -16042,10 +16041,9 @@ TreeTransform::TransformPackExpansionExpr(PackExpansionExpr *E) { } template -std::optional -TreeTransform::ComputeSizeOfPackExprWithoutSubstitution( +UnsignedOrNone TreeTransform::ComputeSizeOfPackExprWithoutSubstitution( ArrayRef PackArgs) { - std::optional Result = 0; + UnsignedOrNone Result = 0u; for (const TemplateArgument &Arg : PackArgs) { if (!Arg.isPackExpansion()) { Result = *Result + 1; @@ -16057,20 +16055,20 @@ TreeTransform::ComputeSizeOfPackExprWithoutSubstitution( // Find the pattern of the pack expansion. SourceLocation Ellipsis; - std::optional OrigNumExpansions; + 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::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); if (getDerived().TransformTemplateArgument(Pattern, OutPattern, /*Uneval*/ true)) - return true; + return 1u; // See if we can determine the number of arguments from the result. - std::optional NumExpansions = + UnsignedOrNone NumExpansions = getSema().getFullyPackExpandedSize(OutPattern.getArgument()); if (!NumExpansions) { // No: we must be in an alias template expansion, and we're going to @@ -16105,7 +16103,7 @@ TreeTransform::TransformSizeOfPackExpr(SizeOfPackExpr *E) { UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc()); bool ShouldExpand = false; bool RetainExpansion = false; - std::optional NumExpansions; + UnsignedOrNone NumExpansions = std::nullopt; if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(), Unexpanded, ShouldExpand, RetainExpansion, @@ -16149,7 +16147,7 @@ TreeTransform::TransformSizeOfPackExpr(SizeOfPackExpr *E) { } // Try to compute the result without performing a partial substitution. - std::optional Result = + UnsignedOrNone Result = getDerived().ComputeSizeOfPackExprWithoutSubstitution(PackArgs); // Common case: we could determine the number of expansions without @@ -16186,9 +16184,10 @@ TreeTransform::TransformSizeOfPackExpr(SizeOfPackExpr *E) { E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(), std::nullopt, Args); - return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(), - E->getPackLoc(), E->getRParenLoc(), - Args.size(), {}); + return getDerived().RebuildSizeOfPackExpr( + E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(), + /*Length=*/static_cast(Args.size()), + /*PartialArgs=*/std::nullopt); } template @@ -16220,14 +16219,14 @@ TreeTransform::TransformPackIndexingExpr(PackIndexingExpr *E) { // be expanded. bool ShouldExpand = true; bool RetainExpansion = false; - std::optional OrigNumExpansions; - std::optional NumExpansions = OrigNumExpansions; + UnsignedOrNone OrigNumExpansions = std::nullopt, + NumExpansions = std::nullopt; if (getDerived().TryExpandParameterPacks( E->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded, ShouldExpand, RetainExpansion, NumExpansions)) return true; if (!ShouldExpand) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); ExprResult Pack = getDerived().TransformExpr(Pattern); if (Pack.isInvalid()) return ExprError(); @@ -16236,7 +16235,7 @@ TreeTransform::TransformPackIndexingExpr(PackIndexingExpr *E) { {}, /*FullySubstituted=*/false); } for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); ExprResult Out = getDerived().TransformExpr(Pattern); if (Out.isInvalid()) return true; @@ -16328,8 +16327,8 @@ TreeTransform::TransformCXXFoldExpr(CXXFoldExpr *E) { // be expanded. bool Expand = true; bool RetainExpansion = false; - std::optional OrigNumExpansions = E->getNumExpansions(), - NumExpansions = OrigNumExpansions; + UnsignedOrNone OrigNumExpansions = E->getNumExpansions(), + NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(E->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded, @@ -16340,7 +16339,7 @@ TreeTransform::TransformCXXFoldExpr(CXXFoldExpr *E) { if (!Expand) { // Do not expand any packs here, just transform and rebuild a fold // expression. - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); ExprResult LHS = E->getLHS() ? getDerived().TransformExpr(E->getLHS()) : ExprResult(); @@ -16364,7 +16363,7 @@ TreeTransform::TransformCXXFoldExpr(CXXFoldExpr *E) { // 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) { + if (NumExpansions && SemaRef.getLangOpts().BracketDepth < *NumExpansions) { SemaRef.Diag(E->getEllipsisLoc(), clang::diag::err_fold_expression_limit_exceeded) << *NumExpansions << SemaRef.getLangOpts().BracketDepth @@ -16397,7 +16396,7 @@ TreeTransform::TransformCXXFoldExpr(CXXFoldExpr *E) { } for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex( + Sema::ArgPackSubstIndexRAII SubstIndex( getSema(), LeftFold ? I : *NumExpansions - I - 1); ExprResult Out = getDerived().TransformExpr(Pattern); if (Out.isInvalid()) @@ -16544,8 +16543,8 @@ TreeTransform::TransformObjCDictionaryLiteral( // and should be expanded. bool Expand = true; bool RetainExpansion = false; - std::optional OrigNumExpansions = OrigElement.NumExpansions; - std::optional NumExpansions = OrigNumExpansions; + UnsignedOrNone OrigNumExpansions = OrigElement.NumExpansions; + UnsignedOrNone NumExpansions = OrigNumExpansions; SourceRange PatternRange(OrigElement.Key->getBeginLoc(), OrigElement.Value->getEndLoc()); if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc, @@ -16557,7 +16556,7 @@ TreeTransform::TransformObjCDictionaryLiteral( // The transform has determined that we should perform a simple // transformation on the pack expansion, producing another pack // expansion. - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt); ExprResult Key = getDerived().TransformExpr(OrigElement.Key); if (Key.isInvalid()) return ExprError(); @@ -16586,7 +16585,7 @@ TreeTransform::TransformObjCDictionaryLiteral( // The transform has determined that we should perform an elementwise // expansion of the pattern. Do so. for (unsigned I = 0; I != *NumExpansions; ++I) { - Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); ExprResult Key = getDerived().TransformExpr(OrigElement.Key); if (Key.isInvalid()) return ExprError(); diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp index 8e573a11efd35..38697eb835134 100644 --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -1321,7 +1321,7 @@ ModuleLocalNameLookupTrait::internal_key_type ModuleLocalNameLookupTrait::GetInternalKey(const external_key_type &Key) { DeclarationNameKey Name(Key.first); - std::optional ModuleHash = getPrimaryModuleHash(Key.second); + UnsignedOrNone ModuleHash = getPrimaryModuleHash(Key.second); if (!ModuleHash) return {Name, 0}; @@ -12884,7 +12884,7 @@ static unsigned getStableHashForModuleName(StringRef PrimaryModuleName) { return ID.computeStableHash(); } -std::optional clang::getPrimaryModuleHash(const Module *M) { +UnsignedOrNone clang::getPrimaryModuleHash(const Module *M) { if (!M) return std::nullopt; diff --git a/clang/lib/Serialization/ASTReaderDecl.cpp b/clang/lib/Serialization/ASTReaderDecl.cpp index 1a2b8be7e2b8a..5545cbc8d608c 100644 --- a/clang/lib/Serialization/ASTReaderDecl.cpp +++ b/clang/lib/Serialization/ASTReaderDecl.cpp @@ -904,8 +904,9 @@ void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) { if (Record.readInt()) { // hasExtInfo auto *Info = new (Reader.getContext()) DeclaratorDecl::ExtInfo(); Record.readQualifierInfo(*Info); - Info->TrailingRequiresClause = - AssociatedConstraint(Record.readExpr(), int(Record.readInt())); + Info->TrailingRequiresClause = AssociatedConstraint( + Record.readExpr(), + UnsignedOrNone::fromInternalRepresentation(Record.readUInt32())); DD->DeclInfo = Info; } QualType TSIType = Record.readType(); @@ -2710,12 +2711,10 @@ void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { if (Record.readBool()) CR = Record.readConceptReference(); Expr *ImmediatelyDeclaredConstraint = Record.readExpr(); - int ArgumentPackSubstitutionIndex = Record.readInt(); + UnsignedOrNone ArgPackSubstIndex = Record.readUnsignedOrNone(); - D->setTypeConstraint(CR, ImmediatelyDeclaredConstraint, - ArgumentPackSubstitutionIndex); - if ((D->ExpandedParameterPack = Record.readInt())) - D->NumExpanded = Record.readInt(); + D->setTypeConstraint(CR, ImmediatelyDeclaredConstraint, ArgPackSubstIndex); + D->NumExpanded = Record.readUnsignedOrNone(); } if (Record.readInt()) diff --git a/clang/lib/Serialization/ASTReaderStmt.cpp b/clang/lib/Serialization/ASTReaderStmt.cpp index 7c7abcb2d49d9..d26152f3780ed 100644 --- a/clang/lib/Serialization/ASTReaderStmt.cpp +++ b/clang/lib/Serialization/ASTReaderStmt.cpp @@ -2271,7 +2271,7 @@ void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) { E->LParenLoc = readSourceLocation(); E->EllipsisLoc = readSourceLocation(); E->RParenLoc = readSourceLocation(); - E->NumExpansions = Record.readInt(); + E->NumExpansions = Record.readUnsignedOrNone(); E->SubExprs[0] = Record.readSubExpr(); E->SubExprs[1] = Record.readSubExpr(); E->SubExprs[2] = Record.readSubExpr(); diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp index 84f7f2bc5fce4..f27be5fb4c76c 100644 --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -4267,7 +4267,7 @@ class ASTDeclContextNameLookupTrait : public ASTDeclContextNameLookupTraitBase { auto ID = Writer.GetDeclRef(DeclForLocalLookup); if (isModuleLocalDecl(D)) { - if (std::optional PrimaryModuleHash = + if (UnsignedOrNone PrimaryModuleHash = getPrimaryModuleHash(D->getOwningModule())) { auto Key = std::make_pair(D->getDeclName(), *PrimaryModuleHash); auto Iter = ModuleLocalDeclsMap.find(Key); diff --git a/clang/lib/Serialization/ASTWriterDecl.cpp b/clang/lib/Serialization/ASTWriterDecl.cpp index a4b89d0d9ed5e..3a7a23481ea98 100644 --- a/clang/lib/Serialization/ASTWriterDecl.cpp +++ b/clang/lib/Serialization/ASTWriterDecl.cpp @@ -730,8 +730,7 @@ void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) { Record.AddQualifierInfo(*Info); Record.AddStmt( const_cast(Info->TrailingRequiresClause.ConstraintExpr)); - Record.push_back( - Info->TrailingRequiresClause.ArgumentPackSubstitutionIndex); + Record.writeUnsignedOrNone(Info->TrailingRequiresClause.ArgPackSubstIndex); } // The location information is deferred until the end of the record. Record.AddTypeRef(D->getTypeSourceInfo() ? D->getTypeSourceInfo()->getType() @@ -2039,10 +2038,8 @@ void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { if (CR) Record.AddConceptReference(CR); Record.AddStmt(TC->getImmediatelyDeclaredConstraint()); - Record.push_back(TC->getArgumentPackSubstitutionIndex()); - Record.push_back(D->isExpandedParameterPack()); - if (D->isExpandedParameterPack()) - Record.push_back(D->getNumExpansionParameters()); + Record.writeUnsignedOrNone(TC->getArgPackSubstIndex()); + Record.writeUnsignedOrNone(D->getNumExpansionParameters()); } bool OwnsDefaultArg = D->hasDefaultArgument() && diff --git a/clang/lib/Serialization/ASTWriterStmt.cpp b/clang/lib/Serialization/ASTWriterStmt.cpp index 0860704368f3b..23bb5ff22efaf 100644 --- a/clang/lib/Serialization/ASTWriterStmt.cpp +++ b/clang/lib/Serialization/ASTWriterStmt.cpp @@ -2271,7 +2271,7 @@ void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) { Record.AddSourceLocation(E->LParenLoc); Record.AddSourceLocation(E->EllipsisLoc); Record.AddSourceLocation(E->RParenLoc); - Record.push_back(E->NumExpansions); + Record.push_back(E->NumExpansions.toInternalRepresentation()); Record.AddStmt(E->SubExprs[0]); Record.AddStmt(E->SubExprs[1]); Record.AddStmt(E->SubExprs[2]); diff --git a/clang/unittests/AST/ASTImporterTest.cpp b/clang/unittests/AST/ASTImporterTest.cpp index 0bac95eb40b20..40e1197bc21f1 100644 --- a/clang/unittests/AST/ASTImporterTest.cpp +++ b/clang/unittests/AST/ASTImporterTest.cpp @@ -3589,7 +3589,7 @@ TEST_P(ASTImporterOptionSpecificTestBase, ImportUnnamedFieldsInCorrectOrder) { ASSERT_FALSE(FromField->getDeclName()); auto *ToField = cast_or_null(Import(FromField, Lang_CXX11)); EXPECT_TRUE(ToField); - std::optional ToIndex = ASTImporter::getFieldIndex(ToField); + UnsignedOrNone ToIndex = ASTImporter::getFieldIndex(ToField); EXPECT_TRUE(ToIndex); EXPECT_EQ(*ToIndex, FromIndex); ++FromIndex; @@ -5472,7 +5472,7 @@ TEST_P(ASTImporterOptionSpecificTestBase, ImportSubstTemplateTypeParmType) { FromTU, classTemplateSpecializationDecl()); auto testType = [&](ASTContext &Ctx, const char *Name, - std::optional PackIndex) { + UnsignedOrNone PackIndex) { const auto *Subst = selectFirst( "sttp", match(substTemplateTypeParmType( hasReplacementType(hasCanonicalType(asString(Name)))) @@ -5486,10 +5486,10 @@ TEST_P(ASTImporterOptionSpecificTestBase, ImportSubstTemplateTypeParmType) { }; auto tests = [&](ASTContext &Ctx) { testType(Ctx, "void", std::nullopt); - testType(Ctx, "char", 3); - testType(Ctx, "float", 2); - testType(Ctx, "int", 1); - testType(Ctx, "short", 0); + testType(Ctx, "char", 3u); + testType(Ctx, "float", 2u); + testType(Ctx, "int", 1u); + testType(Ctx, "short", 0u); }; tests(FromTU->getASTContext());