Struct rustc_hir_analysis::expr_use_visitor::ExprUseVisitor

pub struct ExprUseVisitor<'a, 'tcx> {
    mc: MemCategorizationContext<'a, 'tcx>,
    body_owner: LocalDefId,
    delegate: &'a mut dyn Delegate<'tcx>,
}

The ExprUseVisitor type

This is the code that actually walks the tree.

Fields

mc: MemCategorizationContext<'a, 'tcx>

body_owner: LocalDefId

delegate: &'a mut dyn Delegate<'tcx>

Implementations

impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx>

pub fn new(
    delegate: &'a mut (dyn Delegate<'tcx> + 'a),
    infcx: &'a InferCtxt<'a, 'tcx>,
    body_owner: LocalDefId,
    param_env: ParamEnv<'tcx>,
    typeck_results: &'a TypeckResults<'tcx>
) -> Self

Creates the ExprUseVisitor, configuring it with the various options provided:

• delegate – who receives the callbacks
• param_env — parameter environment for trait lookups (esp. pertaining to Copy)
• typeck_results — typeck results for the code being analyzed

pub fn consume_body(&mut self, body: &Body<'_>)

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

fn delegate_consume(
    &mut self,
    place_with_id: &PlaceWithHirId<'tcx>,
    diag_expr_id: HirId
)

fn consume_exprs(&mut self, exprs: &[Expr<'_>])

pub fn consume_expr(&mut self, expr: &Expr<'_>)

fn mutate_expr(&mut self, expr: &Expr<'_>)

fn borrow_expr(&mut self, expr: &Expr<'_>, bk: BorrowKind)

fn select_from_expr(&mut self, expr: &Expr<'_>)

pub fn walk_expr(&mut self, expr: &Expr<'_>)

fn walk_stmt(&mut self, stmt: &Stmt<'_>)

fn maybe_read_scrutinee<'t>(
    &mut self,
    discr: &Expr<'_>,
    discr_place: PlaceWithHirId<'tcx>,
    pats: impl Iterator<Item = &'t Pat<'t>>
)

fn walk_local<F>(
    &mut self,
    expr: &Expr<'_>,
    pat: &Pat<'_>,
    els: Option<&Block<'_>>,
    f: F
)where
    F: FnMut(&mut Self),

fn walk_block(&mut self, blk: &Block<'_>)

Indicates that the value of blk will be consumed, meaning either copied or moved depending on its type.

fn walk_struct_expr<'hir>(
    &mut self,
    fields: &[ExprField<'_>],
    opt_with: &Option<&'hir Expr<'_>>
)

fn walk_adjustment(&mut self, expr: &Expr<'_>)

Invoke the appropriate delegate calls for anything that gets consumed or borrowed as part of the automatic adjustment process.

fn walk_autoref(
    &mut self,
    expr: &Expr<'_>,
    base_place: &PlaceWithHirId<'tcx>,
    autoref: &AutoBorrow<'tcx>
)

Walks the autoref autoref applied to the autoderef’d expr. base_place is the mem-categorized form of expr after all relevant autoderefs have occurred.

fn walk_arm(&mut self, discr_place: &PlaceWithHirId<'tcx>, arm: &Arm<'_>)

fn walk_irrefutable_pat(
    &mut self,
    discr_place: &PlaceWithHirId<'tcx>,
    pat: &Pat<'_>
)

Walks a pat that occurs in isolation (i.e., top-level of fn argument or let binding, and not a match arm or nested pat.)

fn walk_pat(
    &mut self,
    discr_place: &PlaceWithHirId<'tcx>,
    pat: &Pat<'_>,
    has_guard: bool
)

The core driver for walking a pattern

fn walk_captures(&mut self, closure_expr: &Expr<'_>)

Handle the case where the current body contains a closure.

When the current body being handled is a closure, then we must make sure that

• The parent closure only captures Places from the nested closure that are not local to it.

In the following example the closures c only captures p.x even though incr is a capture of the nested closure

struct P { x: i32 }
let mut p = P { x: 4 };
let c = || {
   let incr = 10;
   let nested = || p.x += incr;
};

• When reporting the Place back to the Delegate, ensure that the UpvarId uses the enclosing closure as the DefId.

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