Enum rustc_mir_build::thir::pattern::_match::Constructor

enum Constructor<'tcx> {
    Single,
    Variant(DefId),
    ConstantValue(&'tcx Const<'tcx>),
    IntRange(IntRange<'tcx>),
    FloatRange(&'tcx Const<'tcx>, &'tcx Const<'tcx>, RangeEnd),
    Slice(Slice),
    NonExhaustive,
}

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_one_pattern 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(DefId)

Enum variants.

ConstantValue(&'tcx Const<'tcx>)

Literal values.

IntRange(IntRange<'tcx>)

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

FloatRange(&'tcx Const<'tcx>, &'tcx Const<'tcx>, RangeEnd)

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

Slice(Slice)

Array and slice patterns.

NonExhaustive

Fake extra constructor for enums that aren't allowed to be matched exhaustively.

Implementations

impl<'tcx> Constructor<'tcx>

fn is_slice(&self) -> bool

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

fn subtract_ctors(
    &self,
    other_ctors: &Vec<Constructor<'tcx>>
) -> Vec<Constructor<'tcx>>

fn apply<'p>(
    &self,
    cx: &MatchCheckCtxt<'p, 'tcx>,
    ty: Ty<'tcx>,
    fields: Fields<'p, 'tcx>
) -> Pat<'tcx>

Apply a constructor to a list of patterns, yielding a new pattern. pats must have as many elements as this constructor's arity.

This is roughly the inverse of specialize_one_pattern.

Examples: self: Constructor::Single ty: (u32, u32, u32) pats: [10, 20, _] returns (10, 20, _)

self: Constructor::Variant(Option::Some) ty: Option<bool> pats: [false] returns Some(false)

fn apply_wildcards<'a>(
    &self,
    cx: &MatchCheckCtxt<'a, 'tcx>,
    ty: Ty<'tcx>
) -> Pat<'tcx>

Like apply, but where all the subpatterns are wildcards _.

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

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

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

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

This method tests for !=.

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