Struct AssignmentResult 

struct AssignmentResult<'a, 'tcx> {
    tcx: TyCtxt<'tcx>,
    typing_env: TypingEnv<'tcx>,
    checked_places: &'a PlaceSet<'tcx>,
    body: &'a Body<'tcx>,
    ever_live: DenseBitSet<PlaceIndex>,
    ever_dropped: DenseBitSet<PlaceIndex>,
    assignments: IndexVec<PlaceIndex, FxIndexMap<SourceInfo, Access>>,
}

Fields

tcx: TyCtxt<'tcx>

typing_env: TypingEnv<'tcx>

checked_places: &'a PlaceSet<'tcx>

body: &'a Body<'tcx>

ever_live: DenseBitSet<PlaceIndex>

Set of locals that are live at least once. This is used to report fully unused locals.

ever_dropped: DenseBitSet<PlaceIndex>

Set of locals that have a non-trivial drop. This is used to skip reporting unused assignment if it would be used by the Drop impl.

assignments: IndexVec<PlaceIndex, FxIndexMap<SourceInfo, Access>>

Set of assignments for each local. Here, assignment is understood in the AST sense. Any MIR that may look like an assignment (Assign, DropAndReplace, Yield, Call) are considered.

For each local, we return a map: for each source position, whether the statement is live and which kind of access it performs. When we encounter multiple statements at the same location, we only increase the liveness, in order to avoid false positives.

Implementations

impl<'a, 'tcx> AssignmentResult<'a, 'tcx>

fn find_dead_assignments( tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>, checked_places: &'a PlaceSet<'tcx>, cursor: &mut ResultsCursor<'_, 'tcx, MaybeLivePlaces<'_, 'tcx>>, body: &'a Body<'tcx>, ) -> AssignmentResult<'a, 'tcx>

Collect all assignments to checked locals.

Assignments are collected, even if they are live. Dead assignments are reported, and live assignments are used to make diagnostics correct for match guards.

fn merge_guards(&mut self)

Match guards introduce a different local to freeze the guarded value as immutable. Having two locals, we need to make sure that we do not report an unused_variable when the guard local is used but not the arm local, or vice versa, like in this example.

match 5 { x if x > 2 => {} ^ ^- This is local +—— This is arm_local _ => {} }

fn compute_dead_captures(&self, num_captures: usize) -> DenseBitSet<FieldIdx>

Compute captures that are fully dead.

fn report_fully_unused(&mut self)

Report fully unused locals, and forget the corresponding assignments.

fn report_unused_assignments(self)

Second, report unused assignments that do not correspond to initialization. Initializations have been removed in the previous loop reporting unused variables.

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