fix(go): a defined type implements the interfaces its methods satisfy

[colbymchenry]

Summary

goImplementsEdges (Go implicit interface satisfaction, #584; method sets follow embeddings since #2402) offered only structs as implementers. A Go defined type over a slice, map, function or basic type declares methods the same way. It is extracted as a type_alias that owns its methods through contains edges, so it never satisfied an interface:

• prometheus's type staticDiscoverer []*targetgroup.Group (Run) was not a Discoverer, and StaticConfig was not a discovery Config;
• gin's formSource, headerSource and multipartRequest were not a setter;
• etcd's Int64Comparable, StringComparable and the two affine comparables were not a Comparable;
• an adapter like type HandlerFunc func(…) with ServeHTTP was not a Handler.

interfaceOverrideEdges walked only class, struct and union too, so even with the edge a call through the interface could not reach their methods.

• Candidates: Go structs and Go type_alias nodes, read in one canonical (file_path, start_line, id) order. Only types with at least one method enter the per-interface loop. A method-less struct never covered an interface, so struct results are unchanged.
• Cap ordering (fix(go): satisfying an interface counts the methods embedding brings in #2402): a defined type has no embeddings, so it declares every method it has. Under the per-interface cap it ranks with the structs that declare all of the interface's methods, in file order, ahead of structs that need promoted ones.
• Dispatch bridge: interfaceOverrideEdges also walks Go type_alias nodes. The kind is walked for Go only, so nothing changes for other languages' aliases.
• True aliases: type A = B is not extracted as a node, since tree-sitter-go parses it as type_alias, not type_spec. So it can never become a second implementer next to B. The fixture pins that, and none of the 21 = declarations in the three repos is a node.
• A defined type over an interface (type Serving Handler) has no methods of its own and implements nothing.
• Every Go type's embeddings now come from the batched prefetch, which removes the per-defined-type lazy lookups in kindOf and embeds.
• iterateNodesByKindIn accepts several kinds, interleaved in its one order. A single kind keeps the kind = ? query.

Validation

The before arm is main at #2403 (31c3328, which includes #2402). The after arm is this branch. Both use the same kernel, built from that main, and the same extraction, on gin, prometheus and etcd (76d58e3). The same A/B on the earlier base, main at #2400 plus #2402, gave identical after-sets. So did re-runs after merging #2410 and #2411 (main d8a7f86, which changed Go import-name resolution) after merging #2414 (main 855eca2), and on main 3bf6b8f, through #2415 and #2416, which changed framework and Go type-position resolution. With #2414, its promoted-method interface-impl edges are the same with and without this change: 0, 17 and 11.

• The graphs differ only in go-implements edges and the interface-impl calls that follow them. Nodes and unresolved refs are identical.
• The after set matches, edge for edge, an independent simulation of the new rule run over the before graph.

	gin	prometheus	etcd
go-implements	83 → 93 (+10)	1829 → 1866 (+45, −8)	921 → 928 (+7)
interface-impl (Go)	170 → 180 (+10)	3366 → 3437 (+80, −9)	2607 → 2614 (+7)

Added: every added go-implements edge has a defined type as its source. Examples:

• gin: formSource, headerSource and multipartRequest → setter; test types → BindUnmarshaler.
• prometheus: staticDiscoverer and lockStaticDiscoverer → Discoverer, StaticConfig → Config, QueryableFunc → Queryable, Expressions and TestStmt → parser Node, inspector → Visitor, realByteSlice → the three ByteSlices, warningsOnlySeriesSet → genericSeriesSet.
• etcd: the four comparables → Comparable.

Every added interface-impl edge hangs off one of these, for example Discoverer.Run → staticDiscoverer.Run and setter.TrySet → formSource.TrySet.

Removed (prometheus only): each of the 8 is a cap displacement. They are at interfaces that already had more than 40 qualifying implementers, where a defined type earlier in file order now takes the slot:

• Discoverer: robotDiscovery and http Discovery out, staticDiscoverer and lockStaticDiscoverer in. All four are real implementers. The two displaced ones only get Run promoted from *refresh.Discovery, so they had no dispatch edges, and the type hierarchy still lists them one level down under refresh.Discovery.
• TBRun (testing.TB + Run(string, func(*testing.T)) bool): the same two out, the same two in. All four are name-only matches, because the unresolved testing.TB truncates the interface (a known limit since fix(go): satisfying an interface counts the methods embedding brings in #2402).
• BucketIterator, Iterator, StringIter: chunkedSeriesIterator / listSeriesIterator (At() (int64, float64)) out, warningsOnlySeriesSet (At() Labels) in. All are name-only matches.
• genericSeriesSet: blockChunkSeriesSet (At() ChunkSeries, a name-only match) out, warningsOnlySeriesSet (At() Labels, an exact match) in.
• The 9 removed interface-impl edges hang off those.

Precision. Every added pair was checked against the methods' signature text, after dropping parameter names. The rate matches the struct edges in the same graphs, since both sides use the same name-only rule:

	gin	prometheus	etcd
defined types: signatures equal	10 / 10	30 / 45 (7 of them up to a package qualifier)	4 / 7
structs (unchanged): signatures equal	82 / 83	1285 / 1821	522 / 921

The mismatches are the same kind as for structs:

• warningsOnlySeriesSet (At() Labels) also matches SeriesSet, ChunkSeriesSet, BucketIterator, Iterator and StringIter by name.
• etcd's StringsValue, URLsValue and uint32Value have Set(string) error, but flagSetter wants Set(fk, fv string) error. None of its 12 struct matches from before this change has that signature either: seven are flag.Value-style, one is ready.Set(), and four are the v2 store's four-argument Set, two of them promoted.
• prometheus's Selector (Matches(Labels)) matches StringMatcher (Matches(string)), and Annotations and Intervals match unsafeLabelAdder on Add.

Effect on answers:

• codegraph_explore on gin, query mappingByPtr tryToSetValue setter.TrySet formSource.TrySet setByForm. Before, the Flow ended at setter.TrySet. After, it continues through the interface dispatch into an implementation and on to setByForm, and lists the other implementation link.
• Type hierarchy:
  • etcd Comparable: 2 → 6 implementers;
  • gin setter: 0 → 3;
  • prometheus discovery Config: 38 → 39;
  • prometheus Discoverer keeps its 40, now including staticDiscoverer.
• Dead code: the reported lists are identical on all three repos. Fewer symbols reach the exclusion rules as candidates (gin 797 → 789, prometheus 3820 → 3784, etcd 3696 → 3693), because the defined types' interface methods now have callers.

Cost: I timed the pass alone, on graphs with synthesized edges stripped, interleaving the arms, 21 runs each.

• Medians: prometheus 308 → 320 ms, etcd 317 → 357 ms.
• Six more interleaved etcd rounds overlapped (round medians 301–472 ms before, 321–433 ms after). This machine is shared and noisy.
• The extra work is the method reads for the defined types (179 on prometheus, 182 on etcd). The per-interface loop now skips types without methods.

Known limits, unchanged here

• Name-only matching, as for structs (see Precision). 342 of etcd's 921 struct edges differ in arity, which Go never accepts. They are mostly single-method interfaces with common names, like peerGetter.Get and Compactable.Compact. 102 are gRPC server structs matched to the generated *Client interfaces, and those currently bridge RPC flows. An arity check is a separate decision with that trade-off; I filed a follow-up to measure it.
• Methods declared through an alias receiver aren't attached. In prometheus, type KumaSDConfig = SDConfig has 5 methods declared through it, and they stay unattached, so SDConfig misses discovery Config. This is part of the known gap that = aliases are not extracted.
• Promoted methods of type T S, where S is a struct, are not modeled. In Go, T keeps the methods promoted through S's embedded fields. T has no embedding edges here, so it is matched by its own methods only.
• Explore's Flow takes the first-enumerated implementation at an interface dispatch, even when the query names another. On gin it went through headerSource.TrySet although formSource.TrySet was named. This comes from the flow walk itself and applies to struct implementations equally. I filed a follow-up.

Tests

• New __tests__/go-implements-defined-types.test.ts, 6 tests, over a fixture shaped like prometheus discovery, gin binding (with a method in another file), etcd adt, an adapter func type and a generic defined type. It covers:
  • the exact go-implements set;
  • interface-impl to the defined types' methods;
  • the type hierarchy in both directions;
  • a true alias and a defined interface type implementing nothing;
  • the cap taking a defined type in file order with the declaring structs;
  • a sync that renames and restores a defined type's method.
• All 6 fail on main. They pass on both the kernel and the wasm (CODEGRAPH_KERNEL=0) extraction paths, as does fix(go): satisfying an interface counts the methods embedding brings in #2402's go-implements-embedding.test.ts.
• tsc --noEmit is clean.
• Full suite, in parallel on this shared Windows machine with the CPU at 100% from other sessions: 224 failures in 83 files. 214 were timeouts, 2 were Windows EBUSY, and 8 were daemon-lock waits or timing thresholds.
• Those 83 files run serially (--no-file-parallelism, 120 s timeouts): 2081 passed and 4 failed. Each of the 4 was then run alone:
  • mcp-writer-lock and mpeg-ts-not-typescript pass.
  • daemon-pid-reuse passed twice.
  • function-ref's Caller/impact graph misses methods passed as first-class references (callbacks), e.g. executor.submit(obj.method, …) #1820 case passed once and once hit its own 60 s timeout, at 60.7 s. It also passed on main's code. Its fixtures are Python only, so neither go-implements nor the interface-dispatch pass runs in it.
• On the tree merged with main through fix(go): a type in a signature or composite literal links a type, never a method of its name #2416, these pass, run serially: this PR's test file, go-promoted-dispatch, go-implements-embedding, go-interface-embedding, go-type-position-kinds, go-import-package-names, go-framework-own-package and type-hierarchy. On the final merge through fix(sync): a navigation call links its route when the route appears later #2425, the first three and type-hierarchy pass again. sync, sync-import-retry and resolution passed on the earlier merge through test(sync): compare synced graphs with an index rebuilt from scratch #2411.
• dead-code.test.ts passes 31/31 on the wasm path. fix(dead-code): a type that declare module or declare global merges outward is not dead #2418's new declare module cases need a kernel rebuilt from main, and mine was built before that change.

Overlap

#2414 landed first. It also edits interfaceOverrideEdges and turned goImplementsEdges' isEmbedding into the module-level isGoEmbedding(e, kindOf). Here is how the merge resolves:

• isEmbedding stays exactly isGoEmbedding(e, kindOf). Only kindOf changes: it is now a plain read of the prefetched type map, because every Go type is in typeKind up front.
• interfaceOverrideEdges keeps both changes. fix(go): a call through an interface reaches a method the struct gets by embedding #2414's goStruct gate keeps promotion to structs, which is right, since a defined type has no embeddings.

🤖 Generated with Claude Code