Problem

optimizeModule decides whether to inline each Standalone binding partly on whether it is referenced exactly once. It computed those reference counts by folding countFreeRefs over every expression in the module, and it redid that fold for every binding that reached the use-once check. That is O(bindings × module size) per optimizeModule run, and the run repeats on every iteration of the optimize+dce fixpoint (#142).

The same counts were also assembled from the original bindings plus the already-substituted exports, a mix of stale and fresh sources. Within a single run that misjudges use-once: a binding that has become referenced multiple times can still be inlined into all of them (code bloat), or a genuinely used-once binding can be skipped. idempotently papered over it across iterations at the cost of extra passes (#143).

What changed

A single free-reference map is threaded through the fold with a precise invariant: it always holds the free-reference counts over the current accumulator (the bindings kept so far plus the exports). foldrM visits bindings right-to-left, and a binding can only be referenced by material to its right, so by the time a binding is visited every one of its referencers is already accounted for and its count is final. The map is built once from the exports and updated by a known delta at each step: add a kept binding's own refs, or, when inlining, add one copy of the inlinee's refs per replaced occurrence and drop the binding's own entry. Note [Incremental free-reference counting] in Optimizer.hs records the invariant and the delta.

This removes the quadratic recomputation and, because the counts now track the live post-substitution module, fixes the stale use-once judgement in the same change.

Measurements

Allocation of a single optimizeModule run on a synthetic module of N non-inlinable bindings, via ghci :set +s:

Doubling N multiplies allocation by about 2.6x to 3.2x before (trending toward the quadratic 4x) and about 1.7x to 1.8x after (linear). The gap widens with module size, as expected going from O(bindings × size) to O(size).

Goldens

Structural goldens (golden.ir / golden.lua) shift for 28 modules. Two kinds of change: the live count stops duplicating a multiply-used foreign accessor (for example Data.Ring.intSub is now shared rather than pasted into both arms of Golden.Fibonacci), and gensym suffixes renumber where a different number of substitutions runs. Every eval/golden.txt oracle is unchanged, so runtime behaviour is preserved.

Testing

Adds a single-run regression spec that inlines a binding which becomes used-once mid-run; it is red against the stale count and green with the fix. A single run is deliberate: the optimize+dce fixpoint masks the misjudgement by self-correcting on a later iteration. The existing optimizer property tests (free references preserved, GUC invariants, idempotence, bound-name set) still pass, and the full suite is green with the eval oracles untouched.

Fixes #142
Fixes #143