Struct PatCtxt

struct PatCtxt<'a, 'tcx> {
    tcx: TyCtxt<'tcx>,
    typing_env: TypingEnv<'tcx>,
    typeck_results: &'a TypeckResults<'tcx>,
    rust_2024_migration_suggestion: Option<Rust2024IncompatiblePatSugg>,
}

Fields

tcx: TyCtxt<'tcx>

typing_env: TypingEnv<'tcx>

typeck_results: &'a TypeckResults<'tcx>

rust_2024_migration_suggestion: Option<Rust2024IncompatiblePatSugg>

Used by the Rust 2024 migration lint.

Implementations

impl<'a, 'tcx> PatCtxt<'a, 'tcx>

pub(super) fn const_to_pat( &self, c: Const<'tcx>, ty: Ty<'tcx>, id: HirId, span: Span, ) -> Box<Pat<'tcx>>

Converts a constant to a pattern (if possible). This means aggregate values (like structs and enums) are converted to a pattern that matches the value (as if you’d compared via structural equality).

Only type system constants are supported, as we are using valtrees as an intermediate step. Unfortunately those don’t carry a type so we have to carry one ourselves.

impl<'a, 'tcx> PatCtxt<'a, 'tcx>

fn lower_pattern(&mut self, pat: &'tcx Pat<'tcx>) -> Box<Pat<'tcx>>

fn lower_pattern_range_endpoint( &mut self, expr: Option<&'tcx Expr<'tcx>>, ) -> Result<(Option<PatRangeBoundary<'tcx>>, Option<Ascription<'tcx>>, Option<LocalDefId>), ErrorGuaranteed>

fn error_on_literal_overflow( &self, expr: Option<&'tcx Expr<'tcx>>, ty: Ty<'tcx>, ) -> Result<(), ErrorGuaranteed>

Overflowing literals are linted against in a late pass. This is mostly fine, except when we encounter a range pattern like -130i8..2: if we believe eval_bits, this looks like a range where the endpoints are in the wrong order. To avoid a confusing error message, we check for overflow then. This is only called when the range is already known to be malformed.

fn lower_pattern_range( &mut self, lo_expr: Option<&'tcx Expr<'tcx>>, hi_expr: Option<&'tcx Expr<'tcx>>, end: RangeEnd, ty: Ty<'tcx>, span: Span, ) -> Result<PatKind<'tcx>, ErrorGuaranteed>

fn lower_pattern_unadjusted(&mut self, pat: &'tcx Pat<'tcx>) -> Box<Pat<'tcx>>

fn lower_tuple_subpats( &mut self, pats: &'tcx [Pat<'tcx>], expected_len: usize, gap_pos: DotDotPos, ) -> Vec<FieldPat<'tcx>>

fn lower_patterns(&mut self, pats: &'tcx [Pat<'tcx>]) -> Box<[Box<Pat<'tcx>>]>

fn lower_opt_pattern( &mut self, pat: Option<&'tcx Pat<'tcx>>, ) -> Option<Box<Pat<'tcx>>>

fn slice_or_array_pattern( &mut self, span: Span, ty: Ty<'tcx>, prefix: &'tcx [Pat<'tcx>], slice: Option<&'tcx Pat<'tcx>>, suffix: &'tcx [Pat<'tcx>], ) -> PatKind<'tcx>

fn lower_variant_or_leaf( &mut self, res: Res, hir_id: HirId, span: Span, ty: Ty<'tcx>, subpatterns: Vec<FieldPat<'tcx>>, ) -> PatKind<'tcx>

fn lower_path( &mut self, qpath: &QPath<'_>, id: HirId, span: Span, ) -> Box<Pat<'tcx>>

Takes a HIR Path. If the path is a constant, evaluates it and feeds it to const_to_pat. Any other path (like enum variants without fields) is converted to the corresponding pattern via lower_variant_or_leaf.

fn lower_inline_const( &mut self, block: &'tcx ConstBlock, id: HirId, span: Span, ) -> PatKind<'tcx>

Converts inline const patterns.

fn lower_lit(&mut self, expr: &'tcx Expr<'tcx>) -> PatKind<'tcx>

Converts literals, paths and negation of literals to patterns. The special case for negation exists to allow things like -128_i8 which would overflow if we tried to evaluate 128_i8 and then negate afterwards.

Trait Implementations

impl<'tcx> UserAnnotatedTyHelpers<'tcx> for PatCtxt<'_, 'tcx>

fn tcx(&self) -> TyCtxt<'tcx>

fn typeck_results(&self) -> &TypeckResults<'tcx>

fn user_args_applied_to_ty_of_hir_id( &self, hir_id: HirId, ) -> Option<CanonicalUserType<'tcx>>

Looks up the type associated with this hir-id and applies the user-given generic parameters; the hir-id must map to a suitable type.

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