Struct rustc_typeck::mem_categorization::MemCategorizationContext

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

Fields

typeck_results: &'a TypeckResults<'tcx>

infcx: &'a InferCtxt<'a, '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<'a, '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>,
    span: Span
) -> bool

pub(in mem_categorization) fn resolve_vars_if_possible<T>(
    &self,
    value: T
) -> T where
    T: TypeFoldable<'tcx>, 

pub(in mem_categorization) fn is_tainted_by_errors(
    &self
) -> bool

pub(in mem_categorization) 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>, ()>

pub(in mem_categorization) 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).

pub(in mem_categorization) 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>, ()>

pub(in mem_categorization) 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>, ()>

pub(in mem_categorization) 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,
    span: Span,
    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>

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

pub(in mem_categorization) 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<'_>), 

pub(in mem_categorization) 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.

pub(in mem_categorization) 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.

pub(in mem_categorization) 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.

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

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.