Struct LoopFinder 

struct LoopFinder<'ctx, 's, 'c, 'hir> {
    gcx: Gcx<'hir>,
    hir: &'hir Hir<'hir>,
    ctx: &'ctx LintContext<'s, 'c>,
    bindings: Vec<(VariableId, Option<SetPath>)>,
    emitted: HashSet<Span>,
}

Walks a function body in statement order and, for each loop, flags the EnumerableSet remove calls that corrupt that loop’s own iteration. The walk keeps, at every point, what each local storage reference last named, so each loop is judged against the bindings standing where it runs rather than against every binding of the function.

Fields

gcx: Gcx<'hir>

hir: &'hir Hir<'hir>

ctx: &'ctx LintContext<'s, 'c>

bindings: Vec<(VariableId, Option<SetPath>)>

What each local storage reference names where the walk stands, the latest entry winning: the path its last straight-line binding resolved to, or None once a write leaves it without one answer, from a conditional branch, a loop body, or a shape the analysis cannot read.

emitted: HashSet<Span>

Implementations

impl<'hir> LoopFinder<'_, '_, '_, 'hir>

fn walk_body(&mut self, stmts: &'hir [Stmt<'hir>])

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

fn enter_loop( &mut self, init: &'hir [Stmt<'hir>], body: &'hir [Stmt<'hir>], source: LoopSource, )

Analyzes one loop, then walks inside it for the nested ones. A write anywhere in the loop may have run on an earlier turn by the time any statement of it runs again, so everything the loop writes, init included, stops naming one thing before the loop is judged, and stays so past it.

fn apply_bindings(&mut self, stmt: &'hir Stmt<'hir>)

Applies one straight-line statement to the bindings. Everything it writes stops naming one thing first; a declaration or a plain assignment then binds its reference to what the right-hand side names right here, resolved eagerly because a later write to a reference the right-hand side reads must not reach back into this binding.

fn poison_writes(&mut self, stmts: &'hir [Stmt<'hir>])

Marks everything the statements write as no longer naming one thing.

fn analyze_loop(&mut self, body: &'hir [Stmt<'hir>])

Flags the removals in body that corrupt this loop’s iteration, under the shrunk rule: an unconditional ascending cadence, a straight-line body, and a remove on a set the loop reads with at at that cadence.

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