pub(super) enum Constructor<'tcx> {
    Single,
    Variant(VariantIdx),
    IntRange(IntRange),
    F32Range(IeeeFloat<SingleS>, IeeeFloat<SingleS>, RangeEnd),
    F64Range(IeeeFloat<DoubleS>, IeeeFloat<DoubleS>, RangeEnd),
    Str(Const<'tcx>),
    Slice(Slice),
    Opaque,
    NonExhaustive,
    Missing {
        nonexhaustive_enum_missing_real_variants: bool,
    },
    Wildcard,
    Or,
}
Expand description

A value can be decomposed into a constructor applied to some fields. This struct represents the constructor. See also Fields.

pat_constructor retrieves the constructor corresponding to a pattern. specialize_constructor returns the list of fields corresponding to a pattern, given a constructor. Constructor::apply reconstructs the pattern from a pair of Constructor and Fields.

Variants§

§

Single

The constructor for patterns that have a single constructor, like tuples, struct patterns and fixed-length arrays.

§

Variant(VariantIdx)

Enum variants.

§

IntRange(IntRange)

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

§

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

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

§

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

§

Str(Const<'tcx>)

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

§

Slice(Slice)

Array and slice patterns.

§

Opaque

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.

§

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.

§

Missing

Fields

§nonexhaustive_enum_missing_real_variants: bool

Stands for constructors that are not seen in the matrix, as explained in the documentation for SplitWildcard. The carried bool is used for the non_exhaustive_omitted_patterns lint.

§

Wildcard

Wildcard pattern.

§

Or

Or-pattern.

Implementations§

source§

impl<'tcx> Constructor<'tcx>

source

pub(super) fn is_wildcard(&self) -> bool

source

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

source

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

source

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

source

pub(super) fn is_unstable_variant(&self, pcx: &PatCtxt<'_, '_, 'tcx>) -> bool

Checks if the Constructor is a variant and TyCtxt::eval_stability returns EvalResult::Deny { .. }.

This means that the variant has a stdlib unstable feature marking it.

source

pub(super) fn is_doc_hidden_variant(&self, pcx: &PatCtxt<'_, '_, 'tcx>) -> bool

Checks if the Constructor is a Constructor::Variant with a #[doc(hidden)] attribute from a type not local to the current crate.

source

fn variant_index_for_adt(&self, adt: AdtDef<'tcx>) -> VariantIdx

source

pub(super) fn arity(&self, pcx: &PatCtxt<'_, '_, 'tcx>) -> usize

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

source

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

Some constructors (namely Wildcard, IntRange and Slice) actually stand for a set of actual constructors (like variants, integers or fixed-sized slices). When specializing for these constructors, we want to be specialising for the actual underlying constructors. Naively, we would simply return the list of constructors they correspond to. We instead are more clever: if there are constructors that we know will behave the same wrt the current matrix, we keep them grouped. For example, all slices of a sufficiently large length will either be all useful or all non-useful with a given matrix.

See the branches for details on how the splitting is done.

This function may discard some irrelevant constructors if this preserves behavior and diagnostics. Eg. for the _ case, we ignore the constructors already present in the matrix, unless all of them are.

source

pub(super) fn is_covered_by<'p>( &self, pcx: &PatCtxt<'_, 'p, 'tcx>, other: &Self ) -> bool

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.

source

fn is_covered_by_any<'p>( &self, pcx: &PatCtxt<'_, 'p, 'tcx>, used_ctors: &[Constructor<'tcx>] ) -> bool

Faster version of is_covered_by when applied to many constructors. used_ctors is assumed to be built from matrix.head_ctors() with wildcards and opaques filtered out, and self is assumed to have been split from a wildcard.

Trait Implementations§

source§

impl<'tcx> Clone for Constructor<'tcx>

source§

fn clone(&self) -> Constructor<'tcx>

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<'tcx> Debug for Constructor<'tcx>

source§

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

Formats the value using the given formatter. Read more
source§

impl<'tcx> PartialEq<Constructor<'tcx>> for Constructor<'tcx>

source§

fn eq(&self, other: &Constructor<'tcx>) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'tcx> StructuralPartialEq for Constructor<'tcx>

Auto Trait Implementations§

§

impl<'tcx> !RefUnwindSafe for Constructor<'tcx>

§

impl<'tcx> Send for Constructor<'tcx>

§

impl<'tcx> Sync for Constructor<'tcx>

§

impl<'tcx> Unpin for Constructor<'tcx>

§

impl<'tcx> !UnwindSafe for Constructor<'tcx>

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

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:

  • Single: 0 bytes
  • Variant: 7 bytes
  • IntRange: 63 bytes
  • F32Range: 79 bytes
  • F64Range: 79 bytes
  • Str: 47 bytes
  • Slice: 47 bytes
  • Opaque: 0 bytes
  • NonExhaustive: 0 bytes
  • Missing: 1 byte
  • Wildcard: 0 bytes
  • Or: 0 bytes