Enum rustc_mir_build::thir::PatKind

pub enum PatKind<'tcx> {
    Wild,
    AscribeUserType {
        ascription: Ascription<'tcx>,
        subpattern: Pat<'tcx>,
    },
    Binding {
        mutability: Mutability,
        name: Symbol,
        mode: BindingMode,
        var: HirId,
        ty: Ty<'tcx>,
        subpattern: Option<Pat<'tcx>>,
        is_primary: bool,
    },
    Variant {
        adt_def: &'tcx AdtDef,
        substs: SubstsRef<'tcx>,
        variant_index: VariantIdx,
        subpatterns: Vec<FieldPat<'tcx>>,
    },
    Leaf {
        subpatterns: Vec<FieldPat<'tcx>>,
    },
    Deref {
        subpattern: Pat<'tcx>,
    },
    Constant {
        value: &'tcx Const<'tcx>,
    },
    Range(PatRange<'tcx>),
    Slice {
        prefix: Vec<Pat<'tcx>>,
        slice: Option<Pat<'tcx>>,
        suffix: Vec<Pat<'tcx>>,
    },
    Array {
        prefix: Vec<Pat<'tcx>>,
        slice: Option<Pat<'tcx>>,
        suffix: Vec<Pat<'tcx>>,
    },
    Or {
        pats: Vec<Pat<'tcx>>,
    },
}

Variants

Wild

AscribeUserType

Fields of AscribeUserType

ascription: Ascription<'tcx>subpattern: Pat<'tcx>

Binding

x, ref x, x @ P, etc.

Fields of Binding

mutability: Mutabilityname: Symbolmode: BindingModevar: HirIdty: Ty<'tcx>subpattern: Option<Pat<'tcx>>is_primary: bool

Is this the leftmost occurrence of the binding, i.e., is var the HirId of this pattern?

Variant

Foo(...) or Foo{...} or Foo, where Foo is a variant name from an ADT with multiple variants.

Fields of Variant

adt_def: &'tcx AdtDefsubsts: SubstsRef<'tcx>variant_index: VariantIdxsubpatterns: Vec<FieldPat<'tcx>>

Leaf

(...), Foo(...), Foo{...}, or Foo, where Foo is a variant name from an ADT with a single variant.

Fields of Leaf

subpatterns: Vec<FieldPat<'tcx>>

Deref

box P, &P, &mut P, etc.

Fields of Deref

subpattern: Pat<'tcx>

Constant

One of the following:

• &str, which will be handled as a string pattern and thus exhaustiveness checking will detect if you use the same string twice in different patterns.
• integer, bool, char or float, which will be handled by exhaustivenes to cover exactly its own value, similar to &str, but these values are much simpler.
• Opaque constants, that must not be matched structurally. So anything that does not derive PartialEq and Eq.

Fields of Constant

value: &'tcx Const<'tcx>

Range(PatRange<'tcx>)

Slice

Matches against a slice, checking the length and extracting elements. irrefutable when there is a slice pattern and both prefix and suffix are empty. e.g., &[ref xs @ ..].

Fields of Slice

prefix: Vec<Pat<'tcx>>slice: Option<Pat<'tcx>>suffix: Vec<Pat<'tcx>>

Array

Fixed match against an array; irrefutable.

Fields of Array

prefix: Vec<Pat<'tcx>>slice: Option<Pat<'tcx>>suffix: Vec<Pat<'tcx>>

Or

An or-pattern, e.g. p | q. Invariant: pats.len() >= 2.

Fields of Or

pats: Vec<Pat<'tcx>>

Trait Implementations

impl<'tcx> Clone for PatKind<'tcx>

fn clone(&self) -> PatKind<'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for PatKind<'tcx>

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

Formats the value using the given formatter.

impl<'tcx> PartialEq<PatKind<'tcx>> for PatKind<'tcx>

fn eq(&self, other: &PatKind<'tcx>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &PatKind<'tcx>) -> bool

This method tests for !=.

impl<'tcx> PatternFoldable<'tcx> for PatKind<'tcx>

fn fold_with<F: PatternFolder<'tcx>>(&self, folder: &mut F) -> Self

fn super_fold_with<F: PatternFolder<'tcx>>(&self, folder: &mut F) -> Self

impl<'tcx> StructuralPartialEq for PatKind<'tcx>