Struct rustc_typeck::expr_use_visitor::ExprUseVisitor

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

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 walk_local<F>(&mut self, expr: &Expr<'_>, pat: &Pat<'_>, 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<'_>)

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

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

let p = ..;
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 be different between compiler versions and platforms. 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