* test(go): pin calls through an interface-typed struct field (#2813)
A call through an interface-typed struct field never reaches the
implementation: the CALLS edge stops at the interface DECLARATION, so
`impact()` on the implementing method reports 0 callers. This commit adds
the executable statement of that defect; the fixes follow.
Two stacked defects produce it, and either alone is enough to reproduce —
which is why no existing fixture could observe it:
D1 `buildDetectionIndexes` skips every POINTER-receiver method, so a
struct whose methods are all `func (r *T)` has an empty method set,
structurally satisfies nothing, and gets no IMPLEMENTS edge. Go's
rule is that the method set of *T includes pointer-receiver methods,
and idiomatic Go stores *T in an interface-typed field.
D2 Case 0 (compound receiver) emits its primary edge and short-circuits
without the interface-dispatch fan-out Case 4 performs. A struct
field receiver `s.orderRepo` contains a dot and so always takes
Case 0; a local or parameter receiver is a bare name and reaches
Case 4.
Every implementor in both pre-existing structural-dispatch fixtures uses a
VALUE receiver, and the one pointer-receiver type is pinned as a negative
(`not.toContain('PointerOnlyThing -> PointerOnly')`), so the corpus could
not see D1 by construction. The new fixture is pointer-receiver
throughout, cross-package, and carries concrete-field controls in the same
structs.
Failing-first, verified against this tree: 7 of the 11 new assertions fail
and 4 pass. The 4 that pass are exactly the controls that must not
regress — the primary edge to the interface declaration, the concrete-field
call, the absence of fan-out on a concrete field, and the partial-signature
negative — so the suite discriminates rather than merely failing.
Two recorded artifacts move here because the FIXTURE was added, not
because capture output changed:
- test/fixtures/go-captures-golden/expected-captures.json — regenerated
additively (32 insertions, 0 deletions).
- bench/scope-capture/baselines.json — go fingerprint, fixture_count
102 -> 110.
Both are regenerated in this commit rather than deferred to the end of the
series: the fixture is their only cause, no later commit touches capture
emission, so they cannot re-drift and every commit stays green. The check
that this is corpus growth and not a capture regression is that go was the
only one of 15 language fingerprints to move on the same run.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
* fix(go): count pointer-receiver methods toward structural interface satisfaction (#2813)
D1 of two stacked defects. `buildDetectionIndexes` skipped every method whose
receiver is a pointer, so a struct declaring `func (r *OrderRepo) DeleteItem(...)`
had an EMPTY method set, structurally satisfied nothing, and produced no
IMPLEMENTS edge at all.
Go's method-set rule is per-type, and there are two types involved: the method
set of `T` holds only value-receiver methods, while the method set of `*T` holds
both. #1966 implemented the `T` reading, which is exactly right for `T` — and
leaves `*T` permanently empty. GitNexus models one Struct node per type with no
separate `*T` node, so only one of the two can be represented, and the `T`
reading is the one idiomatic Go almost never uses: methods take pointer
receivers so they can mutate, and `*T` is what gets stored in an interface-typed
field.
The cost was silence rather than caution. With no IMPLEMENTS edge, a call
through an interface-typed field resolved to the interface DECLARATION and
`impact()` on the implementing method returned 0 callers — byte-identical to a
symbol that genuinely has none, which is what made the reporter's blast-radius
check unusable rather than merely incomplete.
This picks the `*T` reading: the graph now answers "which types provide this
interface's behaviour", and no longer proves `var x I = T{}` invalid. The trade
is deliberate and was checked against every consumer of IMPLEMENTS before being
made — MRO/METHOD_IMPLEMENTS derivation, community clustering, the
receiver-dispatch fan-out index, and the epistemic heritage probe. None performs
value-assignability checking.
Two negative pins encoded the #1966 decision and are REVERSED here rather than
deleted, each keeping a comment that explains why the polarity moved:
- go.test.ts: `PointerOnlyThing -> PointerOnly` now expected to be emitted.
- go-hooks.test.ts: the pointer-receiver-only unit case now expects the
implementor instead of `undefined`.
`goReceiverKind` is still stamped in method-owners.ts — it is the hook a future
value/pointer-aware model would read — but is deliberately no longer a filter.
Its now-dead local predicate and type alias are removed so the file no longer
carries a helper asserting the reverted rule.
Measured on the #2813 fixture, this commit alone: the two IMPLEMENTS assertions
flip to passing (6 pass, up from 4) while the five interface-dispatch fan-out
assertions still fail — those are D2, fixed in the next commit. Keeping the two
commits separate is what makes that attribution visible.
Go unit suite: 91 passed.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
* fix(resolution): fan out interface dispatch from a compound receiver (#2813)
D2 of two stacked defects, and the one that closes the issue. Case 0
(compound receiver) emitted its primary edge and short-circuited without the
interface-dispatch fan-out that Case 4 performs, so a call whose receiver is a
struct FIELD stopped at the interface's method DECLARATION and never reached
any implementation.
The gap was a property of receiver SYNTAX rather than of types. Case 0 is
selected by `receiverName.includes('.')`, so a field receiver (`s.orderRepo`)
always lands there, while the very same interface reached through a local or a
parameter is a bare name and falls through to Case 4 — which fans out
correctly. Field-held interfaces, i.e. dependency injection, were the half that
silently lost every implementation edge; the pre-existing fixtures exercise the
local and parameter forms only, which is why the suite was green.
The fix is the call Case 4 already makes, placed after Case 0's primary
`tryEmitEdge` and before its `handledSites.add`. It stays language-agnostic
(AGENTS.md section 42): `emitInterfaceDispatchFor` self-gates on
`ownerDef.type !== 'Interface'`, so a receiver that folds to a Struct emits
nothing extra and no language check is needed. Confidence is Case 0's own 0.85
literal, not Case 4's site.kind-dependent value — Case 0 has no read/write arm
to mirror.
The case ladder itself is untouched: invariant I4 in contract/scope-resolver.ts
makes the ordering a contract, so the fan-out is added INSIDE Case 0 rather
than by reordering or merging cases.
Also flips a second, previously unnoticed encoding of the #1966 value-only
reading that the full sweep surfaced: the exact-set assertion at
go.test.ts:361 enumerates every structural IMPLEMENTS edge, and D1 correctly
adds `PointerOnlyThing -> PointerOnly` to it. It is D1 fallout rather than D2's,
but D1 had already landed; recording it here with its reason beats amending a
commit whose separate measurability is the point.
Measured:
- #2813 suite: 11 of 11 pass (was 7 failing after D1 alone, which fixed only
the two IMPLEMENTS rows).
- go.test.ts: 160 passed.
- Full cross-language sweep, test/integration/resolvers: 3027 passed,
1 skipped, across 52 files. The single failure in that run was the
exact-set assertion above, fixed here; no other language regressed.
`detect_changes` rates this HIGH (6 affected flows, all EmitReceiverBoundCalls
at step 1) — inherent to editing a hub symbol in the resolution pipeline. The
sweep above is the empirical answer to that label.
An existing index must be re-analyzed to show the new edges; this changes what
the resolver produces, not how it is stored, so no SCHEMA_BUMP applies.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
* test(go): pin the heritage edges that make impact() hedge an interface-bound count (#2813)
The epistemic half of the issue, resolved by MEASUREMENT rather than by new
code, and pinned at its mechanism.
The reporter's disqualifying complaint was that `impact()` reported
`impactedCount 0, epistemic "exact", risk LOW` for a method reachable only
through an interface-typed field — byte-identical to what it reports for a
symbol that genuinely has no callers. A zero therefore could not be used
defensively, which was the entire use case.
That verdict comes from `computeEpistemicBoundary`, which has two producers and
neither fired: the call sites were not DROPPED (they resolved, just to the
interface declaration, so the #2744 receiver-typing producer saw nothing), and
its heritage probe walks IMPLEMENTS/METHOD_IMPLEMENTS edges out of the queried
symbol — of which there were none, because the pointer-receiver exclusion (D1)
meant no such edge was ever emitted.
Restoring those edges fixes the epistemics as a side effect, so the planned
conditional change to local-backend.ts is NOT needed. Measured on this fixture
against the fixed tree:
impact(OrderRepo.DeleteItem, upstream)
before: impactedCount 0, epistemic "exact"
after: impactedCount 3, epistemic "lower-bound", with an interface
boundary note; the three callers are OrderHandlers.Delete,
PickService.StartSession and WaveService.Release — all correct.
impact(CartRepo.Get, upstream) [concrete receiver, no interface]
after: impactedCount 1, epistemic "exact"
The second row is the one that matters for trust: the hedge discriminates
instead of firing on everything, so "exact" still means exact.
This test asserts the METHOD_IMPLEMENTS edges the probe walks. Pinning the
mechanism keeps the resolver suite from reaching into the MCP layer while still
failing loudly if the edges regress; the impact() numbers above are recorded in
the commit message and PR body rather than re-asserted here.
#2813 suite: 12 passed.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
* fix(go): model Go method sets exactly so interface satisfaction is decidable (#2813)
Replaces the approximate structural-interface model with the rules the Go spec
actually defines, so the graph answers what the compiler answers instead of a
useful-but-wrong summary of it. Three answers were provably wrong before; all
three are now exact and covered.
Method sets (go.dev/ref/spec#Method_sets):
MS(T) = methods declared with receiver T
MS(*T) = methods declared with receiver *T OR T
Promotion (#Struct_types):
S embeds T -> MS(S) and MS(*S) get promoted methods with receiver T;
MS(*S) ALSO gets those with receiver *T
S embeds *T -> MS(S) AND MS(*S) both get receiver T or *T
Identifier identity (#Uniqueness_of_identifiers): "Two identifiers are different
if they are spelled differently, OR IF THEY APPEAR IN DIFFERENT PACKAGES AND ARE
NOT EXPORTED."
func (b *Base) Ping() // pointer receiver
type ByValue struct{ Base }
type ByPointer struct{ *Base }
type before exact answer
Base IMPLEMENTS only *Base implements
ByValue IMPLEMENTS only *ByValue implements
ByPointer IMPLEMENTS the VALUE type implements
All three were the same edge. Two of the three were wrong, and nothing in the
graph could tell them apart.
Worse, in a different direction:
package sealed; type Sealed interface { seal() }
package foreign; func (t *T) seal() {}
`foreign.T` cannot implement `sealed.Sealed` in Go — `seal` is unexported, so the
two identifiers are DIFFERENT. Matching on the bare name emitted a FALSE
IMPLEMENTS edge, and the interface-dispatch fan-out then turned it into an
impossible CALLS edge. That is the entire basis of the sealed-interface idiom.
- `methodSetKey` qualifies UNEXPORTED method names with their declaring package,
leaving exported names unqualified (which is what makes cross-package
satisfaction work at all). Exactness, not a heuristic: the sealed case now
emits no edge, while the legitimate same-package implementor is retained.
- `collectStructMethodEntries` builds MS(T) and MS(*T) together and applies the
promotion table above. The embed FORM is load-bearing, so it is now captured:
`@reference.embedded-pointer` records `*T` versus `T`, which the parser
previously discarded (the `*` is an unnamed token).
- Detection returns `{ structDefId, receiverForm }`. `receiverForm: 'pointer'`
means the value type does NOT implement and only `*T` does — the fact
`var x I = T{}` turns on.
- The form rides in the edge `reason` (`-structural-implements-pointer`).
Relationships carry no arbitrary properties, so a new field would change the
relation DDL, move SCHEMA_FINGERPRINT and force a rebuild for a fact a string
already expresses. Value-form implementors keep the ORIGINAL unsuffixed
reason, so a consumer matching the old string now sees exactly the assignable
set — which is what that string always claimed to mean.
- `emitInterfaceDispatchFor` walks the SUBTYPE CLOSURE (IMPLEMENTS + EXTENDS) and
skips bodiless declarations, instead of stopping at depth 1. Two reproduced
Java shapes emitted an edge to a second abstract declaration while the only
class with a body got nothing: a sub-interface that re-declares the method, and
an abstract base between interface and implementation. Both now reach the
implementation and neither emits the declaration edge.
- The fan-out is bounded by `MAX_INTERFACE_DISPATCH_FANOUT` (32,
`GITNEXUS_MAX_INTERFACE_DISPATCH_FANOUT`) and reports what it dropped, mirroring
`MAX_PROPERTY_DISPATCH_FANOUT`. A bare cap would silently discard valid dispatch
targets, which is the same false-safe silence this issue is about.
- Corrects a rationale comment that was factually wrong about the code 70 lines
above it (Case 0 DOES branch on `site.kind`, at :713-716; what it lacks is a
read/write branch in its reason/confidence computation).
- Updates both copies of the case-ladder contract, which still described the
fan-out as Case-4-exclusive.
The embed-pointer marker is PARSE-TIME capture emission, so a warm cache would
replay the pre-marker capture set and the distinction would never appear —
silently, the v27/v30 failure mode. 43 and not 40 because origin/main allocated
40, 41 and 42 while this branch was in review, which is exactly the window this
file's history records both prior EXACT clashes landing in. Pin moved with it.
RE-CHECK AGAINST origin/main IMMEDIATELY BEFORE MERGE.
- Go unit: 93 passed, including new rows pinning that `populateGoOwners` stamps
`goReceiverKind` (previously the field had no reader and could rot silently)
and that a pointer-receiver-only type implements in POINTER form only.
- Cross-language sweep, test/integration/resolvers: 3034 passed, 1 skipped,
52 files, zero regressions.
- scope-capture bench: PASS (15 languages). Go is the ONLY fingerprint that
moved, which is the check that this is a Go capture change and not a
cross-language regression; rebaselined with rationale.
- Also closes review gaps in this PR's own tests: the concrete-field control was
vacuous with respect to the type gate (repointed at a struct that IS an
implementor), the two-service-file row could not distinguish the two files it
is named for (both ends now file-qualified), plus new rows for signature
mismatch, emitted confidence, and an exact N-by-M fan-out bound.
An existing index must be re-analyzed; the schema bump forces it.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---------
Co-authored-by: Gergo Magyar <gergomagyar0@gmail.com>
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
cabd5b82f9