Struct rustc_mir_build::thir::pattern::usefulness::Witness

pub(crate) struct Witness<'tcx>(Vec<Pat<'tcx>>);

A witness of non-exhaustiveness for error reporting, represented as a list of patterns (in reverse order of construction) with wildcards inside to represent elements that can take any inhabitant of the type as a value.

A witness against a list of patterns should have the same types and length as the pattern matched against. Because Rust match is always against a single pattern, at the end the witness will have length 1, but in the middle of the algorithm, it can contain multiple patterns.

For example, if we are constructing a witness for the match against

struct Pair(Option<(u32, u32)>, bool);

match (p: Pair) {
   Pair(None, _) => {}
   Pair(_, false) => {}
}

We’ll perform the following steps:

1. Start with an empty witness Witness(vec![])
2. Push a witness true against the false Witness(vec![true])
3. Push a witness Some(_) against the None Witness(vec![true, Some(_)])
4. Apply the Pair constructor to the witnesses Witness(vec![Pair(Some(_), true)])

The final Pair(Some(_), true) is then the resulting witness.

Implementations

impl<'tcx> Witness<'tcx>

fn single_pattern(self) -> Pat<'tcx>

Asserts that the witness contains a single pattern, and returns it.

fn apply_constructor<'p>(
    self,
    pcx: PatCtxt<'_, 'p, 'tcx>,
    ctor: &Constructor<'tcx>,
    ctor_wild_subpatterns: &Fields<'p, 'tcx>
) -> Self

Constructs a partial witness for a pattern given a list of patterns expanded by the specialization step.

When a pattern P is discovered to be useful, this function is used bottom-up to reconstruct a complete witness, e.g., a pattern P’ that covers a subset of values, V, where each value in that set is not covered by any previously used patterns and is covered by the pattern P’. Examples:

left_ty: tuple of 3 elements pats: [10, 20, _] => (10, 20, _)

left_ty: struct X { a: (bool, &’static str), b: usize} pats: [(false, “foo”), 42] => X { a: (false, “foo”), b: 42 }

Trait Implementations

impl<'tcx> Clone for Witness<'tcx>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for Witness<'tcx>

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

Formats the value using the given formatter.