Struct RustcPatCtxt

pub struct RustcPatCtxt<'p, 'tcx: 'p> {
    pub tcx: TyCtxt<'tcx>,
    pub typeck_results: &'tcx TypeckResults<'tcx>,
    pub module: DefId,
    pub typing_env: TypingEnv<'tcx>,
    pub dropless_arena: &'p DroplessArena,
    pub match_lint_level: HirId,
    pub whole_match_span: Option<Span>,
    pub scrut_span: Span,
    pub refutable: bool,
    pub known_valid_scrutinee: bool,
}

Fields

tcx: TyCtxt<'tcx>

typeck_results: &'tcx TypeckResults<'tcx>

module: DefId

The module in which the match occurs. This is necessary for checking inhabited-ness of types because whether a type is (visibly) inhabited can depend on whether it was defined in the current module or not. E.g., struct Foo { _private: ! } cannot be seen to be empty outside its module and should not be matchable with an empty match statement.

typing_env: TypingEnv<'tcx>

dropless_arena: &'p DroplessArena

To allocate the result of self.ctor_sub_tys()

match_lint_level: HirId

Lint level at the match.

whole_match_span: Option<Span>

The span of the whole match, if applicable.

scrut_span: Span

Span of the scrutinee.

refutable: bool

Only produce NON_EXHAUSTIVE_OMITTED_PATTERNS lint on refutable patterns.

known_valid_scrutinee: bool

Whether the data at the scrutinee is known to be valid. This is false if the scrutinee comes from a union field, a pointer deref, or a reference deref (pending opsem decisions).

Implementations

impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx>

pub fn reveal_opaque_ty(&self, ty: Ty<'tcx>) -> RevealedTy<'tcx>

Type inference occasionally gives us opaque types in places where corresponding patterns have more specific types. To avoid inconsistencies as well as detect opaque uninhabited types, we use the corresponding concrete type if possible.

fn reveal_opaque_key(&self, key: OpaqueTypeKey<'tcx>) -> Option<Ty<'tcx>>

Returns the hidden type corresponding to this key if the body under analysis is allowed to know it.

pub fn is_uninhabited(&self, ty: Ty<'tcx>) -> bool

pub fn is_foreign_non_exhaustive_enum(&self, ty: RevealedTy<'tcx>) -> bool

Returns whether the given type is an enum from another crate declared #[non_exhaustive].

pub fn is_range_beyond_boundaries( &self, range: &IntRange, ty: RevealedTy<'tcx>, ) -> bool

Whether the range denotes the fictitious values before isize::MIN or after usize::MAX/isize::MAX (see doc of IntRange::split for why these exist).

pub(crate) fn variant_sub_tys( &self, ty: RevealedTy<'tcx>, variant: &'tcx VariantDef, ) -> impl Iterator<Item = (&'tcx FieldDef, RevealedTy<'tcx>)> + Captures<'p> + Captures<'_>

pub(crate) fn variant_index_for_adt( ctor: &Constructor<'p, 'tcx>, adt: AdtDef<'tcx>, ) -> VariantIdx

pub(crate) fn ctor_sub_tys<'a>( &'a self, ctor: &'a Constructor<'p, 'tcx>, ty: RevealedTy<'tcx>, ) -> impl Iterator<Item = (RevealedTy<'tcx>, PrivateUninhabitedField)> + ExactSizeIterator + Captures<'a>

Returns the types of the fields for a given constructor. The result must have a length of ctor.arity().

pub(crate) fn ctor_arity( &self, ctor: &Constructor<'p, 'tcx>, ty: RevealedTy<'tcx>, ) -> usize

The number of fields for this constructor.

pub fn ctors_for_ty( &self, ty: RevealedTy<'tcx>, ) -> Result<ConstructorSet<'p, 'tcx>, ErrorGuaranteed>

Creates a set that represents all the constructors of ty.

See crate::constructor for considerations of emptiness.

pub(crate) fn lower_pat_range_bdy( &self, bdy: PatRangeBoundary<'tcx>, ty: RevealedTy<'tcx>, ) -> MaybeInfiniteInt

pub fn lower_pat(&self, pat: &'p Pat<'tcx>) -> DeconstructedPat<'p, 'tcx>

Note: the input patterns must have been lowered through rustc_mir_build::thir::pattern::check_match::MatchVisitor::lower_pattern.

fn hoist_pat_range_bdy( &self, miint: MaybeInfiniteInt, ty: RevealedTy<'tcx>, ) -> PatRangeBoundary<'tcx>

Convert back to a thir::PatRangeBoundary for diagnostic purposes. Note: it is possible to get isize/usize::MAX+1 here, as explained in the doc for IntRange::split. This cannot be represented as a Const, so we represent it with PosInfinity.

fn print_pat_range(&self, range: &IntRange, ty: RevealedTy<'tcx>) -> String

Prints an IntRange to a string for diagnostic purposes.

pub fn print_witness_pat(&self, pat: &WitnessPat<'p, 'tcx>) -> String

Prints a WitnessPat to an owned string, for diagnostic purposes.

This panics for patterns that don’t appear in diagnostics, like float ranges.

Trait Implementations

impl<'p, 'tcx: 'p> Clone for RustcPatCtxt<'p, 'tcx>

fn clone(&self) -> RustcPatCtxt<'p, 'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'p, 'tcx: 'p> Debug for RustcPatCtxt<'p, 'tcx>

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

Formats the value using the given formatter.

impl<'p, 'tcx: 'p> PatCx for RustcPatCtxt<'p, 'tcx>

type Ty = RevealedTy<'tcx>

The type of a pattern.

type Error = ErrorGuaranteed

Errors that can abort analysis.

type VariantIdx = VariantIdx

The index of an enum variant.

type StrLit = Const<'tcx>

A string literal

type ArmData = HirId

Extra data to store in a match arm.

type PatData = &'p Pat<'tcx>

Extra data to store in a pattern.

fn is_exhaustive_patterns_feature_on(&self) -> bool

fn ctor_arity(&self, ctor: &Constructor<Self>, ty: &Self::Ty) -> usize

The number of fields for this constructor.

fn ctor_sub_tys<'a>( &'a self, ctor: &'a Constructor<Self>, ty: &'a Self::Ty, ) -> impl Iterator<Item = (Self::Ty, PrivateUninhabitedField)> + ExactSizeIterator + Captures<'a>

The types of the fields for this constructor. The result must contain ctor_arity() fields.

fn ctors_for_ty( &self, ty: &Self::Ty, ) -> Result<ConstructorSet<Self>, Self::Error>

The set of all the constructors for ty.

fn write_variant_name( f: &mut Formatter<'_>, ctor: &Constructor<Self>, ty: &Self::Ty, ) -> Result

Write the name of the variant represented by pat. Used for the best-effort Debug impl of DeconstructedPat. Only invoqued when pat.ctor() is Struct | Variant(_) | UnionField.

fn bug(&self, fmt: Arguments<'_>) -> Self::Error

Raise a bug.

fn lint_overlapping_range_endpoints( &self, pat: &DeconstructedPat<Self>, overlaps_on: IntRange, overlaps_with: &[&DeconstructedPat<Self>], )

Lint that the range pat overlapped with all the ranges in overlaps_with, where the range they overlapped over is overlaps_on. We only detect singleton overlaps. The default implementation does nothing.

fn complexity_exceeded(&self) -> Result<(), Self::Error>

The maximum pattern complexity limit was reached.

fn lint_non_contiguous_range_endpoints( &self, pat: &DeconstructedPat<Self>, gap: IntRange, gapped_with: &[&DeconstructedPat<Self>], )

Lint that there is a gap gap between pat and all of gapped_with such that the gap is not matched by another range. If gapped_with is empty, then gap is T::MAX. We only detect singleton gaps. The default implementation does nothing.

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