[colbymchenry]

Summary

Issue #2614 reported four Rust call shapes that linked to a same-named project method. Case 1 (names.contains(&k) on a slice) was already fixed on main by the typed-receiver work (#2715). This PR fixes the other three, which still reproduced on main 5b47bc4 in both engines:

case	call	main	this PR
2	vis.map.get("a"), map: HashMap<String, i32>	Ext::get (exact-match 0.9)	no edge
3	J::from(i) under use serde_json::Value as J	Fail::from (instance-method 0.7)	no edge
4	Xyz { x: 1.0 }.to_val()	Stat::to_val (exact-match 0.4)	Xyz::to_val (instance-method 0.9)

Stat { n: 0.0 }.to_val() in the issue's main keeps its target, now resolved by type (0.9) instead of a 0.4 name guess. Kernel and wasm give identical results on the issue's crate.

Root cause

• Cases 2 and 4. The extractor keeps one receiver level on a call (x.m, self.m, self.field.m). A deeper field chain (vis.map.get, self.a.b.m, self.0.m) or a struct literal (Xyz { … }.to_val()) reaches the resolver as the bare method name. The typed-receiver reading from fix(rust): a call on a local reaches the method of the type it is declared with #2715–fix(rust): a call on a field of self reaches the method of the field's declared type #2719 only ran for ident.method and self.field.method refs, so these went to the name strategies: get had one project method (Ext::get, an associated fn at that), and to_val had two trait impls, picked by proximity.
• Case 3. J::from matched no qualified name. J names no project type, so Strategy 1 found nothing, and a single capital letter slips past namesExternalType, which reads it as a possible generic parameter. Strategy 3 then took the crate's one from. The same family: under an unrenamed use serde_json::Value, Value::default() linked by qualified name (0.95) to a project Value's impl Default.

Fix

• matchRustWrittenReceiverCall, an exclusive hook beside matchRustAsMutChainCall. For a bare-named Rust call, it reads the call's receiver from the text at the ref's column.

  • Only two receiver shapes are read: a field chain rooted at a local, a parameter or self, and a struct literal (alone or in parentheses).
  • The receiver is typed with the existing rustValueType, and the call is resolved with rustTypedMethodCall, as a typed local's call is.
  • These are left to the name strategies as before:
    • any other receiver (a call's value, an index, a macro);
    • a receiver whose type can't be read;
    • a type no node names, such as one a macro declares (tokio's type AtomicUnsignedShort = … inside cfg_has_atomic_u64! { });
    • a later link of the same chain that calls the same name again (m.a.get(k).get(j)), since the two refs share a position.
  • When the type has no such method, a provided method of a project trait that the type #[derive]s, and that is in scope, counts. The derive writes the impl, which the index doesn't hold (axum-extra's #[derive(TypedPath)] → with_query_params).

• rustFieldValue now also reads an element of a tuple-typed field (self.pair.0 on pair: (Config, u8)), using the existing rustTupleField.

• isRustPathCallReachable, in gateRustScope beside isRustForeignImplCallable. A call through a type path whose type the file's use, or the written path, names from std or a dependency reaches only:

  • the project's own impl of a trait for that type (impl Blank for serde_json::Value, impl From<Fail> for PathBuf), or
  • for a trait's path (W::flush(s) under use std::io::Write as W), the project's impls of that trait.

  A path dependency the project holds counts as the project's.

This is a resolver-only change: extraction is unchanged, so the kernel needs no mirror (see parity below).

Validation

Tests. The new __tests__/rust-written-receivers.test.ts (12 tests) covers the issue's crate verbatim and field-chain, struct-literal, derive and path variants. It also has guards for what must keep resolving: the project's impl From<Fail> for PathBuf, impl Blank for serde_json::Value, and W::flush(s) under use std::io::Write as W.

• Red→green: with main's name-matcher.ts and index.ts swapped back in, 9 of the 12 fail (the 3 guards pass on both); with the fix, all 12 pass.
• The 27 Rust test files, resolution and cross-language-resolution pass (416 tests).
• Full suite on this commit (98a4337, kernel rebuilt from it, CODEGRAPH_KERNEL_EXPECT=1): 739 of 746 files passed and 6 were skipped; 8,844 tests passed and 82 were skipped. The one failure was daemon-lock-holder.test.ts › "reads a running process from the OS", which reads the OS process table and passed 11/11 when rerun alone.

A/B against main 5b47bc4. Both arms were built from that sha with the native kernel on, and calls edges were diffed by call site. Each change was triaged by reading the receiver's declaration (or, for a path, the file's use):

repo (commit)	.rs files	wrong links removed	right links added	wrong → right	same target, now by type	right links lost
ripgrep (3fce3b5b)	110	30	18	10	37	0
tokio (17638a0d)	814	281	58	54	141	0
axum (86aa6153)	302	18	7	0	7	0
rust-analyzer (0c4d7468), parser test data excluded	951	737	186 (+2 wrong, below)	434	843	0

How each repo was checked:

• On ripgrep, tokio and axum, every changed site was read.
• On rust-analyzer, all 289 path removals were checked against their file's use. For the 448 bare removals, all 99 sites in small groups were read, plus one sample from each of the 45 larger groups (349 sites).
• Every group of rust-analyzer's additions (70) and retargets (124) was sampled.
• Nodes are identical between arms on every repo, since extraction is unchanged.
• Controls: gin (Go, 99 files) and express (JS, 141 files) have byte-identical full natural-key dumps.

What moved:

• Removed: std or dependency calls that had landed on project namesakes.
  • File::open → MmapChoice::open, and a HashMap field's get → ContextModeLimited::get.
  • tokio test and bench files that use std::sync::Mutex / std::sync::atomic::AtomicUsize / std::time::Instant had been linked to tokio's own loom shims and time::Instant; std atomic fields went to loom's mutex-backed AtomicU64::store.
  • rust-analyzer's real std::ops::ControlFlow uses had gone to the fake core in test-utils/src/minicore.rs, and lsp_types::Position::new to a project Position.
  • tungstenite's Message::Text had gone to axum's own.
• Added / retargeted: field chains now reach their declared type. Examples:
  • args.mode.update(…) → Mode::update, and tokio's split halves' self.0.peer_addr() → TcpStream::peer_addr;
  • 20 with_mut calls on loom UnsafeCell fields, which had gone to AtomicUsize::with_mut;
  • rust-analyzer's snap.analysis.hover(…), which had gone to Config::hover;
  • struct literals such as ParamEnvAndCrate { … }.store() and CommentKind { … }.prefix().
• Two wrong links added (rust-analyzer): d.message.clone() on a message: String field links to syntax's ast::String::clone. The struct's file has const _: () = { use syntax::ast::*; … }, and the existing glob lookup (rustGlobItems, from fix(rust): a name a glob use brings in is an item the globbed module passes on #2714) reads that block-local glob as file-wide. Typed locals in such a file already misread String the same way on main. Making glob scope position-aware is a change to shared lookup, so I left it for a follow-up rather than widen this PR.
• Two refinements came out of this triage:
  • An earlier draft ruled out calls on a field typed by a macro-declared alias, losing 5 right unsync_load links on tokio. A type no node names is now left to the name strategies.
  • The derive rule recovers axum-extra's UsersShow { … }.with_query_params(…) and adds Named { id: 1 }.to_uri().

Kernel parity (Rust): scripts/kernel-parity.mjs on ripgrep, tokio and axum gives 1226/1226 files at byte-parity, 0 deferred.

Cost. Interleaved, median of 3: ripgrep 6.7 s → 6.5 s, tokio 20.2 s → 20.8 s. The box was under heavy external load. A CPU profile of tokio puts about 0.27 s of 57 s busy CPU in the new functions and the shared typed reading they call; the rest of the run-to-run difference was spread evenly over code this change doesn't touch.

Rebase. The branch was rebased onto dcb985f (#2827, Ruby only). Re-indexing ripgrep, tokio, axum and rust-analyzer with the rebased build gives edge dumps identical to the pre-rebase fix arm.

Fixes #2614

Contributor PR #2625 (@danusha2345) was read for guidance: its struct-literal reading and its use-alias check for outside types shaped this fix. This PR builds on main's later typed-receiver reading instead of a separate declaration reader.

Left out (none are in the issue):

• A tuple-struct construction as a receiver (Wrapper(x).m()), and a call on a method call's value inside a chain (a.b().m()), still go to the name strategies.
• A renamed use of a project type (use crate::config::Config as Cfg; Cfg::load()) is unchanged (unresolved, as on main).
• Two gaps in the shared typed reading surfaced during triage, and are left for follow-ups:
  • the block-scoped glob above;
  • a trait impl written for a type alias (impl HirDisplayWithExpressionStore for TypeRefId, type TypeRefId = Idx<TypeRef>), which isn't found through the alias. Three rust-analyzer hir_fmt calls there now link nothing; they previously linked to unrelated types.

🤖 Generated with Claude Code