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

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.

impl Pat<'_>

pub fn each_binding(&self, f: impl FnMut(BindingAnnotation, 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(BindingAnnotation, 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 p_0 will be visited.

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.

pub fn for_loop_some(&self) -> Option<&Self>

If the pattern is Some(<pat>) from a desugared for loop, returns the inner pattern

Trait Implementations

impl<'tcx> ArenaAllocatable<'tcx, IsNotCopy> for Pat<'tcx>

fn allocate_on<'a>(self, arena: &'a Arena<'tcx>) -> &'a mut Self

fn allocate_from_iter<'a>(
    arena: &'a Arena<'tcx>,
    iter: impl IntoIterator<Item = Self>
) -> &'a mut [Self]

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)

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