Struct rustc_pattern_analysis::pat::DeconstructedPat

pub struct DeconstructedPat<Cx: PatCx> {
    ctor: Constructor<Cx>,
    fields: Vec<IndexedPat<Cx>>,
    arity: usize,
    ty: Cx::Ty,
    data: Cx::PatData,
    pub(crate) uid: PatId,
}

Values and patterns can be represented as a constructor applied to some fields. This represents a pattern in this form. A DeconstructedPat will almost always come from user input; the only exception are some Wildcards introduced during pattern lowering.

Fields

ctor: Constructor<Cx>

fields: Vec<IndexedPat<Cx>>

arity: usize

The number of fields in this pattern. E.g. if the pattern is SomeStruct { field12: true, .. } this would be the total number of fields of the struct. This is also the same as self.ctor.arity(self.ty).

ty: Cx::Ty

data: Cx::PatData

Extra data to store in a pattern.

uid: PatId

Globally-unique id used to track usefulness at the level of subpatterns.

Implementations

impl<Cx: PatCx> DeconstructedPat<Cx>

pub fn new( ctor: Constructor<Cx>, fields: Vec<IndexedPat<Cx>>, arity: usize, ty: Cx::Ty, data: Cx::PatData, ) -> Self

pub fn at_index(self, idx: usize) -> IndexedPat<Cx>

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

pub fn ctor(&self) -> &Constructor<Cx>

pub fn ty(&self) -> &Cx::Ty

pub fn data(&self) -> &Cx::PatData

Returns the extra data stored in a pattern.

pub fn arity(&self) -> usize

pub fn iter_fields<'a>(&'a self) -> impl Iterator<Item = &'a IndexedPat<Cx>>

pub(crate) fn specialize<'a>( &'a self, other_ctor: &Constructor<Cx>, other_ctor_arity: usize, ) -> SmallVec<[PatOrWild<'a, Cx>; 2]>

Specialize this pattern with a constructor. other_ctor can be different from self.ctor, but must be covered by it.

pub fn walk<'a>(&'a self, it: &mut impl FnMut(&'a Self) -> bool)

Walk top-down and call it in each place where a pattern occurs starting with the root pattern walk is called on. If it returns false then we will descend no further but siblings will be processed.

Trait Implementations

impl<Cx: PatCx> Debug for DeconstructedPat<Cx>

This is best effort and not good enough for a Display impl.

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

Formats the value using the given formatter.

impl<Cx: PatCx> Hash for DeconstructedPat<Cx>

Delegate to uid.

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Cx: PatCx> PartialEq for DeconstructedPat<Cx>

Delegate to uid.

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Cx: PatCx> Eq for DeconstructedPat<Cx>

Delegate to uid.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.