Struct LoopFinder 

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

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<'gcx>

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

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

What each local storage reference names where the walk stands, the latest entry winning; None once a write leaves it without one answer (a conditional branch, a loop body, or an unreadable shape).

Implementations

impl<'gcx> LoopFinder<'_, '_, '_, 'gcx>

fn walk_body(&mut self, stmts: impl IntoIterator<Item = &'gcx Stmt<'gcx>>)

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

fn enter_loop( &mut self, init: &'gcx [Stmt<'gcx>], body: &'gcx [Stmt<'gcx>], update: Option<&'gcx Stmt<'gcx>>, )

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 of its statements 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: &'gcx Stmt<'gcx>)

Applies one straight-line statement to the bindings: everything it writes stops naming one thing, then a declaration or plain assignment binds its reference to what the right-hand side names right here (resolved eagerly, so a later write to a reference the right-hand side reads does not reach back into this binding).

fn poison_writes(&mut self, stmts: impl IntoIterator<Item = &'gcx Stmt<'gcx>>)

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

fn analyze_loop(&mut self, body: impl Iterator<Item = &'gcx Stmt<'gcx>> + Clone)

Flags the removals in a straight-line loop body that remove from a set the loop reads with at at an unconditional ascending 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: 40 bytes