Struct rustc_mir_build::thir::pattern::PatCtxt

pub(crate) struct PatCtxt<'a, 'tcx> {
    pub(crate) tcx: TyCtxt<'tcx>,
    pub(crate) param_env: ParamEnv<'tcx>,
    pub(crate) typeck_results: &'a TypeckResults<'tcx>,
    pub(crate) errors: Vec<PatternError>,
    include_lint_checks: bool,
}

Fields

tcx: TyCtxt<'tcx>

param_env: ParamEnv<'tcx>

typeck_results: &'a TypeckResults<'tcx>

errors: Vec<PatternError>

include_lint_checks: bool

Implementations

impl PatCtxt<'_, '_>

fn report_inlining_errors(&self, pat_span: Span)

fn span_e0158(&self, span: Span, text: &str)

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

pub(super) fn const_to_pat(
    &self,
    cv: &'tcx Const<'tcx>,
    id: HirId,
    span: Span,
    mir_structural_match_violation: bool
) -> Pat<'tcx>

Converts an evaluated 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).

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

pub(crate) fn new(
    tcx: TyCtxt<'tcx>,
    param_env: ParamEnv<'tcx>,
    typeck_results: &'a TypeckResults<'tcx>
) -> Self

pub(crate) fn include_lint_checks(&mut self) -> &mut Self

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

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

fn lower_pattern_range(
    &mut self,
    ty: Ty<'tcx>,
    lo: &'tcx Const<'tcx>,
    hi: &'tcx Const<'tcx>,
    end: RangeEnd,
    span: Span
) -> PatKind<'tcx>

fn normalize_range_pattern_ends(
    &self,
    ty: Ty<'tcx>,
    lo: Option<&PatKind<'tcx>>,
    hi: Option<&PatKind<'tcx>>
) -> Option<(&'tcx Const<'tcx>, &'tcx Const<'tcx>)>

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

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

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

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

fn slice_or_array_pattern(
    &mut self,
    span: Span,
    ty: Ty<'tcx>,
    prefix: &'tcx [&'tcx Pat<'tcx>],
    slice: &'tcx Option<&'tcx Pat<'tcx>>,
    suffix: &'tcx [&'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) -> 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_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_substs_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 substitutions; the hir-id must map to a suitable type.