Propagate the PartialEq bound one hop up the call graph: the caller that forwards its own generic param into a comparing callee emitted a program that does not typecheck

[gunbai-bot]

Unblocks #8605's regen. Orphaned lane (swift-moth-294 no longer exists), picked up here.

The gap

#8699 landed the seed's equality bound correctly, but only for the function whose own body compares. That is not the whole rule. Once fn callee<K> carries K: PartialEq, every caller instantiating that K with its own generic param is obliged by rustc to prove a bound it never states — so the seed emits a program that does not typecheck, and the E0277 lands on a function whose body compares nothing.

Measured on the real specimen, #8605's std.trait_derive_shape:

symbol	before
repr_grounding_derive_shape_has_trait<K> (compares k == capability_key)	<K: Clone + PartialEq> ✅
repr_grounding_derive_completeness_predicate<K> (forwards its own K into that parameter)	<K: Clone> ❌ E0277

What changed

• The per-(callee param, call argument) join the Clone forwarding already performed is factored out as v1_call_forwarding_forwarded_param_names and is trait-agnostic: the only thing separating Clone from equality was which of the callee's generic params already earned a bound, and that now arrives as callee_bound_param_names. Forking it per trait would be a second representation of one fact about a call site (§3).
• v1_call_forwarding_equality_bound_param_names re-derives the callee's own equality bound with the same derivation emit_fn_def runs on itself (§2), then forwards it.
• Its walk is recursive where the Clone half's is direct, and that is a difference in the specimens, not in taste: the forwarded call here sits inside a lambda inside a pipelined all(), which the direct-shape lookup structurally cannot reach. Pointing the Clone half at this walk would widen which functions receive a Clone bound corpus-wide — that is the next-rung trigger BoundedToDirectSingleCallLambdaBody already names, measured on its own regen, not smuggled in beside an equality fix.
• One hop, declared. A bound earned only two hops up is discovered as each intermediate fn is itself re-emitted, exactly as the Clone half's note describes.
• Cost shape (§6): a fn with no type params of its own can never receive a forwarded bound, so the (caller node × callee body) product is refused at the door rather than computed and discarded.

§3 renames

The shared core is no longer about Clone:

v1_call_forwarding_clone_bound_wrapper_param_names -> v1_call_forwarding_bound_wrapper_param_names
v1_union_clone_param_names                         -> v1_union_bound_param_names

Prose citations of v1_call_forwarding_clone_bound_wrapper_param_name — a symbol that never existed under that spelling — are corrected to the real one.

A real defect the first green surfaced

v1_union_bound_param_names filtered extra against base only, so a name repeated within extra survived twice. Latent while the sole consumer was Clone, whose renderer keys a map by param name and absorbs the repeat; the equality bound concatenates onto that param's trait list, and the first emission produced K: Clone + PartialEq + PartialEq — one call site forwarding the same wrapper param through two callee parameters (a bare K and a CapRow<K>). Fixed at the head: a union is duplicate-free in both directions, so no consumer has to know whether the result can repeat.

Test plan — green by execution, with a discriminating red

• Reduction emitted through the seed before the fix: pub fn cap_table_complete<K: Clone>. After: pub fn cap_table_complete<K: Clone + PartialEq>. That measured pre-fix spelling is what the new witness refuses, rather than merely asserting the fixed one is present.
• The real B1: capability-keyed sharing contract — one open key brand in std, Rust rows in extdeps, closed alphabet re-homed to keep spelling total #8605 specimen, its trait_derive_shape.dag emitted through this seed: pub fn repr_grounding_derive_completeness_predicate<K: Clone + PartialEq>.
• Two new rows in dag/test/claim/fn_equality_bound_witness_test.dag, both green via gunbc run --claim-run, alongside Emit a PartialEq bound on the generic parameter a fn body compares: generalize the type-param renderer from Clone-only to a per-parameter trait map #8699's two rows which stay green. The negative row is the discriminator — same wrapper shape, same generic param, same pipeline, but a callee comparing only concrete types; a derivation keyed on "my callee is generic" bounds K there and breaks every caller instantiating K with a non-PartialEq type. Measured bare: pub fn cap_table_shape_is<K: Clone>.
• claim_executor --required-regen: first_generation_equal=true planned=129 executed=129 after installing the re-derived mirrors (three generations: emit_rust, then trait_bound_witness, then fixed).
• cargo fmt --all --check clean; cargo build --release clean.

🤖 Generated with Claude Code