Enum rustc_mir_build::thir::pattern::deconstruct_pat::ConstructorSet

pub(super) enum ConstructorSet {
    Single,
    Variants {
        visible_variants: Vec<VariantIdx>,
        hidden_variants: Vec<VariantIdx>,
        non_exhaustive: bool,
    },
    Bool,
    Integers {
        range_1: IntRange,
        range_2: Option<IntRange>,
    },
    Slice(Option<usize>),
    SliceOfEmpty,
    Unlistable,
    Uninhabited,
}

Describes the set of all constructors for a type.

Variants

Single

The type has a single constructor, e.g. &T or a struct.

Variants

Fields

visible_variants: Vec<VariantIdx>

hidden_variants: Vec<VariantIdx>

non_exhaustive: bool

This type has the following list of constructors. Some variants are hidden, which means they won’t be mentioned in diagnostics unless the user mentioned them first. We use this for variants behind an unstable gate as well as #[doc(hidden)] ones.

Bool

Booleans.

Integers

Fields

range_1: IntRange

range_2: Option<IntRange>

The type is spanned by integer values. The range or ranges give the set of allowed values. The second range is only useful for char.

Slice(Option<usize>)

The type is matched by slices. The usize is the compile-time length of the array, if known.

SliceOfEmpty

The type is matched by slices whose elements are uninhabited.

Unlistable

The constructors cannot be listed, and the type cannot be matched exhaustively. E.g. str, floats.

Uninhabited

The type has no inhabitants.

Implementations

impl ConstructorSet

pub(super) fn for_ty<'p, 'tcx>( cx: &MatchCheckCtxt<'p, 'tcx>, ty: Ty<'tcx> ) -> Self

pub(super) fn split<'a, 'tcx>( &self, pcx: &PatCtxt<'_, '_, 'tcx>, ctors: impl Iterator<Item = &'a Constructor<'tcx>> + Clone ) -> SplitConstructorSet<'tcx>where 'tcx: 'a,

This is the core logical operation of exhaustiveness checking. This analyzes a column a constructors to 1/ determine which constructors of the type (if any) are missing; 2/ split constructors to handle non-trivial intersections e.g. on ranges or slices.

pub(super) fn compute_missing<'a, 'tcx>( &self, pcx: &PatCtxt<'_, '_, 'tcx>, ctors: impl Iterator<Item = &'a Constructor<'tcx>> + Clone ) -> Vec<Constructor<'tcx>>where 'tcx: 'a,

Compute the set of constructors missing from this column. This is only used for reporting to the user.

Trait Implementations

impl Debug for ConstructorSet

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

Formats the value using the given formatter.

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: 96 bytes

Size for each variant:

• Single: 0 bytes
• Variants: 64 bytes
• Bool: 0 bytes
• Integers: 96 bytes
• Slice: 24 bytes
• SliceOfEmpty: 0 bytes
• Unlistable: 0 bytes
• Uninhabited: 0 bytes