Enum rustc_mir_build::thir::pattern::_match::Fields

pub(in thir::pattern::_match) enum Fields<'p, 'tcx> {
    Slice(&'p [Pat<'tcx>]),
    Vec(SmallVec<[&'p Pat<'tcx>; 2]>),
    Filtered {
        fields: SmallVec<[FilteredField<'p, 'tcx>; 2]>,
        kept_count: usize,
    },
}

A value can be decomposed into a constructor applied to some fields. This struct represents those fields, generalized to allow patterns in each field. See also Constructor.

If a private or non_exhaustive field is uninhabited, the code mustn't observe that it is uninhabited. For that, we filter these fields out of the matrix. This is subtle because we still need to have those fields back when going to/from a Pat. Most of this is handled automatically in Fields, but when constructing or deconstructing Fields you need to be careful. As a rule, when going to/from the matrix, use the filtered field list; when going to/from Pat, use the full field list. This filtering is uncommon in practice, because uninhabited fields are rarely used, so we avoid it when possible to preserve performance.

Variants

Slice(&'p [Pat<'tcx>])

Lists of patterns that don't contain any filtered fields. Slice and Vec behave the same; the difference is only to avoid allocating and triple-dereferences when possible. Frankly this is premature optimization, I (Nadrieril) have not measured if it really made a difference.

Vec(SmallVec<[&'p Pat<'tcx>; 2]>)

Filtered

Patterns where some of the fields need to be hidden. kept_count caches the number of non-hidden fields.

Fields of Filtered

fields: SmallVec<[FilteredField<'p, 'tcx>; 2]>kept_count: usize

Implementations

impl<'p, 'tcx> Fields<'p, 'tcx>

pub(in thir::pattern::_match) fn empty(
) -> Self

pub(in thir::pattern::_match) fn from_single_pattern(
    pat: &'p Pat<'tcx>
) -> Self

Construct a new Fields from the given pattern. Must not be used if the pattern is a field of a struct/tuple/variant.

pub(in thir::pattern::_match) fn wildcards_from_tys(
    cx: &MatchCheckCtxt<'p, 'tcx>,
    tys: impl IntoIterator<Item = Ty<'tcx>>
) -> Self

Convenience; internal use.

pub(in thir::pattern::_match) fn wildcards(
    pcx: PatCtxt<'_, 'p, 'tcx>,
    constructor: &Constructor<'tcx>
) -> Self

Creates a new list of wildcard fields for a given constructor.

pub(in thir::pattern::_match) fn len(
    &self
) -> usize

Returns the number of patterns from the viewpoint of match-checking, i.e. excluding hidden fields. This is what we want in most cases in this file, the only exception being conversion to/from Pat.

pub(in thir::pattern::_match) fn all_patterns(
    self
) -> impl Iterator<Item = Pat<'tcx>>

Returns the complete list of patterns, including hidden fields.

pub(in thir::pattern::_match) fn replace_with_fieldpats(
    &self,
    new_pats: impl IntoIterator<Item = &'p FieldPat<'tcx>>
) -> Self

Overrides some of the fields with the provided patterns. Exactly like replace_fields_indexed, except that it takes FieldPats as input.

pub(in thir::pattern::_match) fn replace_fields_indexed(
    &self,
    new_pats: impl IntoIterator<Item = (usize, &'p Pat<'tcx>)>
) -> Self

Overrides some of the fields with the provided patterns. This is used when a pattern defines some fields but not all, for example Foo { field1: Some(_), .. }: here we start with a Fields that is just one wildcard per field of the Foo struct, and override the entry corresponding to field1 with the pattern Some(_). This is also used for slice patterns for the same reason.

pub(in thir::pattern::_match) fn replace_fields(
    &self,
    cx: &MatchCheckCtxt<'p, 'tcx>,
    pats: impl IntoIterator<Item = Pat<'tcx>>
) -> Self

Replaces contained fields with the given filtered list of patterns, e.g. taken from the matrix. There must be len() patterns in pats.

pub(in thir::pattern::_match) fn replace_with_pattern_arguments(
    &self,
    pat: &'p Pat<'tcx>
) -> Self

Replaces contained fields with the arguments of the given pattern. Only use on a pattern that is compatible with the constructor used to build self. This is meant to be used on the result of Fields::wildcards(). The idea is that wildcards constructs a list of fields where all entries are wildcards, and the pattern provided to this function fills some of the fields with non-wildcards. In the following example Fields::wildcards would return [_, _, _, _]. If we call replace_with_pattern_arguments on it with the pattern, the result will be [Some(0), _, _, _].

let x: [Option<u8>; 4] = foo();
match x {
    [Some(0), ..] => {}
}

This is guaranteed to preserve the number of patterns in self.

pub(in thir::pattern::_match) fn push_on_patstack(
    self,
    stack: &[&'p Pat<'tcx>]
) -> PatStack<'p, 'tcx>

Trait Implementations

impl<'p, 'tcx> Clone for Fields<'p, 'tcx>

pub fn clone(&self) -> Fields<'p, 'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'p, 'tcx> Debug for Fields<'p, 'tcx>

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

Formats the value using the given formatter.