Type Alias Constructor

pub type Constructor<'p, 'tcx> = Constructor<RustcPatCtxt<'p, 'tcx>>;

Aliased Type

enum Constructor<'p, 'tcx> {
    Struct,
    Variant(VariantIdx),
    Ref,
    Slice(Slice),
    UnionField,
    Bool(bool),
    IntRange(IntRange),
    F16Range(IeeeFloat<HalfS>, IeeeFloat<HalfS>, RangeEnd),
    F32Range(IeeeFloat<SingleS>, IeeeFloat<SingleS>, RangeEnd),
    F64Range(IeeeFloat<DoubleS>, IeeeFloat<DoubleS>, RangeEnd),
    F128Range(IeeeFloat<QuadS>, IeeeFloat<QuadS>, RangeEnd),
    Str(Const<'tcx>),
    Opaque(OpaqueId),
    Or,
    Wildcard,
    Never,
    NonExhaustive,
    Hidden,
    Missing,
    PrivateUninhabited,
}

Variants

Struct

Tuples and structs.

Variant(VariantIdx)

Enum variants.

Ref

References

Slice(Slice)

Array and slice patterns.

UnionField

Union field accesses.

Bool(bool)

Booleans

IntRange(IntRange)

Ranges of integer literal values (2, 2..=5 or 2..5).

F16Range(IeeeFloat<HalfS>, IeeeFloat<HalfS>, RangeEnd)

Ranges of floating-point literal values (2.0..=5.2).

F32Range(IeeeFloat<SingleS>, IeeeFloat<SingleS>, RangeEnd)

F64Range(IeeeFloat<DoubleS>, IeeeFloat<DoubleS>, RangeEnd)

F128Range(IeeeFloat<QuadS>, IeeeFloat<QuadS>, RangeEnd)

Str(Const<'tcx>)

String literals. Strings are not quite the same as &[u8] so we treat them separately.

Opaque(OpaqueId)

Constants that must not be matched structurally. They are treated as black boxes for the purposes of exhaustiveness: we must not inspect them, and they don’t count towards making a match exhaustive. Carries an id that must be unique within a match. We need this to ensure the invariants of SplitConstructorSet.

Or

Or-pattern.

Wildcard

Wildcard pattern.

Never

Never pattern. Only used in WitnessPat. An actual never pattern should be lowered as Wildcard.

NonExhaustive

Fake extra constructor for enums that aren’t allowed to be matched exhaustively. Also used for those types for which we cannot list constructors explicitly, like f64 and str. Only used in WitnessPat.

Hidden

Fake extra constructor for variants that should not be mentioned in diagnostics. We use this for variants behind an unstable gate as well as #[doc(hidden)] ones. Only used in WitnessPat.

Missing

Fake extra constructor for constructors that are not seen in the matrix, as explained at the top of the file. Only used for specialization.

PrivateUninhabited

Fake extra constructor that indicates and empty field that is private. When we encounter one we skip the column entirely so we don’t observe its emptiness. Only used for specialization.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 80 bytes

Size for each variant:

• Struct: 0 bytes
• Variant: 7 bytes
• Ref: 0 bytes
• Slice: 47 bytes
• UnionField: 0 bytes
• Bool: 1 byte
• IntRange: 79 bytes
• F16Range: 79 bytes
• F32Range: 79 bytes
• F64Range: 79 bytes
• F128Range: 79 bytes
• Str: 47 bytes
• Opaque: 7 bytes
• Or: 0 bytes
• Wildcard: 0 bytes
• Never: 0 bytes
• NonExhaustive: 0 bytes
• Hidden: 0 bytes
• Missing: 0 bytes
• PrivateUninhabited: 0 bytes

Implementations

impl<Cx: PatCx> Constructor<Cx>

pub(crate) fn is_non_exhaustive(&self) -> bool

pub(crate) fn as_variant(&self) -> Option<Cx::VariantIdx>

fn as_bool(&self) -> Option<bool>

pub(crate) fn as_int_range(&self) -> Option<&IntRange>

fn as_slice(&self) -> Option<Slice>

pub(crate) fn arity(&self, cx: &Cx, ty: &Cx::Ty) -> usize

The number of fields for this constructor. This must be kept in sync with Fields::wildcards.

pub(crate) fn is_covered_by( &self, cx: &Cx, other: &Self, ) -> Result<bool, Cx::Error>

Returns whether self is covered by other, i.e. whether self is a subset of other. For the simple cases, this is simply checking for equality. For the “grouped” constructors, this checks for inclusion.

pub(crate) fn fmt_fields( &self, f: &mut Formatter<'_>, ty: &Cx::Ty, fields: impl Iterator<Item = impl Debug>, ) -> Result

Trait Implementations

impl<Cx: PatCx> Clone for Constructor<Cx>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Cx: Debug + PatCx> Debug for Constructor<Cx>

where Cx::VariantIdx: Debug, Cx::StrLit: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.