Struct rustc_hir_typeck::mem_categorization::MemCategorizationContext

pub(crate) struct MemCategorizationContext<'a, 'tcx> {
    pub(crate) typeck_results: &'a TypeckResults<'tcx>,
    infcx: &'a InferCtxt<'tcx>,
    param_env: ParamEnv<'tcx>,
    body_owner: LocalDefId,
    upvars: Option<&'tcx FxIndexMap<HirId, Upvar>>,
}

Fields

typeck_results: &'a TypeckResults<'tcx>

infcx: &'a InferCtxt<'tcx>

param_env: ParamEnv<'tcx>

body_owner: LocalDefId

upvars: Option<&'tcx FxIndexMap<HirId, Upvar>>

Implementations

impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx>

pub(crate) fn new( infcx: &'a InferCtxt<'tcx>, param_env: ParamEnv<'tcx>, body_owner: LocalDefId, typeck_results: &'a TypeckResults<'tcx> ) -> MemCategorizationContext<'a, 'tcx>

Creates a MemCategorizationContext.

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

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

fn resolve_vars_if_possible<T>(&self, value: T) -> T

where T: TypeFoldable<TyCtxt<'tcx>>,

fn is_tainted_by_errors(&self) -> bool

fn resolve_type_vars_or_error( &self, id: HirId, ty: Option<Ty<'tcx>> ) -> Result<Ty<'tcx>, ()>

pub(crate) fn node_ty(&self, hir_id: HirId) -> Result<Ty<'tcx>, ()>

fn expr_ty(&self, expr: &Expr<'_>) -> Result<Ty<'tcx>, ()>

pub(crate) fn expr_ty_adjusted(&self, expr: &Expr<'_>) -> Result<Ty<'tcx>, ()>

pub(crate) fn pat_ty_adjusted(&self, pat: &Pat<'_>) -> Result<Ty<'tcx>, ()>

Returns the type of value that this pattern matches against. Some non-obvious cases:

• a ref x binding matches against a value of type T and gives x the type &T; we return T.
• a pattern with implicit derefs (thanks to default binding modes #42640) may look like Some(x) but in fact have implicit deref patterns attached (e.g., it is really &Some(x)). In that case, we return the “outermost” type (e.g., &Option<T>).

fn pat_ty_unadjusted(&self, pat: &Pat<'_>) -> Result<Ty<'tcx>, ()>

Like pat_ty, but ignores implicit & patterns.

pub(crate) fn cat_expr( &self, expr: &Expr<'_> ) -> Result<PlaceWithHirId<'tcx>, ()>

pub(crate) fn cat_expr_adjusted( &self, expr: &Expr<'_>, previous: PlaceWithHirId<'tcx>, adjustment: &Adjustment<'tcx> ) -> Result<PlaceWithHirId<'tcx>, ()>

fn cat_expr_adjusted_with<F>( &self, expr: &Expr<'_>, previous: F, adjustment: &Adjustment<'tcx> ) -> Result<PlaceWithHirId<'tcx>, ()>

where F: FnOnce() -> Result<PlaceWithHirId<'tcx>, ()>,

pub(crate) fn cat_expr_unadjusted( &self, expr: &Expr<'_> ) -> Result<PlaceWithHirId<'tcx>, ()>

pub(crate) fn cat_res( &self, hir_id: HirId, span: Span, expr_ty: Ty<'tcx>, res: Res ) -> Result<PlaceWithHirId<'tcx>, ()>

fn cat_upvar( &self, hir_id: HirId, var_id: HirId ) -> Result<PlaceWithHirId<'tcx>, ()>

Categorize an upvar.

Note: the actual upvar access contains invisible derefs of closure environment and upvar reference as appropriate. Only regionck cares about these dereferences, so we let it compute them as needed.

pub(crate) fn cat_rvalue( &self, hir_id: HirId, expr_ty: Ty<'tcx> ) -> PlaceWithHirId<'tcx>

pub(crate) fn cat_projection<N: HirNode>( &self, node: &N, base_place: PlaceWithHirId<'tcx>, ty: Ty<'tcx>, kind: ProjectionKind ) -> PlaceWithHirId<'tcx>

fn cat_overloaded_place( &self, expr: &Expr<'_>, base: &Expr<'_> ) -> Result<PlaceWithHirId<'tcx>, ()>

fn cat_deref( &self, node: &impl HirNode, base_place: PlaceWithHirId<'tcx> ) -> Result<PlaceWithHirId<'tcx>, ()>

pub(crate) fn cat_pattern<F>( &self, place: PlaceWithHirId<'tcx>, pat: &Pat<'_>, op: F ) -> Result<(), ()>

where F: FnMut(&PlaceWithHirId<'tcx>, &Pat<'_>),

fn variant_index_for_adt( &self, qpath: &QPath<'_>, pat_hir_id: HirId, span: Span ) -> Result<VariantIdx, ()>

Returns the variant index for an ADT used within a Struct or TupleStruct pattern Here pat_hir_id is the HirId of the pattern itself.

fn total_fields_in_adt_variant( &self, pat_hir_id: HirId, variant_index: VariantIdx, span: Span ) -> Result<usize, ()>

Returns the total number of fields in an ADT variant used within a pattern. Here pat_hir_id is the HirId of the pattern itself.

fn total_fields_in_tuple( &self, pat_hir_id: HirId, span: Span ) -> Result<usize, ()>

Returns the total number of fields in a tuple used within a Tuple pattern. Here pat_hir_id is the HirId of the pattern itself.

fn cat_pattern_<F>( &self, place_with_id: PlaceWithHirId<'tcx>, pat: &Pat<'_>, op: &mut F ) -> Result<(), ()>

where F: FnMut(&PlaceWithHirId<'tcx>, &Pat<'_>),

Here, place is the PlaceWithHirId being matched and pat is the pattern it is being matched against.

In general, the way that this works is that we walk down the pattern, constructing a PlaceWithHirId that represents the path that will be taken to reach the value being matched.

Trait Implementations

impl<'a, 'tcx> Clone for MemCategorizationContext<'a, 'tcx>

fn clone(&self) -> MemCategorizationContext<'a, 'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.

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