The lambda-typing gate is INERT: three arms show zero emitted-byte delta, so #8758's carrier gets a corrected cause (two roots, per-site) and the four-name roster goes as cleanup

[briansrls]

What this PR is, stated before anything else

Two things, and neither of them fixes the three E0282 sites the branch title names:

1. A correction to A1: lambda-argument typing gate — the fourth bare-name-roster instance, recorded as a carrier #8758's merged carrier, whose content asserts a mechanism this branch refutes by execution.
2. Deletion of that mechanism — a four-name literal roster in emit_typed_call — as a cleanup whose receipt is a measured zero emitted-byte delta.

The branch title is the original brief. Its causal claim did not survive measurement, and this PR says so rather than quietly delivering something else under it.

The measurement

Two-arm emission. Subject: emitted closures of v2.compiler.tokenize, v2.compiler.parse, v2.lens.reference_deps. Producer: gunbc compile --target rust, two separately built release binaries in one dispatch. Controls run before either arm: arm B mirror lambda_argument_scope=2 / roster hits=0, arm A lambda_argument_scope=0 / roster hits=1 — the binaries are provably different.

	arm A (roster)	arm B (per-arg scope)
files emitted	258	258
file sets	identical	identical
files differing	0
lines differing	0
diagnostics	31 / 187 / 326	31 / 187 / 326

Arm C — the binding deleted entirely, not generalized — is also identical. That is what separates "the mechanism is inert" from "my replacement happens to agree with the roster", and it is the control that makes the null conclusive.

Why the mechanism cannot reach emitted bytes

Every scope. read in src/v1/05_emit_rust.dag: type_env 204, module_name 7, item_registry 1, locals 1. That single scope.locals reader is is_already_optional, on the arm taken only when a node carries no resolved type. Emission runs off the typed tree.

And the declared parameter types the gate was supposed to supply are already consulted one stage earlier — v1.compiler.infer infer_expr's ExprCall arm passes each callee formal as the argument's expected type, and its ExprLambda arm binds the lambda's parameters from that formal and writes the resolved types back onto the parameter nodes, which is exactly what lambda_scope_from_children reads. So "consult the resolved callee from lookup_item" would have been a second consultation of a fact inference had already resolved, landing in the same inert scope.

What changes in the emitter

• The four-name roster (map/filter/flat_map/fold) is deleted.
• Each argument is emitted in the call scope extended by that argument's own lambda parameters (lambda_argument_scope).
• Scoping moves from per-call to per-argument. The previous form left the last lambda's parameter names visible while emitting sibling arguments and the callee's filled default expressions, positions where those names are not bound.

That narrowing is construction cleanup with NO MEASURED CURRENT CONSEQUENCE, and an earlier revision of this body called it "a real leak" — which the same null refutes. scope.locals is read once in the whole Rust emitter, on an arm taken only when a node carries no resolved type, so nothing measured here shows the leak producing a wrong byte either. It is narrowed because the narrow form is the correct construction, not because a defect was observed, and it stays unearned as a repair until a fixture makes it observable. A PR whose entire point is that an unmeasured mechanism claim was wrong must not carry a second unmeasured mechanism claim in its own body.

The surface was a genuine bare-name-keying shape — the null refutes its consequence, not its shape — so this is a syntactic instance with no observable consequence, and deleting it is a cleanup rather than a defect repair. A literal roster that reads as a live decision and decides nothing is a false coverage surface.

The carrier correction, and the dangerous half

#8758's dissolution trigger read "dies when emit_typed_call binds a lambda argument's parameters from the callee's resolved declaration rather than from the four-name roster." With the mechanism refuted, that trigger is exactly satisfiable by a change that fixes nothing — delete the roster, retire the row, three sites still red. A false cause misleads a reader; a false dissolution trigger disposes of the evidence. The replacement keys on the only fact that can honestly retire the row — the three sites emitting and compiling without an inference failure — and states that no repair to the gate satisfies it on its own.

The mechanism verdict is now a typed row carrying its own measurement (MechanismRefutedByEmittedByteNull), not prose, because prose is precisely how the previous cause got planned against. Cause is CauseUnlocated.

Deliberately not over-retracted: the three sites, their locations, the E0282 × E0061 intersection that derived them, the seven companions in the held class, and UpperBoundPendingResidueCheck with its standing prediction all survive untouched. None of them depended on the cause. The reach figure is deleted outright rather than softened — it sized the blast radius of repairing a mechanism that changes no byte.

Superseded: the map_keys repair this PR used to carry

This section described a two-line map_keys repair to
trait_derive_supplemental_generic_bound_contract_test.dag that rode along on this branch.
It is no longer in this diff and the section is kept only so the record is not silently
rewritten. That repair landed independently through #8780, and when this branch absorbed
main the hunks dropped out on their own rather than needing resolution — verified after the
merge: the file is now byte-identical to main. Hand-resolving them would have re-authored a fix
already on main and produced a hybrid no generator emitted.

Anyone tracing who fixed the .keys() sites should land on #8780, not here.

Caveats, stated rather than buried

• Arm B is a hand-edited stage0 mirror. That the .dag authority emits that same Rust is not established here; it needs regen. The null is a statement about the mechanism's reach, and arm C carries it without depending on the mirror.
• The null was measured against the pre-merge main; origin/main has since been merged into this branch (it added rust_call_arg_function_value_adapt at the same site, kept).

Where the real root looks to be — not in this PR

The emitted specimen:

call:  is_prefix_of(prefix.clone(), source.clone(), |a, b| (a.clone() == b.clone()))
decl:  pub fn is_prefix_of<T: Clone>(prefix: Rc<FreeMonoid<T>>, xs: Rc<FreeMonoid<T>>,
                                     eq: impl Fn(T, T) -> bool + Clone) -> bool
site:  pub fn lex_match_prefix(prefix: String, source: String)
emitted: pub type String = std::string::String;   // v2_std_text.rs
         pub type FreeMonoid<T> = Vec<T>;          // std_algebra.rs

eq's parameters are inferable from impl Fn(T, T) the moment T is known, and T is knowable only from prefix/xs. v2.std.text declares String = FreeMonoid<Char> but emits as the host std::string::String, so the argument cannot unify with Rc<Vec<T>>, T never binds, and rustc reports at the closure. The closure is the symptom location, not the cause — which is why a roster of callee names was never going to move it. DESIGN already records this alias special-case in emit_typed_item. Hypothesis with strong supporting structure, not yet a measurement; confirming it needs cargo on the emitted crate, and that is the next lane's work.

🤖 Generated with Claude Code