Resolve a callable type's parameter and return types: a lambda parameter's receiver had no method surface

[gunbai-bot]

resolve_node_bounded dispatches on connective. A callable type node is Arrow — parse_callable_type_expr puts its parameter types in params and its return type in inferred, leaving children empty. Every arm of that dispatch copied params: n.params through verbatim, and Arrow fell into the coproduct arm, which walks children. The arm was a no-op: a callable's parameter and return types were never resolved at all.

A parameter type that is a plain leaf survived that anyway, because a leaf grounds through its own name downstream — which is why the hole stayed invisible. A type application did not: resolve_scrutinee_type_node has an arm for children-present-with-inferred and an arm for no-children, and none for children-present-inferred-absent, so it returns such a node untouched. The receiver reached method lookup with no surface, and the existence wall could decide nothing about it — MethodExistenceUndecided, blocking, against a receiver rendered Node(..).

The arm that separated cause from symptom

Five fixture arms, built from source. The same receiver type reached through an annotated fn parameter compiled with 0 blocking, while the callable-field spelling refused. So the defect is the callable-parameter position, not the lambda binding the diagnostic names — a compiler suggestion locates where a failure was detected, never where it was caused. A non-generic callable field also compiled clean, which is what identifies the failing shape as the type application rather than the callable field as such.

The fix

An Arrow arm in that same dispatch, resolving parameter types and the return type through the one traversal authority the rest of the file uses, at depth + 1 and inheriting masked per resolve_node_bounded_masked_boundary. The rendered-use-site rule resolve_param already applied to a parameterized head — keep the authored head and args, attach the resolved target as inferred — is extracted as rendered_use_site_type so both consume one authority rather than two copies (DESIGN §3).

Measured

Pre-fix binary vs regenerated-mirror post-fix binary:

arm	before	after
armD — callable field, AlgebraL<Payload3>	1 blocking, Node(AlgebraL)	0 blocking
armE — annotated param, same receiver type	0	0 (control unmoved)
armC — declared type is the type variable	1	1 (untouched, see below)
src/v2/compiler/01_tokenize.dag	7 advisory	7 advisory
whole-closure advisory totals	536 / 198	536 / 198

The advisory totals holding is what establishes the fix did not buy its green by widening anything.

What is not repaired — and it is not the same defect

01_tokenize's seven sites are a lambda parameter whose own declared type is the type variable (LexPatternFold's algebra fields, fn(R, R) -> R). Nothing binds R: call_subst accumulates across arguments after each is inferred, and unify_record_lit_generics recovers R from the already-typed record literal — too late for the lambda fields inside it. That renders Primitive() rather than Node(..); this change cannot touch it, and measurement confirms it did not.

Dispatched separately as node://adhoc-b99a2a7b-866. The v2.compiler.tokenize frontier row therefore stays, measured unchanged at seven.

The work item this PR answers asserted one root. That premise was refuted by measurement before any code was written, and repairing the second half would mean a corpus-wide reordering of record-literal field inference in a load-bearing stage — not something the brief authorises. Reported and split rather than improvised.

A wrong mechanism in a live carrier, corrected here

method_existence_wall_note and the unresolved_method_frontier row both blamed "the LexMatchThunk { apply: fn(s) } idiom" for those seven. That is the wrong idiom, and it routes the next reader into repairing the wrong thing: apply: fn(s) declares its parameter String, a leaf, and a non-generic record field holding a callable measures 0 blocking. The seven receivers are left_r/right_r/elem_r/open_r — LexPatternFold's algebra parameters, not s. Upstream defect (2) in the wall note is now recorded as split, with this half fixed and the type-variable half explicitly still open.

Evidence

dag/test/claim/lambda_receiver_type_witness_test.dag, two arms, both PASS on the post-fix binary and both RED on the pre-fix one. Both assert a success that requires resolution to have happened, rather than the absence of a refusal from a wall — a weakened wall cannot make alg.unit produce a conforming type.

Two absent-member arms were designed and rejected by reading the producer, and the note records why:

• MethodNotFound is unreachable — the wall's decidability predicate is kernel_profile_lookup, so a resolved user product still answers MethodExistenceUndecided.
• FieldNotFound is produced only for record-literal unknown fields and pattern bindings, never for field access, which raises an InternalError naming the receiver's authored name — the same string either way.

Both would have been permanently green in the wrong direction, which is worse than absent because they would have been cited as coverage.

Mirror

Regenerated via claim_executor --required-regen, not hand-edited. v1_compiler_infer_resolve.rs shows 1931 changed lines for a ~35-line .dag addition; git diff -w reduces that to 331, and the residue is rustfmt reflow from nesting the existing body one level deeper, plus the Arrow import, the match arm, the new fn and its three call sites. v1_compiler_infer.rs is string data only (the two prose corrections).

🤖 Generated with Claude Code