[llvm-branch-commits] [clang] [clang] NFC: introduce UnsignedOrNone as a replacement for std::optional<unsigned> (PR #134142)
Matheus Izvekov via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Wed Apr 2 12:51:05 PDT 2025
https://github.com/mizvekov updated https://github.com/llvm/llvm-project/pull/134142
>From b280da4906a8a4a79d5b65edd700f414298095dd Mon Sep 17 00:00:00 2001
From: Matheus Izvekov <mizvekov at gmail.com>
Date: Wed, 2 Apr 2025 13:21:05 -0300
Subject: [PATCH] [clang] NFC: introduce UnsignedOrNone replacement for
std::optional<unsigned>
This introduces a new class 'UnsignedOrNone', which models a lite
version of std::optional<unsigned>, but has the same size as 'unsigned'.
This replaces most uses of std::optional<unsigned> and of
similar schemes utilizing 'int' and '-1' as sentinel.
---
clang/include/clang/AST/ASTConcept.h | 12 +-
clang/include/clang/AST/ASTContext.h | 20 +--
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 | 13 +-
clang/include/clang/AST/Type.h | 25 ++-
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 | 39 ++---
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 | 10 +-
clang/lib/AST/TextNodeDumper.cpp | 2 +-
clang/lib/AST/Type.cpp | 9 +-
clang/lib/Sema/Sema.cpp | 2 +-
clang/lib/Sema/SemaConcept.cpp | 21 ++-
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, 511 insertions(+), 512 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 526d4c7c12b6e..0dccb1dcc9e99 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -1795,10 +1795,9 @@ class ASTContext : public RefCountedBase<ASTContext> {
QualType Wrapped, QualType Contained,
const HLSLAttributedResourceType::Attributes &Attrs);
- QualType
- getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl,
- unsigned Index,
- std::optional<unsigned> PackIndex) const;
+ QualType getSubstTemplateTypeParmType(QualType Replacement,
+ Decl *AssociatedDecl, unsigned Index,
+ UnsignedOrNone PackIndex) const;
QualType getSubstTemplateTypeParmPackType(Decl *AssociatedDecl,
unsigned Index, bool Final,
const TemplateArgument &ArgPack);
@@ -1853,8 +1852,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
/// 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<unsigned> NumExpansions,
+ QualType getPackExpansionType(QualType Pattern, UnsignedOrNone NumExpansions,
bool ExpectPackInType = true) const;
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl,
@@ -1898,7 +1896,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
QualType getPackIndexingType(QualType Pattern, Expr *IndexExpr,
bool FullySubstituted = false,
ArrayRef<QualType> Expansions = {},
- int Index = -1) const;
+ UnsignedOrNone Index = std::nullopt) const;
/// Unary type transforms
QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType,
@@ -2393,10 +2391,10 @@ class ASTContext : public RefCountedBase<ASTContext> {
TemplateName
getDependentTemplateName(const DependentTemplateStorage &Name) const;
- TemplateName
- getSubstTemplateTemplateParm(TemplateName replacement, Decl *AssociatedDecl,
- unsigned Index,
- std::optional<unsigned> PackIndex) const;
+ TemplateName getSubstTemplateTemplateParm(TemplateName replacement,
+ Decl *AssociatedDecl,
+ unsigned Index,
+ UnsignedOrNone PackIndex) const;
TemplateName getSubstTemplateTemplateParmPack(const TemplateArgument &ArgPack,
Decl *AssociatedDecl,
unsigned Index,
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<unsigned> 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<unsigned>
- 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<unsigned> *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<unsigned> 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<unsigned> 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<int, unsigned int> 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<AssociatedConstraint> &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<int,int>::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<unsigned> getExpandedPackSize(const NamedDecl *Param) {
+inline UnsignedOrNone getExpandedPackSize(const NamedDecl *Param) {
if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
- if (TTP->isExpandedParameterPack())
- return TTP->getNumExpansionParameters();
+ if (UnsignedOrNone Num = TTP->getNumExpansionParameters())
+ return Num;
}
if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
diff --git a/clang/include/clang/AST/ExprCXX.h b/clang/include/clang/AST/ExprCXX.h
index bdc0eb81b5f02..265c29d59396c 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<unsigned> 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<unsigned> 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<unsigned> Length,
- ArrayRef<TemplateArgument> PartialArgs)
+ UnsignedOrNone Length, ArrayRef<TemplateArgument> 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<unsigned> Length = std::nullopt,
+ UnsignedOrNone Length = std::nullopt,
ArrayRef<TemplateArgument> PartialArgs = {});
static SizeOfPackExpr *CreateDeserialized(ASTContext &Context,
unsigned NumPartialArgs);
@@ -4467,7 +4466,7 @@ class PackIndexingExpr final
Expr *getIndexExpr() const { return cast<Expr>(SubExprs[1]); }
- std::optional<unsigned> getSelectedIndex() const {
+ UnsignedOrNone getSelectedIndex() const {
if (isInstantiationDependent())
return std::nullopt;
ConstantExpr *CE = cast<ConstantExpr>(getIndexExpr());
@@ -4477,7 +4476,7 @@ class PackIndexingExpr final
}
Expr *getSelectedExpr() const {
- std::optional<unsigned> Index = getSelectedIndex();
+ UnsignedOrNone Index = getSelectedIndex();
assert(Index && "extracting the indexed expression of a dependant pack");
return getTrailingObjects<Expr *>()[*Index];
}
@@ -4523,11 +4522,11 @@ class SubstNonTypeTemplateParmExpr : public Expr {
SubstNonTypeTemplateParmExpr(QualType Ty, ExprValueKind ValueKind,
SourceLocation Loc, Expr *Replacement,
Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex, bool RefParam)
+ UnsignedOrNone PackIndex, bool RefParam)
: Expr(SubstNonTypeTemplateParmExprClass, Ty, ValueKind, OK_Ordinary),
Replacement(Replacement),
AssociatedDeclAndRef(AssociatedDecl, RefParam), Index(Index),
- PackIndex(PackIndex ? *PackIndex + 1 : 0) {
+ PackIndex(PackIndex.toInternalRepresentation()) {
assert(AssociatedDecl != nullptr);
SubstNonTypeTemplateParmExprBits.NameLoc = Loc;
setDependence(computeDependence(this));
@@ -4549,10 +4548,8 @@ class SubstNonTypeTemplateParmExpr : public Expr {
/// This should match the result of `getParameter()->getIndex()`.
unsigned getIndex() const { return Index; }
- std::optional<unsigned> getPackIndex() const {
- if (PackIndex == 0)
- return std::nullopt;
- return PackIndex - 1;
+ UnsignedOrNone getPackIndex() const {
+ return UnsignedOrNone::fromInternalRepresentation(PackIndex);
}
NonTypeTemplateParmDecl *getParameter() const;
@@ -4867,7 +4864,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;
@@ -4875,7 +4872,7 @@ class CXXFoldExpr : public Expr {
CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee,
SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Opcode,
SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc,
- std::optional<unsigned> NumExpansions);
+ UnsignedOrNone NumExpansions);
CXXFoldExpr(EmptyShell Empty) : Expr(CXXFoldExprClass, Empty) {}
@@ -4904,11 +4901,7 @@ class CXXFoldExpr : public Expr {
SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
BinaryOperatorKind getOperator() const { return Opcode; }
- std::optional<unsigned> 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<unsigned> 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<unsigned> (*)(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 5171555008ac9..0b0eccfa6ebce 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<TemplateName, "SubstTemplateTemplateParm"> in {
def : Property<"index", UInt32> {
let Read = [{ parm->getIndex() }];
}
- def : Property<"packIndex", Optional<UInt32>> {
+ def : Property<"packIndex", UnsignedOrNone> {
let Read = [{ parm->getPackIndex() }];
}
def : Creator<[{
@@ -859,21 +860,16 @@ let Class = PropertyTypeCase<TemplateArgument, "TemplateExpansion"> in {
def : Property<"name", TemplateName> {
let Read = [{ node.getAsTemplateOrTemplatePattern() }];
}
- def : Property<"numExpansions", Optional<UInt32>> {
+ 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<TemplateArgument, "Expression"> 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<unsigned> 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<unsigned> 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 1a56133b72d6e..3bcbc4522f287 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,9 +415,9 @@ class SubstTemplateTemplateParmStorage
SubstTemplateTemplateParmStorage(TemplateName Replacement,
Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex)
+ UnsignedOrNone PackIndex)
: UncommonTemplateNameStorage(SubstTemplateTemplateParm, Index,
- PackIndex ? *PackIndex + 1 : 0),
+ PackIndex.toInternalRepresentation()),
Replacement(Replacement), AssociatedDecl(AssociatedDecl) {
assert(AssociatedDecl != nullptr);
}
@@ -430,10 +431,8 @@ class SubstTemplateTemplateParmStorage
/// This should match the result of `getParameter()->getIndex()`.
unsigned getIndex() const { return Bits.Index; }
- std::optional<unsigned> getPackIndex() const {
- if (Bits.Data == 0)
- return std::nullopt;
- return Bits.Data - 1;
+ UnsignedOrNone getPackIndex() const {
+ return UnsignedOrNone::fromInternalRepresentation(Bits.Data);
}
TemplateTemplateParmDecl *getParameter() const;
@@ -443,7 +442,7 @@ class SubstTemplateTemplateParmStorage
static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Replacement,
Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex);
+ UnsignedOrNone PackIndex);
};
class DeducedTemplateStorage : public UncommonTemplateNameStorage,
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index cfd417068abb7..894e7349afd35 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -5959,7 +5959,7 @@ class PackIndexingType final
return *(getExpansionsPtr() + *getSelectedIndex());
}
- std::optional<unsigned> getSelectedIndex() const;
+ UnsignedOrNone getSelectedIndex() const;
bool hasSelectedType() const { return getSelectedIndex() != std::nullopt; }
@@ -6397,7 +6397,7 @@ class SubstTemplateTypeParmType final
Decl *AssociatedDecl;
SubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl,
- unsigned Index, std::optional<unsigned> PackIndex);
+ unsigned Index, UnsignedOrNone PackIndex);
public:
/// Gets the type that was substituted for the template
@@ -6420,10 +6420,9 @@ class SubstTemplateTypeParmType final
/// This should match the result of `getReplacedParameter()->getIndex()`.
unsigned getIndex() const { return SubstTemplateTypeParmTypeBits.Index; }
- std::optional<unsigned> 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; }
@@ -6436,11 +6435,11 @@ class SubstTemplateTypeParmType final
static void Profile(llvm::FoldingSetNodeID &ID, QualType Replacement,
const Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex) {
+ UnsignedOrNone PackIndex) {
Replacement.Profile(ID);
ID.AddPointer(AssociatedDecl);
ID.AddInteger(Index);
- ID.AddInteger(PackIndex ? *PackIndex - 1 : 0);
+ ID.AddInteger(PackIndex.toInternalRepresentation());
}
static bool classof(const Type *T) {
@@ -7138,7 +7137,7 @@ class PackExpansionType : public Type, public llvm::FoldingSetNode {
QualType Pattern;
PackExpansionType(QualType Pattern, QualType Canon,
- std::optional<unsigned> NumExpansions)
+ UnsignedOrNone NumExpansions)
: Type(PackExpansion, Canon,
(Pattern->getDependence() | TypeDependence::Dependent |
TypeDependence::Instantiation) &
@@ -7156,7 +7155,7 @@ class PackExpansionType : public Type, public llvm::FoldingSetNode {
/// Retrieve the number of expansions that this pack expansion will
/// generate, if known.
- std::optional<unsigned> getNumExpansions() const {
+ UnsignedOrNone getNumExpansions() const {
if (PackExpansionTypeBits.NumExpansions)
return PackExpansionTypeBits.NumExpansions - 1;
return std::nullopt;
@@ -7170,11 +7169,9 @@ class PackExpansionType : public Type, public llvm::FoldingSetNode {
}
static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern,
- std::optional<unsigned> 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 391fd26a086f7..530601abe3304 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<UInt32>> {
+ def : Property<"PackIndex", UnsignedOrNone> {
let Read = [{ node->getPackIndex() }];
}
@@ -854,7 +854,7 @@ let Class = PackExpansionType in {
def : Property<"pattern", QualType> {
let Read = [{ node->getPattern() }];
}
- def : Property<"numExpansions", Optional<UInt32>> {
+ 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..3f5a31865c49b
--- /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 <cassert>
+#include <optional>
+
+namespace clang {
+
+struct UnsignedOrNone {
+ constexpr UnsignedOrNone(std::nullopt_t) : Rep(0) {}
+ UnsignedOrNone(unsigned Index) : Rep(Index + 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 3a18bcb8a38da..1bc43f05b9f25 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<unsigned int> 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
@@ -8889,10 +8889,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<unsigned> 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.
@@ -13343,28 +13344,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;
@@ -13464,7 +13462,7 @@ class Sema final : public SemaBase {
ParmVarDecl *
SubstParmVarDecl(ParmVarDecl *D,
const MultiLevelTemplateArgumentList &TemplateArgs,
- int indexAdjustment, std::optional<unsigned> NumExpansions,
+ int indexAdjustment, UnsignedOrNone NumExpansions,
bool ExpectParameterPack, bool EvaluateConstraints = true);
/// Substitute the given template arguments into the given set of
@@ -14314,13 +14312,13 @@ class Sema final : public SemaBase {
/// expansion.
TypeSourceInfo *CheckPackExpansion(TypeSourceInfo *Pattern,
SourceLocation EllipsisLoc,
- std::optional<unsigned> 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<unsigned> NumExpansions);
+ UnsignedOrNone NumExpansions);
/// Invoked when parsing an expression followed by an ellipsis, which
/// creates a pack expansion.
@@ -14339,7 +14337,7 @@ class Sema final : public SemaBase {
///
/// \param EllipsisLoc The location of the ellipsis.
ExprResult CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
- std::optional<unsigned> NumExpansions);
+ UnsignedOrNone NumExpansions);
/// Determine whether we could expand a pack expansion with the
/// given set of parameter packs into separate arguments by repeatedly
@@ -14379,7 +14377,7 @@ class Sema final : public SemaBase {
SourceLocation EllipsisLoc, SourceRange PatternRange,
ArrayRef<UnexpandedParameterPack> Unexpanded,
const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand,
- bool &RetainExpansion, std::optional<unsigned> &NumExpansions);
+ bool &RetainExpansion, UnsignedOrNone &NumExpansions);
/// Determine the number of arguments in the given pack expansion
/// type.
@@ -14388,10 +14386,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<unsigned> getNumArgumentsInExpansion(
+ UnsignedOrNone getNumArgumentsInExpansion(
QualType T, const MultiLevelTemplateArgumentList &TemplateArgs);
- std::optional<unsigned> getNumArgumentsInExpansionFromUnexpanded(
+ UnsignedOrNone getNumArgumentsInExpansionFromUnexpanded(
llvm::ArrayRef<UnexpandedParameterPack> Unexpanded,
const MultiLevelTemplateArgumentList &TemplateArgs);
@@ -14420,9 +14418,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<unsigned> &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
@@ -14430,7 +14429,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<unsigned> getFullyPackExpandedSize(TemplateArgument Arg);
+ UnsignedOrNone getFullyPackExpandedSize(TemplateArgument Arg);
/// Called when an expression computing the size of a parameter pack
/// is parsed.
@@ -14472,7 +14471,7 @@ class Sema final : public SemaBase {
BinaryOperatorKind Operator,
SourceLocation EllipsisLoc, Expr *RHS,
SourceLocation RParenLoc,
- std::optional<unsigned> 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<unsigned> getStackIndexOfNearestEnclosingCaptureCapableLambda(
+UnsignedOrNone getStackIndexOfNearestEnclosingCaptureCapableLambda(
ArrayRef<const sema::FunctionScopeInfo *> 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<unsigned> 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<TemplateDeclInstantiator, Decl *>
{
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<unsigned> 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 2779b3d1cf2ea..f988eb3f2826b 100644
--- a/clang/include/clang/Serialization/ASTReader.h
+++ b/clang/include/clang/Serialization/ASTReader.h
@@ -2653,7 +2653,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<unsigned> 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 5483503fefddf..fcd8d78a6c74a 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<TemplateTypeParmDecl>(*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<unsigned>(TTP->getNumExpansionParameters())
- : std::nullopt);
+ TTP->getNumExpansionParameters());
CanonParams.push_back(NewTTP);
} else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
QualType T = getUnconstrainedType(getCanonicalType(NTTP->getType()));
@@ -5445,9 +5440,10 @@ QualType ASTContext::getHLSLAttributedResourceType(
return QualType(Ty, 0);
}
/// Retrieve a substitution-result type.
-QualType ASTContext::getSubstTemplateTypeParmType(
- QualType Replacement, Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex) const {
+QualType
+ASTContext::getSubstTemplateTypeParmType(QualType Replacement,
+ Decl *AssociatedDecl, unsigned Index,
+ UnsignedOrNone PackIndex) const {
llvm::FoldingSetNodeID ID;
SubstTemplateTypeParmType::Profile(ID, Replacement, AssociatedDecl, Index,
PackIndex);
@@ -5863,7 +5859,7 @@ TemplateArgument ASTContext::getInjectedTemplateArg(NamedDecl *Param) const {
TemplateName Name = getQualifiedTemplateName(
nullptr, /*TemplateKeyword=*/false, TemplateName(TTP));
if (TTP->isParameterPack())
- Arg = TemplateArgument(Name, std::optional<unsigned>());
+ Arg = TemplateArgument(Name, /*NumExpansions=*/std::nullopt);
else
Arg = TemplateArgument(Name);
}
@@ -5876,7 +5872,7 @@ TemplateArgument ASTContext::getInjectedTemplateArg(NamedDecl *Param) const {
}
QualType ASTContext::getPackExpansionType(QualType Pattern,
- std::optional<unsigned> NumExpansions,
+ UnsignedOrNone NumExpansions,
bool ExpectPackInType) const {
assert((!ExpectPackInType || Pattern->containsUnexpandedParameterPack()) &&
"Pack expansions must expand one or more parameter packs");
@@ -6371,10 +6367,10 @@ QualType ASTContext::getDecltypeType(Expr *e, QualType UnderlyingType) const {
QualType ASTContext::getPackIndexingType(QualType Pattern, Expr *IndexExpr,
bool FullySubstituted,
ArrayRef<QualType> 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 +7068,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 +10093,10 @@ ASTContext::getDependentTemplateName(const DependentTemplateStorage &S) const {
return TemplateName(QTN);
}
-TemplateName ASTContext::getSubstTemplateTemplateParm(
- TemplateName Replacement, Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex) const {
+TemplateName
+ASTContext::getSubstTemplateTemplateParm(TemplateName Replacement,
+ Decl *AssociatedDecl, unsigned Index,
+ UnsignedOrNone PackIndex) const {
llvm::FoldingSetNodeID ID;
SubstTemplateTemplateParmStorage::Profile(ID, Replacement, AssociatedDecl,
Index, PackIndex);
@@ -12974,7 +12971,7 @@ MangleContext *ASTContext::createDeviceMangleContext(const TargetInfo &T) {
case TargetCXXABI::XL:
return ItaniumMangleContext::create(
*this, getDiagnostics(),
- [](ASTContext &, const NamedDecl *ND) -> std::optional<unsigned> {
+ [](ASTContext &, const NamedDecl *ND) -> UnsignedOrNone {
if (const auto *RD = dyn_cast<CXXRecordDecl>(ND))
return RD->getDeviceLambdaManglingNumber();
return std::nullopt;
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index 286d159b46ab2..f2d5cca85c56d 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<unsigned int> FriendPosition;
+ UnsignedOrNone FriendPosition = std::nullopt;
const auto *RD = cast<CXXRecordDecl>(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<unsigned> Length;
+ UnsignedOrNone Length = std::nullopt;
if (!E->isValueDependent())
Length = E->getPackLength();
@@ -9042,7 +9041,7 @@ ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
ASTImporter::~ASTImporter() = default;
-std::optional<unsigned> ASTImporter::getFieldIndex(Decl *F) {
+UnsignedOrNone ASTImporter::getFieldIndex(Decl *F) {
assert(F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*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<unsigned> Index1 =
+ if (UnsignedOrNone Index1 =
StructuralEquivalenceContext::findUntaggedStructOrUnionIndex(D1)) {
- if (std::optional<unsigned> 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<unsigned>
+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<unsigned> 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<unsigned> *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<unsigned> Expansions = getExpandedPackSize(P)) {
+ if (UnsignedOrNone Expansions = getExpandedPackSize(P)) {
NumRequiredArgs += *Expansions;
continue;
}
@@ -230,7 +230,7 @@ void TemplateParameterList::getAssociatedConstraints(
if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
if (const auto *TC = TTP->getTypeConstraint())
ACs.emplace_back(TC->getImmediatelyDeclaredConstraint(),
- TC->getArgumentPackSubstitutionIndex());
+ TC->getArgPackSubstIndex());
} else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(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<unsigned> NumExpanded) {
+ UnsignedOrNone NumExpanded) {
auto *TTPDecl =
new (C, DC,
additionalSizeToAlloc<TypeConstraint>(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>()) TypeConstraint(
- Loc, ImmediatelyDeclaredConstraint, ArgumentPackSubstitutionIndex);
+ new (getTrailingObjects<TypeConstraint>())
+ 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<unsigned> {
+ const NamedDecl *ND) -> UnsignedOrNone {
if (const auto *RD = dyn_cast<CXXRecordDecl>(ND))
return RD->getDeviceLambdaManglingNumber();
return std::nullopt;
diff --git a/clang/lib/AST/ExprCXX.cpp b/clang/lib/AST/ExprCXX.cpp
index 232a23223f556..e4a3f051b6dd9 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<unsigned> Length,
+ UnsignedOrNone Length,
ArrayRef<TemplateArgument> PartialArgs) {
void *Storage =
Context.Allocate(totalSizeToAlloc<TemplateArgument>(PartialArgs.size()));
@@ -1979,14 +1979,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<unsigned> 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(
// <lambda-sig> ::= <template-param-decl>* <parameter-type>+
// # Parameter types or 'v' for 'void'.
if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(TD)) {
- std::optional<unsigned> 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<unsigned> 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<unsigned> {
+ [](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<unsigned> 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<unsigned> 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 031b58123fc99..734b33849a2f7 100644
--- a/clang/lib/AST/TemplateName.cpp
+++ b/clang/lib/AST/TemplateName.cpp
@@ -80,13 +80,15 @@ void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID) {
Profile(ID, Replacement, getAssociatedDecl(), getIndex(), getPackIndex());
}
-void SubstTemplateTemplateParmStorage::Profile(
- llvm::FoldingSetNodeID &ID, TemplateName Replacement, Decl *AssociatedDecl,
- unsigned Index, std::optional<unsigned> PackIndex) {
+void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID,
+ TemplateName Replacement,
+ Decl *AssociatedDecl,
+ unsigned Index,
+ UnsignedOrNone PackIndex) {
Replacement.Profile(ID);
ID.AddPointer(AssociatedDecl);
ID.AddInteger(Index);
- ID.AddInteger(PackIndex ? *PackIndex + 1 : 0);
+ ID.AddInteger(PackIndex.toInternalRepresentation());
}
SubstTemplateTemplateParmPackStorage::SubstTemplateTemplateParmPackStorage(
diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp
index 1fe6f2c722acf..361691fdc69d1 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<unsigned int> PackIndex = STS->getPackIndex())
+ if (UnsignedOrNone PackIndex = STS->getPackIndex())
OS << " pack_index " << *PackIndex;
if (const TemplateTemplateParmDecl *P = STS->getParameter())
AddChild("parameter", [=] { Visit(P); });
diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
index 667ffc0e599a6..3497fc3f96b10 100644
--- a/clang/lib/AST/Type.cpp
+++ b/clang/lib/AST/Type.cpp
@@ -4059,7 +4059,7 @@ PackIndexingType::PackIndexingType(const ASTContext &Context,
getTrailingObjects<QualType>());
}
-std::optional<unsigned> PackIndexingType::getSelectedIndex() const {
+UnsignedOrNone PackIndexingType::getSelectedIndex() const {
if (isInstantiationDependentType())
return std::nullopt;
// Should only be not a constant for error recovery.
@@ -4261,9 +4261,10 @@ static const TemplateTypeParmDecl *getReplacedParameter(Decl *D,
getReplacedTemplateParameterList(D)->getParam(Index));
}
-SubstTemplateTypeParmType::SubstTemplateTypeParmType(
- QualType Replacement, Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex)
+SubstTemplateTypeParmType::SubstTemplateTypeParmType(QualType Replacement,
+ Decl *AssociatedDecl,
+ unsigned Index,
+ UnsignedOrNone PackIndex)
: Type(SubstTemplateTypeParm, Replacement.getCanonicalType(),
Replacement->getDependence()),
AssociatedDecl(AssociatedDecl) {
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 eccdaf2400e00..012ad6561ab50 100644
--- a/clang/lib/Sema/SemaConcept.cpp
+++ b/clang/lib/Sema/SemaConcept.cpp
@@ -269,12 +269,12 @@ calculateConstraintSatisfaction(Sema &S, const CXXFoldExpr *FE,
if (Conjunction != Satisfaction.IsSatisfied)
return Out;
}
- std::optional<unsigned> NumExpansions =
+ UnsignedOrNone NumExpansions =
Evaluator.EvaluateFoldExpandedConstraintSize(FE);
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(),
Satisfaction, Evaluator);
if (Res.isInvalid())
@@ -528,7 +528,7 @@ static ExprResult calculateConstraintSatisfaction(
return SubstitutedExpression;
}
- std::optional<unsigned>
+ UnsignedOrNone
EvaluateFoldExpandedConstraintSize(const CXXFoldExpr *FE) const {
// We should ignore errors in the presence of packs of different size.
@@ -541,15 +541,15 @@ static ExprResult calculateConstraintSatisfaction(
assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
bool Expand = true;
bool RetainExpansion = false;
- std::optional<unsigned> OrigNumExpansions = FE->getNumExpansions(),
- NumExpansions = OrigNumExpansions;
+ UnsignedOrNone OrigNumExpansions = FE->getNumExpansions(),
+ NumExpansions = OrigNumExpansions;
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
@@ -594,8 +594,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);
@@ -697,9 +696,9 @@ bool Sema::CheckConstraintSatisfaction(const Expr *ConstraintExpr,
return S.PerformContextuallyConvertToBool(const_cast<Expr *>(AtomicExpr));
}
- std::optional<unsigned>
+ UnsignedOrNone
EvaluateFoldExpandedConstraintSize(const CXXFoldExpr *FE) const {
- return 0;
+ return 0u;
}
};
@@ -1487,7 +1486,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 cf05b1c55bb72..cc1d2ead15b1f 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -16754,7 +16754,7 @@ void Sema::AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(
FD->getDeclName().getCXXOverloadedOperator() != OO_Array_New)
return;
- std::optional<unsigned> 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 87c2b1b7eee1e..45dc69a59e3c9 100644
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -1662,8 +1662,8 @@ void Sema::CheckCompleteDecompositionDeclaration(DecompositionDecl *DD) {
DD->setInvalidDecl();
}
-std::optional<unsigned> Sema::GetDecompositionElementCount(QualType T,
- SourceLocation Loc) {
+UnsignedOrNone Sema::GetDecompositionElementCount(QualType T,
+ SourceLocation Loc) {
const ASTContext &Ctx = getASTContext();
assert(!T->isDependentType());
@@ -1673,18 +1673,18 @@ std::optional<unsigned> Sema::GetDecompositionElementCount(QualType T,
T = Context.getQualifiedType(Unqual, Quals);
if (auto *CAT = Ctx.getAsConstantArrayType(T))
- return CAT->getSize().getZExtValue();
+ return static_cast<unsigned>(CAT->getSize().getZExtValue());
if (auto *VT = T->getAs<VectorType>())
return VT->getNumElements();
if (T->getAs<ComplexType>())
- 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<unsigned>(TupleSize.getExtValue());
case IsTupleLike::NotTupleLike:
break;
}
diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp
index fa492bc124abd..909f3514f2d49 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<unsigned> AlignmentParam;
+ UnsignedOrNone AlignmentParam = std::nullopt;
if (FD.isReplaceableGlobalAllocationFunction(&AlignmentParam) &&
AlignmentParam)
return true;
@@ -5820,7 +5820,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<unsigned> Size =
+ UnsignedOrNone Size =
S.GetDecompositionElementCount(T, ArgRange.getBegin());
if (!Size) {
S.Diag(KWLoc, diag::err_arg_is_not_destructurable) << T << ArgRange;
@@ -8779,7 +8779,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<unsigned> Index =
+ if (const UnsignedOrNone Index =
getStackIndexOfNearestEnclosingCaptureCapableLambda(
S.FunctionScopes, Var, S))
S.MarkCaptureUsedInEnclosingContext(Var, VarExpr->getExprLoc(), *Index);
@@ -8812,7 +8812,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<unsigned> 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 9f82433a0b335..e590dccc03808 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<unsigned> 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<unsigned>
-getStackIndexOfNearestEnclosingCaptureReadyLambda(
+static inline UnsignedOrNone getStackIndexOfNearestEnclosingCaptureReadyLambda(
ArrayRef<const clang::sema::FunctionScopeInfo *> FunctionScopes,
ValueDecl *VarToCapture) {
// Label failure to capture.
- const std::optional<unsigned> 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<unsigned> 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<unsigned>
-clang::getStackIndexOfNearestEnclosingCaptureCapableLambda(
+UnsignedOrNone clang::getStackIndexOfNearestEnclosingCaptureCapableLambda(
ArrayRef<const sema::FunctionScopeInfo *> FunctionScopes,
ValueDecl *VarToCapture, Sema &S) {
- const std::optional<unsigned> NoLambdaIsCaptureCapable;
+ const UnsignedOrNone NoLambdaIsCaptureCapable = std::nullopt;
- const std::optional<unsigned> 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<unsigned> 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 fea334e9e80ff..325922ed4bfe4 100644
--- a/clang/lib/Sema/SemaOpenACC.cpp
+++ b/clang/lib/Sema/SemaOpenACC.cpp
@@ -285,7 +285,8 @@ void SemaOpenACC::AssociatedStmtRAII::SetTileInfoBeforeAssociatedStmt(
OpenACCTileClause *TileClause = cast<OpenACCTileClause>(*TileClauseItr);
SemaRef.TileInfo.ActiveTile = TileClause;
SemaRef.TileInfo.TileDepthSatisfied = false;
- SemaRef.TileInfo.CurTileCount = TileClause->getSizeExprs().size();
+ SemaRef.TileInfo.CurTileCount =
+ static_cast<unsigned>(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<unsigned> DeductionFailureInfo::getCallArgIndex() {
+UnsignedOrNone DeductionFailureInfo::getCallArgIndex() {
switch (static_cast<TemplateDeductionResult>(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 eace9b87a5bfe..b8973f12b19f0 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<unsigned int>());
+ 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;
}
@@ -5253,8 +5252,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<PackExpansionType>()) {
- Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this,
- ArgumentPackIndex);
+ Sema::ArgPackSubstIndexRAII SubstIndex(*this, ArgumentPackIndex);
NTTPType = SubstType(PET->getPattern(), MLTAL, NTTP->getLocation(),
NTTP->getDeclName());
} else {
@@ -5572,7 +5570,7 @@ bool Sema::CheckTemplateArgumentList(
// If we have an expanded parameter pack, make sure we don't have too
// many arguments.
- if (std::optional<unsigned> 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<unsigned> 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<unsigned> 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<bool>(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<unsigned> 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<unsigned> FixedNumExpansions;
+ UnsignedOrNone FixedNumExpansions = std::nullopt;
SmallVector<DeducedPack, 2> 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<unsigned> 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<unsigned> 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<unsigned> 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<unsigned> 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<TemplateArgument> DeducedArgs, bool CheckConsistency) {
+ Sema &S, FunctionTemplateDecl *FTD, UnsignedOrNone ArgIdx, QualType P,
+ QualType A, ArrayRef<TemplateArgument> 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<DeducedTemplateArgument> &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<unsigned>(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<TemplateArgument, 16> Depth1Args;
- AssociatedConstraint OuterRC(TemplateParams->getRequiresClause(),
- /*ArgumentPackSubstitutionIndex=*/-1);
+ AssociatedConstraint OuterRC(TemplateParams->getRequiresClause());
if (FTD) {
TemplateParameterList *InnerParams = FTD->getTemplateParameters();
SmallVector<NamedDecl *, 16> AllParams;
@@ -469,8 +466,7 @@ struct ConvertConstructorToDeductionGuideTransform {
const_cast<Expr *>(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<Expr *>(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<PackExpansionTypeLoc>()) {
// 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<Expr *>(Constraint.ConstraintExpr));
if (!Conjunction.isInvalid()) {
Constraint.ConstraintExpr = Conjunction.getAs<Expr>();
- 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 9f5ca9dca8e89..751112573640f 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -1350,9 +1350,9 @@ std::optional<TemplateDeductionInfo *> 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<unsigned> 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<UnexpandedParameterPack> Unexpanded,
bool &ShouldExpand, bool &RetainExpansion,
- std::optional<unsigned> &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<unsigned> ComputeSizeOfPackExprWithoutSubstitution(
+ UnsignedOrNone ComputeSizeOfPackExprWithoutSubstitution(
ArrayRef<TemplateArgument> 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<unsigned> 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<unsigned> PackIndex,
+ Decl *AssociatedDecl, unsigned Index, UnsignedOrNone PackIndex,
TemplateArgument Arg, SourceLocation NameLoc);
/// Transforms an already-substituted template type parameter pack
@@ -1865,11 +1865,9 @@ namespace {
Sema::ExtParameterInfoBuilder &PInfos);
private:
- ExprResult
- transformNonTypeTemplateParmRef(Decl *AssociatedDecl,
- const NonTypeTemplateParmDecl *parm,
- SourceLocation loc, TemplateArgument arg,
- std::optional<unsigned> PackIndex);
+ ExprResult transformNonTypeTemplateParmRef(
+ Decl *AssociatedDecl, const NonTypeTemplateParmDecl *parm,
+ SourceLocation loc, TemplateArgument arg, UnsignedOrNone PackIndex);
};
}
@@ -1958,7 +1956,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);
@@ -2063,12 +2061,12 @@ TemplateName TemplateInstantiator::TransformTemplateName(
auto [AssociatedDecl, Final] =
TemplateArgs.getAssociatedDecl(TTP->getDepth());
- std::optional<unsigned> 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.
@@ -2092,7 +2090,7 @@ TemplateName TemplateInstantiator::TransformTemplateName(
if (SubstTemplateTemplateParmPackStorage *SubstPack
= Name.getAsSubstTemplateTemplateParmPack()) {
- if (getSema().ArgumentPackSubstitutionIndex == -1)
+ if (!getSema().ArgPackSubstIndex)
return Name;
TemplateArgument Pack = SubstPack->getArgumentPack();
@@ -2145,12 +2143,12 @@ TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
}
auto [AssociatedDecl, _] = TemplateArgs.getAssociatedDecl(NTTP->getDepth());
- std::optional<unsigned> 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.
@@ -2268,8 +2266,7 @@ TemplateInstantiator::TransformOpenACCRoutineDeclAttr(
ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
Decl *AssociatedDecl, const NonTypeTemplateParmDecl *parm,
- SourceLocation loc, TemplateArgument arg,
- std::optional<unsigned> PackIndex) {
+ SourceLocation loc, TemplateArgument arg, UnsignedOrNone PackIndex) {
ExprResult result;
// Determine the substituted parameter type. We can usually infer this from
@@ -2277,7 +2274,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<PackExpansionType>(T))
@@ -2344,7 +2341,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;
}
@@ -2409,9 +2406,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<ValueDecl>(TransformDecl(E->getExprLoc(), D));
if (!VD)
return ExprError();
@@ -2453,7 +2450,7 @@ TemplateInstantiator::TransformFunctionParmPackRefExpr(DeclRefExpr *E,
if (DeclArgumentPack *Pack = dyn_cast<DeclArgumentPack *>(*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();
@@ -2463,7 +2460,7 @@ TemplateInstantiator::TransformFunctionParmPackRefExpr(DeclRefExpr *E,
return PackExpr;
}
- TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex];
+ TransformedDecl = (*Pack)[*getSema().ArgPackSubstIndex];
} else {
TransformedDecl = cast<Decl *>(*Found);
}
@@ -2528,8 +2525,8 @@ QualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB,
}
ParmVarDecl *TemplateInstantiator::TransformFunctionTypeParam(
- ParmVarDecl *OldParm, int indexAdjustment,
- std::optional<unsigned> NumExpansions, bool ExpectParameterPack) {
+ ParmVarDecl *OldParm, int indexAdjustment, UnsignedOrNone NumExpansions,
+ bool ExpectParameterPack) {
auto NewParm = SemaRef.SubstParmVarDecl(
OldParm, TemplateArgs, indexAdjustment, NumExpansions,
ExpectParameterPack, EvaluateConstraints);
@@ -2540,7 +2537,7 @@ ParmVarDecl *TemplateInstantiator::TransformFunctionTypeParam(
QualType TemplateInstantiator::BuildSubstTemplateTypeParmType(
TypeLocBuilder &TLB, bool SuppressObjCLifetime, bool Final,
- Decl *AssociatedDecl, unsigned Index, std::optional<unsigned> PackIndex,
+ Decl *AssociatedDecl, unsigned Index, UnsignedOrNone PackIndex,
TemplateArgument Arg, SourceLocation NameLoc) {
QualType Replacement = Arg.getAsType();
@@ -2606,12 +2603,12 @@ TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
auto [AssociatedDecl, Final] =
TemplateArgs.getAssociatedDecl(T->getDepth());
- std::optional<unsigned> 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.
@@ -2659,7 +2656,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())
@@ -2878,7 +2875,7 @@ TemplateInstantiator::TransformNestedRequirement(
if (!SemaRef.CheckConstraintSatisfaction(
nullptr,
AssociatedConstraint(Req->getConstraintExpr(),
- SemaRef.ArgumentPackSubstitutionIndex),
+ SemaRef.ArgPackSubstIndex),
Result, TemplateArgs, Req->getConstraintExpr()->getSourceRange(),
Satisfaction) &&
!Result.empty())
@@ -3162,9 +3159,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;
@@ -3189,10 +3186,11 @@ bool Sema::SubstTypeConstraint(
: SourceLocation());
}
-ParmVarDecl *Sema::SubstParmVarDecl(
- ParmVarDecl *OldParm, const MultiLevelTemplateArgumentList &TemplateArgs,
- int indexAdjustment, std::optional<unsigned> 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;
@@ -3434,7 +3432,7 @@ Sema::SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
Unexpanded);
bool ShouldExpand = false;
bool RetainExpansion = false;
- std::optional<unsigned> NumExpansions;
+ UnsignedOrNone NumExpansions = std::nullopt;
if (CheckParameterPacksForExpansion(Base.getEllipsisLoc(),
Base.getSourceRange(),
Unexpanded,
@@ -3448,7 +3446,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,
@@ -3476,7 +3474,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 4e208b993cabd..4d705a36e2fcb 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<unsigned> 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<unsigned> 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<FriendDecl *> 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)
@@ -3416,10 +3416,10 @@ Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
TemplateTypeParmDecl *D) {
assert(D->getTypeForDecl()->isTemplateTypeParmType());
- std::optional<unsigned> 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");
@@ -3526,9 +3526,9 @@ Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
// be expanded.
bool Expand = true;
bool RetainExpansion = false;
- std::optional<unsigned> OrigNumExpansions =
+ UnsignedOrNone OrigNumExpansions =
Expansion.getTypePtr()->getNumExpansions();
- std::optional<unsigned> NumExpansions = OrigNumExpansions;
+ UnsignedOrNone NumExpansions = OrigNumExpansions;
if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(),
Pattern.getSourceRange(),
Unexpanded,
@@ -3539,7 +3539,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());
@@ -3564,7 +3564,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());
@@ -3699,7 +3699,7 @@ TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
// be expanded.
bool Expand = true;
bool RetainExpansion = false;
- std::optional<unsigned> NumExpansions;
+ UnsignedOrNone NumExpansions = std::nullopt;
if (SemaRef.CheckParameterPacksForExpansion(D->getLocation(),
TempParams->getSourceRange(),
Unexpanded,
@@ -3710,7 +3710,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)
@@ -3726,7 +3726,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);
@@ -3976,7 +3976,7 @@ Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl(
// be expanded.
bool Expand = true;
bool RetainExpansion = false;
- std::optional<unsigned> NumExpansions;
+ UnsignedOrNone NumExpansions = std::nullopt;
if (SemaRef.CheckParameterPacksForExpansion(
D->getEllipsisLoc(), D->getSourceRange(), Unexpanded, TemplateArgs,
Expand, RetainExpansion, NumExpansions))
@@ -3990,7 +3990,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);
}
@@ -4010,7 +4010,7 @@ Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl(
// Instantiate the slices of this pack and build a UsingPackDecl.
SmallVector<NamedDecl*, 8> 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;
@@ -4044,8 +4044,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();
@@ -4996,7 +4996,7 @@ TemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D,
LocalInstantiationScope *Scope = SemaRef.CurrentInstantiationScope;
- std::optional<unsigned> NumArgumentsInExpansion;
+ UnsignedOrNone NumArgumentsInExpansion = std::nullopt;
if (OldParam->isParameterPack())
NumArgumentsInExpansion =
SemaRef.getNumArgumentsInExpansion(OldParam->getType(),
@@ -5123,7 +5123,7 @@ bool Sema::addInstantiatedParametersToScope(
// Expand the parameter pack.
Scope.MakeInstantiatedLocalArgPack(PatternParam);
- std::optional<unsigned> NumArgumentsInExpansion =
+ UnsignedOrNone NumArgumentsInExpansion =
getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs);
if (NumArgumentsInExpansion) {
QualType PatternType =
@@ -5132,7 +5132,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());
@@ -6304,7 +6304,7 @@ Sema::InstantiateMemInitializers(CXXConstructorDecl *New,
collectUnexpandedParameterPacks(Init->getInit(), Unexpanded);
bool ShouldExpand = false;
bool RetainExpansion = false;
- std::optional<unsigned> NumExpansions;
+ UnsignedOrNone NumExpansions = std::nullopt;
if (CheckParameterPacksForExpansion(Init->getEllipsisLoc(),
BaseTL.getSourceRange(),
Unexpanded,
@@ -6319,7 +6319,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,
@@ -6692,18 +6692,17 @@ NamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
if (auto Found = CurrentInstantiationScope->findInstantiationOf(D)) {
if (Decl *FD = Found->dyn_cast<Decl *>()) {
if (auto *BD = dyn_cast<BindingDecl>(FD);
- BD && BD->isParameterPack() &&
- ArgumentPackSubstitutionIndex != -1) {
- return BD->getBindingPackDecls()[ArgumentPackSubstitutionIndex];
+ BD && BD->isParameterPack() && ArgPackSubstIndex) {
+ return BD->getBindingPackDecls()[*ArgPackSubstIndex];
}
return cast<NamedDecl>(FD);
}
- int PackIdx = ArgumentPackSubstitutionIndex;
- assert(PackIdx != -1 &&
+ assert(ArgPackSubstIndex &&
"found declaration pack but not pack expanding");
typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
- return cast<NamedDecl>((*cast<DeclArgumentPack *>(*Found))[PackIdx]);
+ return cast<NamedDecl>(
+ (*cast<DeclArgumentPack *>(*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<unsigned> 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<unsigned> 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<unsigned> NumExpansions) {
+ UnsignedOrNone NumExpansions) {
if (!Pattern)
return ExprError();
@@ -753,12 +753,12 @@ bool Sema::CheckParameterPacksForExpansion(
SourceLocation EllipsisLoc, SourceRange PatternRange,
ArrayRef<UnexpandedParameterPack> Unexpanded,
const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand,
- bool &RetainExpansion, std::optional<unsigned> &NumExpansions) {
+ bool &RetainExpansion, UnsignedOrNone &NumExpansions) {
ShouldExpand = true;
RetainExpansion = false;
std::pair<IdentifierInfo *, SourceLocation> FirstPack;
bool HaveFirstPack = false;
- std::optional<unsigned> NumPartialExpansions;
+ UnsignedOrNone NumPartialExpansions = std::nullopt;
SourceLocation PartiallySubstitutedPackLoc;
typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
@@ -942,10 +942,10 @@ bool Sema::CheckParameterPacksForExpansion(
return false;
}
-std::optional<unsigned> Sema::getNumArgumentsInExpansionFromUnexpanded(
+UnsignedOrNone Sema::getNumArgumentsInExpansionFromUnexpanded(
llvm::ArrayRef<UnexpandedParameterPack> Unexpanded,
const MultiLevelTemplateArgumentList &TemplateArgs) {
- std::optional<unsigned> 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<unsigned> Sema::getNumArgumentsInExpansionFromUnexpanded(
return Result;
}
-std::optional<unsigned> Sema::getNumArgumentsInExpansion(
+UnsignedOrNone Sema::getNumArgumentsInExpansion(
QualType T, const MultiLevelTemplateArgumentList &TemplateArgs) {
QualType Pattern = cast<PackExpansionType>(T)->getPattern();
SmallVector<UnexpandedParameterPack, 2> Unexpanded;
@@ -1252,7 +1252,7 @@ ExprResult Sema::BuildPackIndexingExpr(Expr *PackExpression,
TemplateArgumentLoc Sema::getTemplateArgumentPackExpansionPattern(
TemplateArgumentLoc OrigLoc, SourceLocation &Ellipsis,
- std::optional<unsigned> &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<unsigned> 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<unsigned> 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 2df961a48c7c3..411d338ce26bb 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -9680,7 +9680,7 @@ QualType Sema::BuildPackIndexingType(QualType Pattern, Expr *IndexExpr,
bool FullySubstituted,
ArrayRef<QualType> Expansions) {
- std::optional<int64_t> Index;
+ UnsignedOrNone Index = std::nullopt;
if (FullySubstituted && !IndexExpr->isValueDependent() &&
!IndexExpr->isTypeDependent()) {
llvm::APSInt Value(Context.getIntWidth(Context.getSizeType()));
@@ -9688,20 +9688,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<unsigned>(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 024d6b4225984..506e71845007b 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<bool>(SemaRef.ArgPackSubstIndex); }
/// Whether the transformation is forming an expression or statement that
/// replaces the original. In this case, we'll reuse mangling numbers from
@@ -293,7 +293,7 @@ class TreeTransform {
SourceRange PatternRange,
ArrayRef<UnexpandedParameterPack> Unexpanded,
bool &ShouldExpand, bool &RetainExpansion,
- std::optional<unsigned> &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<unsigned> 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<unsigned> 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<unsigned>
+ UnsignedOrNone
ComputeSizeOfPackExprWithoutSubstitution(ArrayRef<TemplateArgument> PackArgs);
/// Build a new expression to compute the length of a parameter pack.
ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc, NamedDecl *Pack,
SourceLocation PackLoc,
SourceLocation RParenLoc,
- std::optional<unsigned> Length,
+ UnsignedOrNone Length,
ArrayRef<TemplateArgument> 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<unsigned> 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<unsigned> 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<unsigned> NumExpansions) {
+ UnsignedOrNone NumExpansions) {
return getSema().BuildCXXFoldExpr(ULE, LParenLoc, LHS, Operator,
EllipsisLoc, RHS, RParenLoc,
NumExpansions);
@@ -4451,8 +4451,8 @@ bool TreeTransform<Derived>::TransformExprs(Expr *const *Inputs,
// be expanded.
bool Expand = true;
bool RetainExpansion = false;
- std::optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions();
- std::optional<unsigned> NumExpansions = OrigNumExpansions;
+ UnsignedOrNone OrigNumExpansions = Expansion->getNumExpansions();
+ UnsignedOrNone NumExpansions = OrigNumExpansions;
if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
Pattern->getSourceRange(),
Unexpanded,
@@ -4464,7 +4464,7 @@ bool TreeTransform<Derived>::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;
@@ -4488,7 +4488,7 @@ bool TreeTransform<Derived>::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;
@@ -5038,7 +5038,7 @@ bool TreeTransform<Derived>::TransformTemplateArguments(
// We have a pack expansion, for which we will be substituting into
// the pattern.
SourceLocation Ellipsis;
- std::optional<unsigned> OrigNumExpansions;
+ UnsignedOrNone OrigNumExpansions = std::nullopt;
TemplateArgumentLoc Pattern
= getSema().getTemplateArgumentPackExpansionPattern(
In, Ellipsis, OrigNumExpansions);
@@ -5051,7 +5051,7 @@ bool TreeTransform<Derived>::TransformTemplateArguments(
// be expanded.
bool Expand = true;
bool RetainExpansion = false;
- std::optional<unsigned> NumExpansions = OrigNumExpansions;
+ UnsignedOrNone NumExpansions = OrigNumExpansions;
if (getDerived().TryExpandParameterPacks(Ellipsis,
Pattern.getSourceRange(),
Unexpanded,
@@ -5065,7 +5065,7 @@ bool TreeTransform<Derived>::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;
@@ -5081,7 +5081,7 @@ bool TreeTransform<Derived>::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;
@@ -6079,8 +6079,8 @@ QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
template <typename Derived>
ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam(
- ParmVarDecl *OldParm, int indexAdjustment,
- std::optional<unsigned> NumExpansions, bool ExpectParameterPack) {
+ ParmVarDecl *OldParm, int indexAdjustment, UnsignedOrNone NumExpansions,
+ bool ExpectParameterPack) {
TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
TypeSourceInfo *NewDI = nullptr;
@@ -6151,7 +6151,7 @@ bool TreeTransform<Derived>::TransformFunctionTypeParams(
if (ParmVarDecl *OldParm = Params[i]) {
assert(OldParm->getFunctionScopeIndex() == i);
- std::optional<unsigned> NumExpansions;
+ UnsignedOrNone NumExpansions = std::nullopt;
ParmVarDecl *NewParm = nullptr;
if (OldParm->isParameterPack()) {
// We have a function parameter pack that may need to be expanded.
@@ -6166,7 +6166,7 @@ bool TreeTransform<Derived>::TransformFunctionTypeParams(
// Determine whether we should expand the parameter packs.
bool ShouldExpand = false;
bool RetainExpansion = false;
- std::optional<unsigned> OrigNumExpansions;
+ UnsignedOrNone OrigNumExpansions = std::nullopt;
if (Unexpanded.size() > 0) {
OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions();
NumExpansions = OrigNumExpansions;
@@ -6192,7 +6192,7 @@ bool TreeTransform<Derived>::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++,
@@ -6239,7 +6239,7 @@ bool TreeTransform<Derived>::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,
@@ -6269,7 +6269,7 @@ bool TreeTransform<Derived>::TransformFunctionTypeParams(
assert(ParamTypes);
QualType OldType = ParamTypes[i];
bool IsPackExpansion = false;
- std::optional<unsigned> NumExpansions;
+ UnsignedOrNone NumExpansions = std::nullopt;
QualType NewType;
if (const PackExpansionType *Expansion
= dyn_cast<PackExpansionType>(OldType)) {
@@ -6293,7 +6293,7 @@ bool TreeTransform<Derived>::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;
@@ -6336,7 +6336,7 @@ bool TreeTransform<Derived>::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);
@@ -6578,7 +6578,7 @@ bool TreeTransform<Derived>::TransformExceptionSpec(
// be expanded.
bool Expand = false;
bool RetainExpansion = false;
- std::optional<unsigned> 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(
@@ -6590,7 +6590,7 @@ bool TreeTransform<Derived>::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;
@@ -6603,7 +6603,7 @@ bool TreeTransform<Derived>::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))
@@ -6856,14 +6856,13 @@ TreeTransform<Derived>::TransformPackIndexingType(TypeLocBuilder &TLB,
// be expanded.
bool ShouldExpand = true;
bool RetainExpansion = false;
- std::optional<unsigned> OrigNumExpansions;
- std::optional<unsigned> 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 =
@@ -6887,7 +6886,7 @@ TreeTransform<Derived>::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();
@@ -6909,7 +6908,7 @@ TreeTransform<Derived>::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(
@@ -7920,7 +7919,7 @@ TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc();
bool Expand = false;
bool RetainExpansion = false;
- std::optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
+ UnsignedOrNone NumExpansions = PackExpansion->getNumExpansions();
if (getDerived().TryExpandParameterPacks(
PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(),
Unexpanded, Expand, RetainExpansion, NumExpansions))
@@ -7930,7 +7929,7 @@ TreeTransform<Derived>::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());
@@ -7951,7 +7950,7 @@ TreeTransform<Derived>::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());
@@ -14827,9 +14826,9 @@ TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) {
// be expanded.
bool Expand = true;
bool RetainExpansion = false;
- std::optional<unsigned> OrigNumExpansions =
+ UnsignedOrNone OrigNumExpansions =
ExpansionTL.getTypePtr()->getNumExpansions();
- std::optional<unsigned> NumExpansions = OrigNumExpansions;
+ UnsignedOrNone NumExpansions = OrigNumExpansions;
if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
PatternTL.getSourceRange(),
Unexpanded,
@@ -14841,7 +14840,7 @@ TreeTransform<Derived>::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());
@@ -14867,7 +14866,7 @@ TreeTransform<Derived>::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);
@@ -15371,7 +15370,7 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
auto *OldVD = cast<VarDecl>(C->getCapturedVar());
auto SubstInitCapture = [&](SourceLocation EllipsisLoc,
- std::optional<unsigned> NumExpansions) {
+ UnsignedOrNone NumExpansions) {
ExprResult NewExprInitResult = getDerived().TransformInitializer(
OldVD->getInit(), OldVD->getInitStyle() == VarDecl::CallInit);
@@ -15404,9 +15403,9 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
// be expanded.
bool Expand = true;
bool RetainExpansion = false;
- std::optional<unsigned> OrigNumExpansions =
+ UnsignedOrNone OrigNumExpansions =
ExpansionTL.getTypePtr()->getNumExpansions();
- std::optional<unsigned> NumExpansions = OrigNumExpansions;
+ UnsignedOrNone NumExpansions = OrigNumExpansions;
if (getDerived().TryExpandParameterPacks(
ExpansionTL.getEllipsisLoc(),
OldVD->getInit()->getSourceRange(), Unexpanded, Expand,
@@ -15416,7 +15415,7 @@ TreeTransform<Derived>::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 {
@@ -15569,7 +15568,7 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation());
bool ShouldExpand = false;
bool RetainExpansion = false;
- std::optional<unsigned> NumExpansions;
+ UnsignedOrNone NumExpansions = std::nullopt;
if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(),
C->getLocation(),
Unexpanded,
@@ -15585,7 +15584,7 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
// expansion of the pattern. Do so.
auto *Pack = cast<ValueDecl>(C->getCapturedVar());
for (unsigned I = 0; I != *NumExpansions; ++I) {
- Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
+ Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I);
ValueDecl *CapturedVar = cast_if_present<ValueDecl>(
getDerived().TransformDecl(C->getLocation(), Pack));
if (!CapturedVar) {
@@ -15654,8 +15653,8 @@ TreeTransform<Derived>::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(),
@@ -16036,10 +16035,9 @@ TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) {
}
template <typename Derived>
-std::optional<unsigned>
-TreeTransform<Derived>::ComputeSizeOfPackExprWithoutSubstitution(
+UnsignedOrNone TreeTransform<Derived>::ComputeSizeOfPackExprWithoutSubstitution(
ArrayRef<TemplateArgument> PackArgs) {
- std::optional<unsigned> Result = 0;
+ UnsignedOrNone Result = 0u;
for (const TemplateArgument &Arg : PackArgs) {
if (!Arg.isPackExpansion()) {
Result = *Result + 1;
@@ -16051,20 +16049,20 @@ TreeTransform<Derived>::ComputeSizeOfPackExprWithoutSubstitution(
// Find the pattern of the pack expansion.
SourceLocation Ellipsis;
- std::optional<unsigned> 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<unsigned> NumExpansions =
+ UnsignedOrNone NumExpansions =
getSema().getFullyPackExpandedSize(OutPattern.getArgument());
if (!NumExpansions) {
// No: we must be in an alias template expansion, and we're going to
@@ -16099,7 +16097,7 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) {
UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc());
bool ShouldExpand = false;
bool RetainExpansion = false;
- std::optional<unsigned> NumExpansions;
+ UnsignedOrNone NumExpansions = std::nullopt;
if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(),
Unexpanded,
ShouldExpand, RetainExpansion,
@@ -16143,7 +16141,7 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) {
}
// Try to compute the result without performing a partial substitution.
- std::optional<unsigned> Result =
+ UnsignedOrNone Result =
getDerived().ComputeSizeOfPackExprWithoutSubstitution(PackArgs);
// Common case: we could determine the number of expansions without
@@ -16180,9 +16178,10 @@ TreeTransform<Derived>::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<unsigned>(Args.size()),
+ /*PartialArgs=*/std::nullopt);
}
template <typename Derived>
@@ -16214,14 +16213,14 @@ TreeTransform<Derived>::TransformPackIndexingExpr(PackIndexingExpr *E) {
// be expanded.
bool ShouldExpand = true;
bool RetainExpansion = false;
- std::optional<unsigned> OrigNumExpansions;
- std::optional<unsigned> 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();
@@ -16230,7 +16229,7 @@ TreeTransform<Derived>::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;
@@ -16322,8 +16321,8 @@ TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) {
// be expanded.
bool Expand = true;
bool RetainExpansion = false;
- std::optional<unsigned> OrigNumExpansions = E->getNumExpansions(),
- NumExpansions = OrigNumExpansions;
+ UnsignedOrNone OrigNumExpansions = E->getNumExpansions(),
+ NumExpansions = OrigNumExpansions;
if (getDerived().TryExpandParameterPacks(E->getEllipsisLoc(),
Pattern->getSourceRange(),
Unexpanded,
@@ -16334,7 +16333,7 @@ TreeTransform<Derived>::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();
@@ -16358,7 +16357,7 @@ TreeTransform<Derived>::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
@@ -16391,7 +16390,7 @@ TreeTransform<Derived>::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())
@@ -16538,8 +16537,8 @@ TreeTransform<Derived>::TransformObjCDictionaryLiteral(
// and should be expanded.
bool Expand = true;
bool RetainExpansion = false;
- std::optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions;
- std::optional<unsigned> NumExpansions = OrigNumExpansions;
+ UnsignedOrNone OrigNumExpansions = OrigElement.NumExpansions;
+ UnsignedOrNone NumExpansions = OrigNumExpansions;
SourceRange PatternRange(OrigElement.Key->getBeginLoc(),
OrigElement.Value->getEndLoc());
if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc,
@@ -16551,7 +16550,7 @@ TreeTransform<Derived>::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();
@@ -16580,7 +16579,7 @@ TreeTransform<Derived>::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 58a57d6c54523..9b52866ad6135 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<unsigned> ModuleHash = getPrimaryModuleHash(Key.second);
+ UnsignedOrNone ModuleHash = getPrimaryModuleHash(Key.second);
if (!ModuleHash)
return {Name, 0};
@@ -12880,7 +12880,7 @@ static unsigned getStableHashForModuleName(StringRef PrimaryModuleName) {
return ID.computeStableHash();
}
-std::optional<unsigned> 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 989a107fc3488..3899d71825195 100644
--- a/clang/lib/Serialization/ASTReaderDecl.cpp
+++ b/clang/lib/Serialization/ASTReaderDecl.cpp
@@ -901,8 +901,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();
@@ -2707,12 +2708,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 8dceca6ff3dbf..f2b3fd9911695 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<unsigned> 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<Expr *>(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 037eb13b1dc52..8bcf7da3179d6 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<FieldDecl>(Import(FromField, Lang_CXX11));
EXPECT_TRUE(ToField);
- std::optional<unsigned> 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<unsigned> PackIndex) {
+ UnsignedOrNone PackIndex) {
const auto *Subst = selectFirst<SubstTemplateTypeParmType>(
"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());
More information about the llvm-branch-commits
mailing list