[alexcgatea]

Summary

RewriteDriver still runs a fixpoint of sweeps. Each sweep now visits statements from a worklist instead of walking them in place:

1. The worklist is seeded with every statement under the root, in walk order, as a snapshot taken before any rule runs. The default order is PreOrder.

2. Statements are popped one at a time, and every rule is tried in order at each, as before.

3. After each statement, the MutationEvents of its edits add back the statements they may have given a new match. For each statement an event names as changed, replaced or inserted, the sweep adds, top-down:

   • its owner (new Statement::owner)
   • the producers of its operands
   • the statement itself
   • the users of its results

   A statement still in the queue keeps its place, so it is visited once, after the edit. One already visited goes to the back. Only statements under the root are added, so run_at(root) never leaves root's tree.

4. When the worklist is empty, dead code is cleaned up. The run ends after the first sweep that changes nothing.

Edits the worklist doesn't follow, such as erasures and CFG edits, are picked up by the next sweep, which starts from every statement again. So correctness never depends on the worklist being complete.

Behaviour changes

• In the driver, erasing the visited statement is allowed in every walk order, including a pattern rule erasing its root, because the driver visits a snapshot rather than walking the IR in place. DriverError::ErasesRoot and DriverError::Walk are removed. Ordinary walks in kirin_ir::walk keep their edit contract: ALLOWS_ERASING_VISITED still decides whether the visited statement may be erased.
• skip has no effect in the driver, because its walk is a snapshot. Ordinary walks in kirin_ir::walk still honour it.
• interrupt is unchanged: it ends the current sweep, and the run continues if that sweep changed something.
• A statement rule's copy may be handed the same statement more than once in a sweep.
• Block rules run again when their owner is re-added. That happens when an edit changes a statement in one of its blocks.
• New limit, max_rewrites_per_sweep (default 10,000). A sweep making more rewrites than that fails with DriverError::RewritesExhausted { root, rewrites }. max_sweeps is unchanged.

API

RewriteDriver::new(&rules)                  // PreOrder
    .walk_order::<PostOrder>()              // optional, any WalkOrder
    .max_sweeps(n)
    .max_rewrites_per_sweep(n)
    .run(rewriter)                          // was run::<O>(rewriter)

• RewriteDriver<'r, L, O: WalkOrder = PreOrder>.
• kirin-ir gains a public Statement::owner(stage), replacing the walk module's private parent helper.