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

fn resolve_vars_if_possible<T>(&self, value: T) -> T where
    T: TypeFoldable<'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).

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,
    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>

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<'_>), 

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