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

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§

source§

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

source

pub fn new( delegate: &'a mut (dyn Delegate<'tcx> + 'a), infcx: &'a InferCtxt<'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
source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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.

source

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

source

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.

source

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.

source

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

source

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.)

source

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

The core driver for walking a pattern

source

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

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.

Auto Trait Implementations§

§

impl<'a, 'tcx> !RefUnwindSafe for ExprUseVisitor<'a, 'tcx>

§

impl<'a, 'tcx> !Send for ExprUseVisitor<'a, 'tcx>

§

impl<'a, 'tcx> !Sync for ExprUseVisitor<'a, 'tcx>

§

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

§

impl<'a, 'tcx> !UnwindSafe for ExprUseVisitor<'a, 'tcx>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

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