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

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

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

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

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

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

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

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

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

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

pub(in expr_use_visitor) fn walk_local(
    &mut self,
    local: &Local<'_>
)

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

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

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

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

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

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

pub(in expr_use_visitor) fn walk_pat(
    &mut self,
    discr_place: &PlaceWithHirId<'tcx>,
    pat: &Pat<'_>
)

The core driver for walking a pattern

pub(in expr_use_visitor) fn walk_captures_closure_captures(
    &mut self,
    closure_expr: &Expr<'_>
)

Walk closure captures but using closure_caputes instead of closure_min_captures.

This is needed because clippy uses ExprUseVisitor after TypeckResults are written back. We don't currently writeback min_captures to TypeckResults.

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

pub(in expr_use_visitor) fn cat_captured_var(
    &mut self,
    closure_hir_id: HirId,
    closure_span: Span,
    var_id: HirId
) -> Result<PlaceWithHirId<'tcx>, ()>