Struct rustc_mir_build::thir::pattern::deconstruct_pat::DeconstructedPat

pub(crate) struct DeconstructedPat<'p, 'tcx> {
    ctor: Constructor<'tcx>,
    fields: Fields<'p, 'tcx>,
    ty: Ty<'tcx>,
    span: Span,
    reachable: Cell<bool>,
}

Values and patterns can be represented as a constructor applied to some fields. This represents a pattern in this form. This also keeps track of whether the pattern has been found reachable during analysis. For this reason we should be careful not to clone patterns for which we care about that. Use clone_and_forget_reachability if you’re sure.

Fields

ctor: Constructor<'tcx>

fields: Fields<'p, 'tcx>

ty: Ty<'tcx>

span: Span

reachable: Cell<bool>

Implementations

impl<'p, 'tcx> DeconstructedPat<'p, 'tcx>

pub(super) fn wildcard(ty: Ty<'tcx>) -> Self

pub(super) fn new(
    ctor: Constructor<'tcx>,
    fields: Fields<'p, 'tcx>,
    ty: Ty<'tcx>,
    span: Span
) -> Self

pub(super) fn wild_from_ctor(
    pcx: PatCtxt<'_, 'p, 'tcx>,
    ctor: Constructor<'tcx>
) -> Self

Construct a pattern that matches everything that starts with this constructor. For example, if ctor is a Constructor::Variant for Option::Some, we get the pattern Some(_).

pub(super) fn clone_and_forget_reachability(&self) -> Self

Clone this value. This method emphasizes that cloning loses reachability information and should be done carefully.

pub(crate) fn from_pat(cx: &MatchCheckCtxt<'p, 'tcx>, pat: &Pat<'tcx>) -> Self

pub(crate) fn to_pat(&self, cx: &MatchCheckCtxt<'p, 'tcx>) -> Pat<'tcx>

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

pub(super) fn ctor(&self) -> &Constructor<'tcx>

pub(super) fn ty(&self) -> Ty<'tcx>

pub(super) fn span(&self) -> Span

pub(super) fn iter_fields<'a>(
    &'a self
) -> impl Iterator<Item = &'p DeconstructedPat<'p, 'tcx>> + Captures<'a>

pub(super) fn specialize<'a>(
    &'a self,
    cx: &MatchCheckCtxt<'p, 'tcx>,
    other_ctor: &Constructor<'tcx>
) -> SmallVec<[&'p DeconstructedPat<'p, 'tcx>; 2]>

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

pub(super) fn set_reachable(&self)

We keep track for each pattern if it was ever reachable during the analysis. This is used with unreachable_spans to report unreachable subpatterns arising from or patterns.

pub(super) fn is_reachable(&self) -> bool

pub(super) fn unreachable_spans(&self) -> Vec<Span>

Report the spans of subpatterns that were not reachable, if any.

fn collect_unreachable_spans(&self, spans: &mut Vec<Span>)

Trait Implementations

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

This is mostly copied from the Pat impl. 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.

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