[colbymchenry]

Problem

A Go call x.M() resolves through x's declared type when receiver inference can read it. The line patterns behind inferLocalReceiverType read a parameter's type only when it is a lowercase name of the caller's own package (s *server) or starts with a capital (lg Logger). So a parameter declared through a package — client rest.Interface, c clock.PassiveClock, pod *v1.Pod, w http.ResponseWriter — had no type. The scope reader (#2448) knows every one of these declarations, but only two paths asked it: standard method names (#2664) and receivers named like an import (#2448). Every other call fell to the name strategies:

• client.Patch(…) on a rest.Interface parameter went to RESTClient::Patch by a shared word (0.65), not the interface's method.
• c.Now() on a clock.PassiveClock went to apimachinery's unrelated Clock::Now.
• 44,750 kubernetes calls on a t *testing.T (t.Errorf, t.Run, t.Fatalf, …) went to three test-helper interfaces named T, by capitalizing the receiver's name (0.8).
• A local or var the patterns did type as an outside type looked the type's name up across the project: prometheus's pool := sync.Pool{…} reached chunkenc's Pool::Get, etcd's cc := &http.Client{} reached KV::Do and a kubernetes client's Client::Get, all at 0.9.
• The patterns scan back with no block scope, so they can read another declaration of the name: in prometheus d.Run(…) inside a closure taking d discovery.Discoverer became a self-call of the enclosing (d *Discovery) Run.

What changed

Resolver only (src/resolution/name-matcher.ts); extraction and the kernel are untouched.

• inferLocalReceiverType asks the scope reader first for every Go receiver. A declaration in scope that writes a named type — a parameter, a result, either name of a, b rest.Interface, a var (…) spec, a function literal's parameter — gives that type (GoReceiverDecl.declared), ahead of the patterns. A type literal (interface{ Errorf(…) }, []T, func(…)) gives null. A declaration with no written type leaves the patterns to run as before.
• matchMethodCall, matchMemberFunctionRef (method values) and matchGoFieldChainCall (x.field.M()) all use it:
  • a project type resolves in the package that declares it, through embedding and aliases (resolveGoMethodInPackage);
  • a type from outside the project, a predeclared type, or an alias of either (goHasNoProjectMethods, built on goWrittenType) reaches none of the project's methods, and neither does a type literal;
  • a qualifier none of the file's imports names, as indexed, can't be told, and keeps the lookup by name it had.
• Standard method names keep fix(go): a call of a standard method name like err.Error() links to its receiver's declared type, never to one it shares a word with #2664's rules unchanged (a declared type lacking the method gives no edge, an outside package's value gives none). Any other name the declared project type lacks goes on to the name strategies, as a call on a receiver of unread type does.
• A field chain's field typed as an alias of an outside type is skipped as an outside one is.
• fix(go): a dotted call is written through its own receiver, and a local named like an import is that variable #2448's block in matchMethodCall that typed only receivers named like an import is subsumed and removed, with the declaredType field it read.

Validation

Tests. New __tests__/go-declared-receiver.test.ts, 7 tests. With main's resolver (8beab37) 6 of them fail. The seventh passes there and pins what must not change: a shadowing s := decoy.New() in an inner block is not typed through the parameter. Calls of standard method names on outside types (w.Header()), which #2664 already handles, are kept as guards inside the outside-type tests. Cases:

• typed through a project package: a single parameter, each of a grouped pair, a multi-line parameter list, a named result, a var (…) spec, a function literal's parameter, embedding, an alias, a method value, a field chain;
• the declaration in scope wins over a test table's field the patterns read above it;
• outside types reach nothing: http.ResponseWriter beside a project ResponseWriter (gin's case), *http.Request beside a project Worker::WithContext, clock.PassiveClock beside a project Clock, context.Context and an alias of it beside a struct Ctx, var rw http.ResponseWriter, cl := &http.Client{}, a method value of an outside type.

One existing expectation moves: #2664's go-std-method-receivers test pinned query.Exec() through var ( query promql.Query ) at the 0.8 guess. The same Query::Exec is now typed at 0.9 by that declaration, and the second commit updates the expectation.

Full suite on this tree (Windows, native kernel, CODEGRAPH_KERNEL_EXPECT=1, --maxWorkers=4 --minWorkers=1, other sessions' suites running at 100% CPU): 7,682 tests, 7,324 passed, 234 failed, 124 skipped. The 234 failures sit in 61 files: timeouts at the 5 s default, Windows file locks (EBUSY, EEXIST on a symlink), spawnSync git ENOENT, timing thresholds (2789 < 2000), and the expectation above. Rerunning those 61 files with --maxWorkers=3 and 180 s timeouts: 2,016 tests, 2,000 passed, 0 failed, 16 skipped. tsc passes.

Before / after. Full index of each repo with main 5530676 and this change on it, native kernel, same kernel binary. The branch was then synced with main 8beab37, which adds #1925 (agent-eval script), #1962 (docs) and #2592 (JS/TS bare calls; Go's reading is unchanged), none of them in Go resolution. Natural-key edge diff with vendor/ excluded; a site is (caller, line, column, edge kind).

repo	commit	edges main → branch	sites dropped	added	moved	same target, now typed
gin	0f09c3a	7,992 → 7,933	63	4	0	1
prometheus	50321cc	103,523 → 104,039	189	705	64	309
etcd	6782f52	67,253 → 67,306	395	448	154	380
harbor	dc64f3b	102,879 → 102,781	218	120	16	56
kubernetes	c905fdd	1,282,384 → 1,244,489	47,150	9,255	2,685	11,773

Nodes are identical in every repo. Controls: express 0dee2c5 (JS: 1,135 nodes, 2,256 edges, 8,947 unresolved refs) and flask d086db8 (Python: 2,736 / 4,940 / 3,704) are byte-identical on both arms, compared by natural key.

Every changed site was classified by its receiver's declaration as the branch's scope reader reads it, independently of the resolver's verdict (a copy of the branch's build that exports goLocalDecl), and by the package that declares the type, read from go.mod files and the file's imports:

• Added, moved and confirmed (typed) sites: all are declared with a project type. The branch's target was checked mechanically: for 22,379 typed sites (all repos) the target's owner is the declared type and it lives in that type's package. The rest were read in groups:
  • another owner (965): interface or struct embedding — storage.Appender → HistogramAppender::AppendHistogram, mvcc.TxnWrite → WriteView::DeleteRange, cmdutil.Factory → RESTClientGetter::ToRawKubeConfigLoader, v1.PersistentVolumeClaim → ObjectMeta::SetOwnerReferences;
  • same type name in another package (793): aliases (type Event = mvccpb.Event, harbor's Quota = models.Quota) and same-named embeddings (client-go's ktesting.TContext embeds k8s.io/ktesting's, harbor's controller Artifact embeds pkg/artifact.Artifact);
  • field chains at 0.85 (1,804): f.ClientSet.CoreV1() → Interface::CoreV1, chunk.Chunk.Bytes();
  • 29 kubernetes sites through an import the triage's own simpler reader didn't name (k8s.io/mount-utils as mount), read by hand: all right, like v1.Taint → the API's Taint::MatchTaint instead of the internal pkg/apis/core copy.
    On main the moved sites were guesses into concrete implementations or namesakes: etcd's txnReadWrite::DeleteRange for an mvcc.TxnWrite, prometheus's StringIter::At for a chunks.Iterator, kubernetes' internal pkg/apis/core Taint::MatchTaint for a v1.Taint.
• Dropped sites (48,015): 47,883 have a receiver declared with a type from outside the project, or an alias of one. On main they were guesses onto a project type that shares a name or a word:
  • kubernetes: 44,750 *testing.T calls → test-helper T interfaces; 821 klog.Logger calls → etcd3's klogWrapper; 419 flag/pflag.FlagSet calls → component-base's flagSet; 173 more *testing.T → TContext; *http.Client locals → client-go's HTTPClient and storageversion's Client; 42 testingclock.FakeClock → a struct named fakeClock;
  • harbor: 176 *http.Request calls (r.Context() → BaseAPI::Context, r.WithContext() → Worker::WithContext), &http.Client{} locals → common/http.Client;
  • etcd: testing.TB → its own look-alike TB, &http.Client{} → KV::Do, gRPC stream aliases (type Lease_LeaseKeepAliveServer = grpc.BidiStreamingServer[…]) → chanStream::Context;
  • prometheus: *testing.B → TestSuite::Fail, t.Skip → Decbuf::Skip, sync.Pool → Pool::Get;
  • gin: t.Run on *testing.T → Engine::Run, pb.Next on *testing.PB → Context::Next.
    The 132 others: 94 method values through a project type that has no method of that name, which main linked to a function named like the member. 88 read a field the type declares (e.Without on a *parser.AggregateExpr, ckv.CreateRevision on a mvccpb.KeyValue); 6 read a field of a go-swagger type harbor generates at build time (params.WithTag, model.AuthMode); 26 calls through an anonymous interface parameter (t interface{ Helper(); Errorf(…) }) that main sent to a T; 4 PodsClient calls whose interface is in a generated file the index skips (main reached unrelated types); one closure parameter whose GetName comes from an embedded outside klog.KMetadata; and the 7 runtime.Codec calls under Limits.
  • Arguable: 613 dropped sites (kubernetes 394, etcd 177, gin 20, harbor 15, prometheus 7) are calls through a well-known interface from outside the project, or an alias of one: testing.TB, context.Context, io.Writer, http.Handler, gRPC stream aliases. Most of main's targets there are look-alikes (etcd's own TB interface), but some project types implement the interface and may be what runs: context.Context → mergeCtx, http.RoundTripper → uncancellableRT, net.Conn → grpcConn, gRPC streams → stream adapters, gin's http.FileSystem → OnlyFilesFS. The declared type is an outside interface, so the call gets no edge, as ctx.Done() already does for a standard method name.

Cost. No measurable change, on a box at 100% CPU with other sessions' suites running:

repo	runs	CPU main	CPU branch
etcd	3 interleaved, median	57.3 s	57.3 s
harbor	3 interleaved, median	92.7 s (92.1–98.8)	93.6 s (89.6–94.7)
kubernetes	1 pair	773.7 s	777.1 s

CPU is the indexing process plus its child, all threads. The branch asks the scope reader for every Go receiver, but main already built its per-file index for nearly every Go file, through the standard-method-name path. CPU profiles of one etcd index per arm (every thread) put the scope reader's functions at 444 ms on main and 427 ms on the branch. The new lookups and goHasNoProjectMethods add about 70 ms, offset by less time in the line patterns and the name strategies: the watched functions total 901 ms vs 857 ms of 165–175 s sampled.

Limits and follow-ups

• A type defined over an interface (type Codec Serializer) has the interface's methods, but the resolver doesn't give them to it. codec.Encode(…) on a runtime.Codec parameter now gets no edge in 7 kubernetes sites where main reached the versioning codec struct, which implements it, because the receiver shares that struct's name. fix(go): a call on a package-level variable or constant links through the type it is declared with #2667 left this gap by choice for package-level values. It is not proposed as a follow-up here either: kubernetes declares 4 such types (runtime.Codec, meta.List, meta.Type, one code-generator test type), and these 7 sites are the only ones in the five repos this change moves.
• Calls through an outside interface that a project type implements lose main's guesses (above). Linking them would need interface-impl edges from outside interfaces, which have no nodes.
• A := local whose value comes from a call (r := newRing()) is still not typed by its callee's result; fix(go): type receivers from package-qualified parameters and call results; no guess for outside types #1954 does that, among other things.

Overlap

PR #1954 (@danusha2345, open) types package-qualified parameters by extending the line pattern and stops outside types for every method name. This PR does both through the scope reader instead, which also reads grouped names, var (…) blocks and function literal parameters, and won't take a test table's field or an outer variable for the receiver. That misreading is the risk the #2664 session recorded for #1954's stop. #1954's call-result typing (x := f()) remains its own; the two touch the same lines of matchMethodCall. The CHANGELOG bullet thanks @danusha2345. Closing or reworking #1954 is the maintainer's call.

🤖 Generated with Claude Code