Struct rustc_hir::hir::Pat

pub struct Pat<'hir> {
    pub hir_id: HirId,
    pub kind: PatKind<'hir>,
    pub span: Span,
    pub default_binding_modes: bool,
}

Fields

hir_id: HirId

kind: PatKind<'hir>

span: Span

default_binding_modes: bool

Whether to use default binding modes. At present, this is false only for destructuring assignment.

Implementations

impl<'hir> Pat<'hir>

fn walk_short_(&self, it: &mut impl FnMut(&Pat<'hir>) -> bool) -> bool

pub fn walk_short(&self, it: impl FnMut(&Pat<'hir>) -> bool) -> bool

Walk the pattern in left-to-right order, short circuiting (with .all(..)) if false is returned.

Note that when visiting e.g. Tuple(ps), if visiting ps[0] returns false, then ps[1] will not be visited.

fn walk_(&self, it: &mut impl FnMut(&Pat<'hir>) -> bool)

pub fn walk(&self, it: impl FnMut(&Pat<'hir>) -> bool)

Walk the pattern in left-to-right order.

If it(pat) returns false, the children are not visited.

pub fn walk_always(&self, it: impl FnMut(&Pat<'_>))

Walk the pattern in left-to-right order.

If you always want to recurse, prefer this method over walk.

pub fn is_never_pattern(&self) -> bool

Whether this a never pattern.

impl Pat<'_>

pub fn each_binding(&self, f: impl FnMut(BindingMode, HirId, Span, Ident))

Call f on every “binding” in a pattern, e.g., on a in match foo() { Some(a) => (), None => () }

pub fn each_binding_or_first( &self, f: &mut impl FnMut(BindingMode, HirId, Span, Ident), )

Call f on every “binding” in a pattern, e.g., on a in match foo() { Some(a) => (), None => () }.

When encountering an or-pattern p_0 | ... | p_n only the first non-never pattern will be visited. If they’re all never patterns we visit nothing, which is ok since a never pattern cannot have bindings.

pub fn simple_ident(&self) -> Option<Ident>

pub fn necessary_variants(&self) -> Vec<DefId>

Returns variants that are necessary to exist for the pattern to match.

pub fn contains_explicit_ref_binding(&self) -> Option<Mutability>

Checks if the pattern contains any ref or ref mut bindings, and if yes whether it contains mutable or just immutables ones.

Trait Implementations

impl<'hir> Clone for Pat<'hir>

fn clone(&self) -> Pat<'hir>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'hir> Debug for Pat<'hir>

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

Formats the value using the given formatter.

impl<'hir, __CTX> HashStable<__CTX> for Pat<'hir>

where __CTX: HashStableContext,

fn hash_stable(&self, __hcx: &mut __CTX, __hasher: &mut StableHasher)

impl<'hir> Copy for Pat<'hir>

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