fix(rust): resolve paths into other crates of a Cargo workspace by BGamboa13 · Pull Request #2631 · colbymchenry/codegraph

BGamboa13 · 2026-10-17T13:13:52Z

fix(rust): resolve paths into other crates of a Cargo workspace

Problem

In a Cargo workspace, a call written with its path into another crate never connects. Only a bare imported name resolved (through the name matcher), so callers, impact and codegraph_explore miss most cross-crate uses.

// crates/sim/src/items.rs
impl ItemPool { pub fn for_def(..) {} }

// crates/server/src/shop.rs   (server depends on sim)
use sim::items::ItemPool;
fn buy() { ItemPool::for_def(..); }          // also: sim::items::ItemPool::for_def(..)

Before: codegraph callers for_def returns 1 caller (a test inside sim) while git grep finds 8 sites in crates/server. After: 9.

Causes: the Rust path resolver required every segment but the leaf to be a module file (so Type::method tails failed); a first segment that is a workspace crate name was never mapped to that crate's src; pub const/static (extracted as variable) were not accepted as leaves; crate::x / super::x with no module segments resolved to no file; pub use re-exports were not followed; and a use sim::items::ItemPool; binding was not used to expand ItemPool::for_def, so a same-named type in another crate won.

What changes

New src/resolution/rust-paths.ts (the Rust path code moves out of import-resolver.ts): walks the module tree from the path's anchor (crate, self, super, a workspace crate name, or the file's use binding) to an item or a Type::member, following pub use and glob re-exports; accepts constants/statics and enum variants as leaves.
frameworks/cargo-workspace.ts: Cargo path dependencies (renamed keys, non-member paths) map to their crate directory. A dependency key that two crates bind to different directories is left unresolved instead of picking one.
A module-qualified type (scheduler::Handle) resolves by its own written path (read back from the source, across lines, comments ignored) before any same-named use binding.
Resolution only ever returns a node the path actually names; anything it cannot place is left unresolved (unresolved over wrong).

No extraction change; EXTRACTION_VERSION untouched (main is already at the unreleased 28). Existing indexes pick it up on re-index.

Precision evidence

Hand-checked random samples of the new edges against source (seeded, stratified by fix class; per-edge tables kept):

repo	sample	true	false	precision (95% Wilson)
a 331-file private Cargo workspace (3 crates)	93	93	0	100% (96.0–100%)
tokio @cdd9dae3 (822 files)	67 (+2 heuristic dispatch, excluded)	66	1	98.5% (92.0–99.7%)
Rust pooled	160	159	1	99.4% (~96.6–99.9%)

The 1 false edge was a path-qualified type resolved through a same-leaf use import (&scheduler::Handle → the imported Handle). That class was then fixed (module-qualified types resolve by their own path) and re-verified on tokio: 85/94 such sites now reach the right type, 7/8 previously lost edges are back, the 8th is a same-file case resolved by design. 423 edges that existed before were replaced on the private workspace; all 423 were name-match mistakes corrected by use-path resolution (e.g. a function aliased with as in test modules; 200+ router(..) calls linked to the wrong router).

Known remaining limits (stated plainly):

Local shadowing (open). A closure/parameter that shadows a use-imported function (let run = |x| ..; run(3)) is still linked by the pre-existing name matcher exactly as on main; this change does not make it worse and does not fix it. 0 of 2,887 new bare-call edges on the two repos have such a same-named local.
Sibling inline modules binding the same local name differently (mod a { use x::helper } mod b { use y::helper }): one binding per file, as before. On tokio this yields no edge rather than a wrong one.
Not resolved: use pricing; of a module as a leaf (modules have no node), #[path = ".."] modules, super:: from inline modules, mod common; test helpers, tails of call results, leading-:: paths, derive/std Type::default().
Sample sizes (≤93 per repo) only support ≥94–96% at 95% confidence; there is no population-level machine check for Rust.

Recall

Private workspace: failed refs rooted at a workspace crate name 457 → 17; failed refs 38,263 → 33,330; edges 40,516 → 45,439 (+4.9k, mostly calls and imports); server→sim edges 717 → 973. tokio: edges 35,151 → 37,474, failed refs 43,344 → 41,084. Nodes identical before/after.

Benchmarks

Median of 3 interleaved runs, shared 16-core WSL host (noisy; trust ranges for deltas under ~25%). All runs exit 0.

repo	wall s before → after	peak RSS MB before → after	DB MB
private workspace (331 files)	14.1 → 13.1 (within noise)	1,133 → 1,259 (+11%)	49.7 → 50.1
tokio (822 files)	13.9 → 15.8 (+14%, ranges do not overlap)	1,106 → 1,168 (+6%)	43.9 → 44.5

The per-reference module-tree probing and use parsing cost roughly +5–15% RSS and up to ~+14% wall on Rust repos. Non-Rust repos are unaffected.

Tests

__tests__/rust-cross-crate.test.ts (9 tests): fully qualified cross-crate call; crate-root item, re-export, constant and enum variant; use import of another crate and calls through it; renamed path dependency and a path dependency outside the workspace members; crate:: / super:: in a member crate; module-qualified type vs same-name use; qualifier written across lines; qualifier with comments; ambiguous path-dependency key left unresolved. Against plain main, 7 of the 9 fail (the other 2 are guards that must stay unresolved). Rust-named suites, frameworks-integration and pr19-improvements pass; full suite on this branch: 6,899 passed, 2 failed (bundle-launcher Windows-archive cases, zip: command not found on the host — fail identically on main).

Relation to existing issues/PRs

Builds on the Cargo workspace crate map from test+feat: add cargo workspace crate resolution for rust resolver #151 (extends it to path dependencies).
Overlaps fix(rust): resolve bare calls through exact use bindings #2308 (bare calls through exact use bindings, open): both touch the Rust use/path code in import-resolver.ts; expect a rebase conflict whichever lands second. fix(rust): resolve bare calls through exact use bindings #2308 resolves bare calls and in-crate module paths by their use; this PR resolves cross-crate paths, Type::member tails, re-exports and constants. They are complementary but not independent.
Related, no overlap found: fix(rust): a variant path references the enum that declares it (#2328) #2354 (variant path), fix(rust): a method call resolves by the type its receiver is written with, never by the method's name alone (#2614) #2625 (method receiver by written type), fix(rust): resolve use super::* callees in #[path] modules #1892 (#[path] modules).
Searched open and closed issues/PRs for "cargo workspace", "cross-crate", "path dependency": none reports this failure.

Not included

Fixing local-shadowing (needs a scope check in the name matcher), module-as-leaf imports, #[path] modules, inline-module super::.

A call written with its path into another workspace crate, like `sim::items::ItemPool::for_def(...)`, never connected: only a bare imported name resolved, so callers/impact missed most cross-crate uses. Resolve a Rust path by walking the module tree from its anchor (`crate`, `self`, `super`, a workspace crate name, or the file's `use` binding), to an item or a `Type::member`, following `pub use` and glob re-exports. Cargo path dependencies (including renamed ones and non-members) map to their crate directory; a dependency key that two crates bind to different directories is left unresolved rather than guessed. A module-qualified type (`scheduler::Handle`) resolves by its own written path, read back across lines and ignoring comments, before any same-named `use` import. The Rust path code moves out of import-resolver.ts into rust-paths.ts.

@BGamboa13

…'s own function A Rust call through a type, `sim::items::ItemPool::for_def(…)` into another crate of the workspace or `ItemPool::for_def(…)` under `use sim::items::ItemPool;`, was matched by its qualified name alone, so a namesake type's function in another crate or module could take it (a workspace's `client` crate's `ItemPool::for_def`). The module walk stopped at the type, a `use` of a `pub const` or `static` (`use sim::RANK_COUNT;`) linked nothing, and a type rustfmt wrapped below its path (`h: &scheduler::\n Handle`) linked by the file's `use` of its last name. The fix, on the module walk: - rustPathTarget reads `Type::member` calls: the type is the item the path's modules name, or the one the `use` that binds its name names (rustUseItemsAt), and rustTypeMember finds its member: an enum's variant; else the type's own (inherent) function or `const` in the type's crate, a trait impl's only when it is the one of that name; a trait's own declared method. A type alias, `Self`, a type the module declares itself and a type path in any other position are left as they were. - Module items include `variable`s (a module-level `pub const`/`static`). - matchRustUseBoundName reads a qualifier written on the line above a type (rust-scopes' blanked code, so a commented-out path is none) and resolves the whole path. - Memoized per (type, member) and per path. - Manifest paths stay inside the project: a workspace member that leaves it (`../sibling`, an absolute path) is neither read nor listed (isInsideProject, in expandMembers), and rustCrateGraph drops a `[lib]`/`[[bin]]` path that leaves it, as it already did a dependency's. Validation: - rust-cross-crate.test.ts (PR 2631's 9 cases, credited), rust-type-member-paths.test.ts and rust-manifest-paths.test.ts: on main 11 of 15 fail; all pass. Every rust-* suite passes. On main the workspace map read `../outside/Cargo.toml`, `../vendor/x/Cargo.toml` and `/abs/crate/Cargo.toml` and listed `../vendor`; now only the project's. - A/B against main, native kernel, 7 Rust repos (every site the same as against PR #3014's own commit; re-checked on 57dc7ae): tokio +205 links / 139 retargeted / 230 chains gaining their head call, ripgrep +155 / 13 / 1, axum +25, clap +179 / 0 / 295, serde +28, dioxus +142 / 6 / 31, gleam +114 / 47 / 0; 0 removed. Retargets go to the type the code imports or its own crate's (tokio's Semaphore::new and loom mocks to tokio::sync, ripgrep's Error::from, gleam's Printer::new); express and flask byte-identical. - Cost, native kernel, medians of 3 interleaved runs (dioxus of 7): tokio CPU 32.1 -> 29.7 s, peak RSS 1,000 -> 1,010 MB; gleam 29.1 -> 28.1 s, 1,010 -> 1,004 MB; dioxus 38.7 -> 40.1 s, 1,111 -> 1,115 MB (timed on one thread, rustPathTarget 1.24 -> 1.32 s over 17,198 calls). Builds on PR #2631 by @BGamboa13. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@BGamboa13

…'s own function A Rust call through a type, `sim::items::ItemPool::for_def(…)` into another crate of the workspace or `ItemPool::for_def(…)` under `use sim::items::ItemPool;`, was matched by its qualified name alone, so a namesake type's function in another crate or module could take it (a workspace's `client` crate's `ItemPool::for_def`). The module walk stopped at the type, a `use` of a `pub const` or `static` (`use sim::RANK_COUNT;`) linked nothing, and a type rustfmt wrapped below its path (`h: &scheduler::\n Handle`) linked by the file's `use` of its last name. The fix, on the module walk: - rustPathTarget reads `Type::member` calls: the type is the item the path's modules name, or the one the `use` that binds its name names (rustUseItemsAt), and rustTypeMember finds its member: an enum's variant; else the type's own (inherent) function or `const` in the type's crate, a trait impl's only when it is the one of that name; a trait's own declared method. A type alias, `Self`, a type the module declares itself and a type path in any other position are left as they were. - Module items include `variable`s (a module-level `pub const`/`static`). - matchRustUseBoundName reads a qualifier written on the line above a type (rust-scopes' blanked code, so a commented-out path is none) and resolves the whole path. - Memoized per (type, member) and per path. - Manifest paths stay inside the project: a workspace member that leaves it (`../sibling`, an absolute path) is neither read nor listed (escapesRoot, in expandMembers), and rustCrateGraph drops a `[lib]`/`[[bin]]` path that leaves it, as it already did a dependency's. Validation: - rust-cross-crate.test.ts (PR 2631's 9 cases, credited), rust-type-member-paths.test.ts and rust-manifest-paths.test.ts: on main 10 of 15 fail; all pass. Every rust-* suite passes. On main the workspace map read `../outside/Cargo.toml`, `../vendor/x/Cargo.toml` and `/abs/crate/Cargo.toml` and listed `../vendor`; now only the project's. - A/B against main, native kernel, 7 Rust repos (every site the same as against PR #3014's own commit; re-checked on a38a1ec): tokio +205 links / 139 retargeted / 230 chains gaining their head call, ripgrep +155 / 13 / 1, axum +25, clap +179 / 0 / 295, serde +28, dioxus +142 / 6 / 31, gleam +114 / 47 / 0; 0 removed. Retargets go to the type the code imports or its own crate's (tokio's Semaphore::new and loom mocks to tokio::sync, ripgrep's Error::from, gleam's Printer::new); express and flask byte-identical. - Cost, native kernel, medians of 3 interleaved runs (dioxus of 7): tokio CPU 32.1 -> 29.7 s, peak RSS 1,000 -> 1,010 MB; gleam 29.1 -> 28.1 s, 1,010 -> 1,004 MB; dioxus 38.7 -> 40.1 s, 1,111 -> 1,115 MB (timed on one thread, rustPathTarget 1.24 -> 1.32 s over 17,198 calls). Builds on PR #2631 by @BGamboa13. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@BGamboa13

…'s own function A Rust call through a type, `sim::items::ItemPool::for_def(…)` into another crate of the workspace or `ItemPool::for_def(…)` under `use sim::items::ItemPool;`, was matched by its qualified name alone, so a namesake type's function in another crate or module could take it (a workspace's `client` crate's `ItemPool::for_def`). The module walk stopped at the type, a `use` of a `pub const` or `static` (`use sim::RANK_COUNT;`) linked nothing, and a type rustfmt wrapped below its path (`h: &scheduler::\n Handle`) linked by the file's `use` of its last name. The fix, on the module walk: - rustPathTarget reads `Type::member` calls: the type is the item the path's modules name, or the one the `use` that binds its name names (rustUseItemsAt), and rustTypeMember finds its member: an enum's variant; else the type's own (inherent) function or `const` in the type's crate, a trait impl's only when it is the one of that name; a trait's own declared method. A type alias, `Self`, a type the module declares itself and a type path in any other position are left as they were. - Module items include `variable`s (a module-level `pub const`/`static`). - matchRustUseBoundName reads a qualifier written on the line above a type (rust-scopes' blanked code, so a commented-out path is none) and resolves the whole path. - Memoized per (type, member) and per path. - Manifest paths stay inside the project: a workspace member that leaves it (`../sibling`, an absolute path) is neither read nor listed (escapesRoot, in expandMembers), and rustCrateGraph drops a `[lib]`/`[[bin]]` path that leaves it, as it already did a dependency's. Validation: - rust-cross-crate.test.ts (PR 2631's 9 cases, credited), rust-type-member-paths.test.ts and rust-manifest-paths.test.ts: on main 10 of 15 fail; all pass. Every rust-* suite passes. On main the workspace map read `../outside/Cargo.toml`, `../vendor/x/Cargo.toml` and `/abs/crate/Cargo.toml` and listed `../vendor`; now only the project's. - A/B against main, native kernel, 7 Rust repos (every site the same as against PR #3014's own commit; re-checked on a38a1ec): tokio +205 links / 139 retargeted / 230 chains gaining their head call, ripgrep +155 / 13 / 1, axum +25, clap +179 / 0 / 295, serde +28, dioxus +142 / 6 / 31, gleam +114 / 47 / 0; 0 removed. Retargets go to the type the code imports or its own crate's (tokio's Semaphore::new and loom mocks to tokio::sync, ripgrep's Error::from, gleam's Printer::new); express and flask byte-identical. - Cost, native kernel, medians of 3 interleaved runs (dioxus of 7): tokio CPU 32.1 -> 29.7 s, peak RSS 1,000 -> 1,010 MB; gleam 29.1 -> 28.1 s, 1,010 -> 1,004 MB; dioxus 38.7 -> 40.1 s, 1,111 -> 1,115 MB (timed on one thread, rustPathTarget 1.24 -> 1.32 s over 17,198 calls). Builds on PR #2631 by @BGamboa13. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@BGamboa13

…'s own function A Rust call through a type, `sim::items::ItemPool::for_def(…)` into another crate of the workspace or `ItemPool::for_def(…)` under `use sim::items::ItemPool;`, was matched by its qualified name alone, so a namesake type's function in another crate or module could take it (a workspace's `client` crate's `ItemPool::for_def`). The module walk stopped at the type, a `use` of a `pub const` or `static` (`use sim::RANK_COUNT;`) linked nothing, and a type rustfmt wrapped below its path (`h: &scheduler::\n Handle`) linked by the file's `use` of its last name. The fix, on the module walk: - rustPathTarget reads `Type::member` calls: the type is the item the path's modules name, or the one the `use` that binds its name names (rustUseItemsAt), and rustTypeMember finds its member: an enum's variant; else the type's own (inherent) function or `const` in the type's crate, a trait impl's only when it is the one of that name; a trait's own declared method. A type alias, `Self`, a type the module declares itself and a type path in any other position are left as they were. - Module items include `variable`s (a module-level `pub const`/`static`). - matchRustUseBoundName reads a qualifier written on the line above a type (rust-scopes' blanked code, so a commented-out path is none) and resolves the whole path. - Memoized per (type, member) and per path. - Manifest paths stay inside the project: a workspace member that leaves it (`../sibling`, an absolute path) is neither read nor listed (escapesRoot, in expandMembers), and rustCrateGraph drops a `[lib]`/`[[bin]]` path that leaves it, as it already did a dependency's. Validation: - rust-cross-crate.test.ts (PR 2631's 9 cases, credited), rust-type-member-paths.test.ts and rust-manifest-paths.test.ts: on main 10 of 15 fail; all pass. Every rust-* suite passes. On main the workspace map read `../outside/Cargo.toml`, `../vendor/x/Cargo.toml` and `/abs/crate/Cargo.toml` and listed `../vendor`; now only the project's. - A/B against main, native kernel, 7 Rust repos (every site the same as against PR #3014's own commit; re-checked on a38a1ec): tokio +205 links / 139 retargeted / 230 chains gaining their head call, ripgrep +155 / 13 / 1, axum +25, clap +179 / 0 / 295, serde +28, dioxus +142 / 6 / 31, gleam +114 / 47 / 0; 0 removed. Retargets go to the type the code imports or its own crate's (tokio's Semaphore::new and loom mocks to tokio::sync, ripgrep's Error::from, gleam's Printer::new); express and flask byte-identical. - Cost, native kernel, medians of 3 interleaved runs (dioxus of 7): tokio CPU 32.1 -> 29.7 s, peak RSS 1,000 -> 1,010 MB; gleam 29.1 -> 28.1 s, 1,010 -> 1,004 MB; dioxus 38.7 -> 40.1 s, 1,111 -> 1,115 MB (timed on one thread, rustPathTarget 1.24 -> 1.32 s over 17,198 calls). Builds on PR #2631 by @BGamboa13. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@BGamboa13

…'s own function A Rust call through a type, `sim::items::ItemPool::for_def(…)` into another crate of the workspace or `ItemPool::for_def(…)` under `use sim::items::ItemPool;`, was matched by its qualified name alone, so a namesake type's function in another crate or module could take it (a workspace's `client` crate's `ItemPool::for_def`). The module walk stopped at the type, a `use` of a `pub const` or `static` (`use sim::RANK_COUNT;`) linked nothing, and a type rustfmt wrapped below its path (`h: &scheduler::\n Handle`) linked by the file's `use` of its last name. The fix, on the module walk: - rustPathTarget reads `Type::member` calls: the type is the item the path's modules name, or the one the `use` that binds its name names (rustUseItemsAt), and rustTypeMember finds its member: an enum's variant; else the type's own (inherent) function or `const` in the type's crate, a trait impl's only when it is the one of that name; a trait's own declared method. A type alias, `Self`, a type the module declares itself and a type path in any other position are left as they were. - Module items include `variable`s (a module-level `pub const`/`static`). - matchRustUseBoundName reads a qualifier written on the line above a type (rust-scopes' blanked code, so a commented-out path is none) and resolves the whole path. - Memoized per (type, member) and per path. - Manifest paths stay inside the project: a workspace member that leaves it (`../sibling`, an absolute path) is neither read nor listed (escapesRoot, in expandMembers), and rustCrateGraph drops a `[lib]`/`[[bin]]` path that leaves it, as it already did a dependency's. Validation: - rust-cross-crate.test.ts (PR 2631's 9 cases, credited), rust-type-member-paths.test.ts and rust-manifest-paths.test.ts: on main 10 of 15 fail; all pass. Every rust-* suite passes. On main the workspace map read `../outside/Cargo.toml`, `../vendor/x/Cargo.toml` and `/abs/crate/Cargo.toml` and listed `../vendor`; now only the project's. - A/B against main, native kernel, 7 Rust repos (every site the same as against PR #3014's own commit; re-checked on 60b0d7a): tokio +205 links / 139 retargeted / 230 chains gaining their head call, ripgrep +155 / 13 / 1, axum +25, clap +179 / 0 / 295, serde +28, dioxus +142 / 6 / 31, gleam +114 / 47 / 0; 0 removed. Retargets go to the type the code imports or its own crate's (tokio's Semaphore::new and loom mocks to tokio::sync, ripgrep's Error::from, gleam's Printer::new); express and flask byte-identical. - Cost, native kernel, medians of 3 interleaved runs (dioxus of 7): tokio CPU 32.1 -> 29.7 s, peak RSS 1,000 -> 1,010 MB; gleam 29.1 -> 28.1 s, 1,010 -> 1,004 MB; dioxus 38.7 -> 40.1 s, 1,111 -> 1,115 MB (timed on one thread, rustPathTarget 1.24 -> 1.32 s over 17,198 calls). Builds on PR #2631 by @BGamboa13. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@BGamboa13

…'s own function A Rust call through a type, `sim::items::ItemPool::for_def(…)` into another crate of the workspace or `ItemPool::for_def(…)` under `use sim::items::ItemPool;`, was matched by its qualified name alone, so a namesake type's function in another crate or module could take it (a workspace's `client` crate's `ItemPool::for_def`). The module walk stopped at the type, a `use` of a `pub const` or `static` (`use sim::RANK_COUNT;`) linked nothing, and a type rustfmt wrapped below its path (`h: &scheduler::\n Handle`) linked by the file's `use` of its last name. The fix, on the module walk: - rustPathTarget reads `Type::member` calls: the type is the item the path's modules name, or the one the `use` that binds its name names (rustUseItemsAt), and rustTypeMember finds its member: an enum's variant; else the type's own (inherent) function or `const` in the type's crate, a trait impl's only when it is the one of that name; a trait's own declared method. A type alias, `Self`, a type the module declares itself and a type path in any other position are left as they were. - Module items include `variable`s (a module-level `pub const`/`static`). - matchRustUseBoundName reads a qualifier written on the line above a type (rust-scopes' blanked code, so a commented-out path is none) and resolves the whole path. - Memoized per (type, member) and per path. - Manifest paths stay inside the project: a workspace member that leaves it (`../sibling`, an absolute path) is neither read nor listed (escapesRoot, in expandMembers), and rustCrateGraph drops a `[lib]`/`[[bin]]` path that leaves it, as it already did a dependency's. Validation: - rust-cross-crate.test.ts (PR 2631's 9 cases, credited), rust-type-member-paths.test.ts and rust-manifest-paths.test.ts: on main 10 of 15 fail; all pass. Every rust-* suite passes. On main the workspace map read `../outside/Cargo.toml`, `../vendor/x/Cargo.toml` and `/abs/crate/Cargo.toml` and listed `../vendor`; now only the project's. - A/B against main, native kernel, 7 Rust repos (every site the same as against PR #3014's own commit; re-checked on 60b0d7a): tokio +205 links / 139 retargeted / 230 chains gaining their head call, ripgrep +155 / 13 / 1, axum +25, clap +179 / 0 / 295, serde +28, dioxus +142 / 6 / 31, gleam +114 / 47 / 0; 0 removed. Retargets go to the type the code imports or its own crate's (tokio's Semaphore::new and loom mocks to tokio::sync, ripgrep's Error::from, gleam's Printer::new); express and flask byte-identical. - Cost, native kernel, medians of 3 interleaved runs (dioxus of 7): tokio CPU 32.1 -> 29.7 s, peak RSS 1,000 -> 1,010 MB; gleam 29.1 -> 28.1 s, 1,010 -> 1,004 MB; dioxus 38.7 -> 40.1 s, 1,111 -> 1,115 MB (timed on one thread, rustPathTarget 1.24 -> 1.32 s over 17,198 calls). Builds on PR #2631 by @BGamboa13. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@BGamboa13

…'s own function A Rust call through a type, `sim::items::ItemPool::for_def(…)` into another crate of the workspace or `ItemPool::for_def(…)` under `use sim::items::ItemPool;`, was matched by its qualified name alone, so a namesake type's function in another crate or module could take it (a workspace's `client` crate's `ItemPool::for_def`). The module walk stopped at the type, a `use` of a `pub const` or `static` (`use sim::RANK_COUNT;`) linked nothing, and a type rustfmt wrapped below its path (`h: &scheduler::\n Handle`) linked by the file's `use` of its last name. The fix, on the module walk: - rustPathTarget reads `Type::member` calls: the type is the item the path's modules name, or the one the `use` that binds its name names (rustUseItemsAt), and rustTypeMember finds its member: an enum's variant; else the type's own (inherent) function or `const` in the type's crate, a trait impl's only when it is the one of that name; a trait's own declared method. A type alias, `Self`, a type the module declares itself and a type path in any other position are left as they were. - Module items include `variable`s (a module-level `pub const`/`static`). - matchRustUseBoundName reads a qualifier written on the line above a type (rust-scopes' blanked code, so a commented-out path is none) and resolves the whole path. - Memoized per (type, member) and per path. - Manifest paths stay inside the project: a workspace member that leaves it (`../sibling`, an absolute path) is neither read nor listed (escapesRoot, in expandMembers), and rustCrateGraph drops a `[lib]`/`[[bin]]` path that leaves it, as it already did a dependency's. Validation: - rust-cross-crate.test.ts (PR 2631's 9 cases, credited), rust-type-member-paths.test.ts and rust-manifest-paths.test.ts: on main 10 of 15 fail; all pass. Every rust-* suite passes. On main the workspace map read `../outside/Cargo.toml`, `../vendor/x/Cargo.toml` and `/abs/crate/Cargo.toml` and listed `../vendor`; now only the project's. - A/B against main, native kernel, 7 Rust repos (every site the same as against PR #3014's own commit; re-checked on 60b0d7a): tokio +205 links / 139 retargeted / 230 chains gaining their head call, ripgrep +155 / 13 / 1, axum +25, clap +179 / 0 / 295, serde +28, dioxus +142 / 6 / 31, gleam +114 / 47 / 0; 0 removed. Retargets go to the type the code imports or its own crate's (tokio's Semaphore::new and loom mocks to tokio::sync, ripgrep's Error::from, gleam's Printer::new); express and flask byte-identical. - Cost, native kernel, medians of 3 interleaved runs (dioxus of 7): tokio CPU 32.1 -> 29.7 s, peak RSS 1,000 -> 1,010 MB; gleam 29.1 -> 28.1 s, 1,010 -> 1,004 MB; dioxus 38.7 -> 40.1 s, 1,111 -> 1,115 MB (timed on one thread, rustPathTarget 1.24 -> 1.32 s over 17,198 calls). Builds on PR #2631 by @BGamboa13. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@BGamboa13

…'s own function A Rust call through a type, `sim::items::ItemPool::for_def(…)` into another crate of the workspace or `ItemPool::for_def(…)` under `use sim::items::ItemPool;`, was matched by its qualified name alone, so a namesake type's function in another crate or module could take it (a workspace's `client` crate's `ItemPool::for_def`). The module walk stopped at the type, a `use` of a `pub const` or `static` (`use sim::RANK_COUNT;`) linked nothing, and a type rustfmt wrapped below its path (`h: &scheduler::\n Handle`) linked by the file's `use` of its last name. The fix, on the module walk: - rustPathTarget reads `Type::member` calls: the type is the item the path's modules name, or the one the `use` that binds its name names (rustUseItemsAt), and rustTypeMember finds its member: an enum's variant; else the type's own (inherent) function or `const` in the type's crate, a trait impl's only when it is the one of that name; a trait's own declared method. A type alias, `Self`, a type the module declares itself and a type path in any other position are left as they were. - Module items include `variable`s (a module-level `pub const`/`static`). - matchRustUseBoundName reads a qualifier written on the line above a type (rust-scopes' blanked code, so a commented-out path is none) and resolves the whole path. - Memoized per (type, member) and per path. - Manifest paths stay inside the project: a workspace member that leaves it (`../sibling`, an absolute path) is neither read nor listed (escapesRoot, in expandMembers), and rustCrateGraph drops a `[lib]`/`[[bin]]` path that leaves it, as it already did a dependency's. Validation: - rust-cross-crate.test.ts (PR 2631's 9 cases, credited), rust-type-member-paths.test.ts and rust-manifest-paths.test.ts: on main 10 of 15 fail; all pass. Every rust-* suite passes. On main the workspace map read `../outside/Cargo.toml`, `../vendor/x/Cargo.toml` and `/abs/crate/Cargo.toml` and listed `../vendor`; now only the project's. - A/B against main, native kernel, 7 Rust repos (every site the same as against PR #3014's own commit; re-checked on 60b0d7a): tokio +205 links / 139 retargeted / 230 chains gaining their head call, ripgrep +155 / 13 / 1, axum +25, clap +179 / 0 / 295, serde +28, dioxus +142 / 6 / 31, gleam +114 / 47 / 0; 0 removed. Retargets go to the type the code imports or its own crate's (tokio's Semaphore::new and loom mocks to tokio::sync, ripgrep's Error::from, gleam's Printer::new); express and flask byte-identical. - Cost, native kernel, medians of 3 interleaved runs (dioxus of 7): tokio CPU 32.1 -> 29.7 s, peak RSS 1,000 -> 1,010 MB; gleam 29.1 -> 28.1 s, 1,010 -> 1,004 MB; dioxus 38.7 -> 40.1 s, 1,111 -> 1,115 MB (timed on one thread, rustPathTarget 1.24 -> 1.32 s over 17,198 calls). Builds on PR #2631 by @BGamboa13. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@BGamboa13

…'s own function A Rust call through a type, `sim::items::ItemPool::for_def(…)` into another crate of the workspace or `ItemPool::for_def(…)` under `use sim::items::ItemPool;`, was matched by its qualified name alone, so a namesake type's function in another crate or module could take it (a workspace's `client` crate's `ItemPool::for_def`). The module walk stopped at the type, a `use` of a `pub const` or `static` (`use sim::RANK_COUNT;`) linked nothing, and a type rustfmt wrapped below its path (`h: &scheduler::\n Handle`) linked by the file's `use` of its last name. The fix, on the module walk: - rustPathTarget reads `Type::member` calls: the type is the item the path's modules name, or the one the `use` that binds its name names (rustUseItemsAt), and rustTypeMember finds its member: an enum's variant; else the type's own (inherent) function or `const` in the type's crate, a trait impl's only when it is the one of that name; a trait's own declared method. A type alias, `Self`, a type the module declares itself and a type path in any other position are left as they were. - Module items include `variable`s (a module-level `pub const`/`static`). - matchRustUseBoundName reads a qualifier written on the line above a type (rust-scopes' blanked code, so a commented-out path is none) and resolves the whole path. - Memoized per (type, member) and per path. - Manifest paths stay inside the project: a workspace member that leaves it (`../sibling`, an absolute path) is neither read nor listed (escapesRoot, in expandMembers), and rustCrateGraph drops a `[lib]`/`[[bin]]` path that leaves it, as it already did a dependency's. Validation: - rust-cross-crate.test.ts (PR 2631's 9 cases, credited), rust-type-member-paths.test.ts and rust-manifest-paths.test.ts: on main 10 of 15 fail; all pass. Every rust-* suite passes. On main the workspace map read `../outside/Cargo.toml`, `../vendor/x/Cargo.toml` and `/abs/crate/Cargo.toml` and listed `../vendor`; now only the project's. - A/B against main, native kernel, 7 Rust repos (every site the same as against PR #3014's own commit; re-checked on 60b0d7a): tokio +205 links / 139 retargeted / 230 chains gaining their head call, ripgrep +155 / 13 / 1, axum +25, clap +179 / 0 / 295, serde +28, dioxus +142 / 6 / 31, gleam +114 / 47 / 0; 0 removed. Retargets go to the type the code imports or its own crate's (tokio's Semaphore::new and loom mocks to tokio::sync, ripgrep's Error::from, gleam's Printer::new); express and flask byte-identical. - Cost, native kernel, medians of 3 interleaved runs (dioxus of 7): tokio CPU 32.1 -> 29.7 s, peak RSS 1,000 -> 1,010 MB; gleam 29.1 -> 28.1 s, 1,010 -> 1,004 MB; dioxus 38.7 -> 40.1 s, 1,111 -> 1,115 MB (timed on one thread, rustPathTarget 1.24 -> 1.32 s over 17,198 calls). Builds on PR #2631 by @BGamboa13. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@BGamboa13

…'s own function A Rust call through a type, `sim::items::ItemPool::for_def(…)` into another crate of the workspace or `ItemPool::for_def(…)` under `use sim::items::ItemPool;`, was matched by its qualified name alone, so a namesake type's function in another crate or module could take it (a workspace's `client` crate's `ItemPool::for_def`). The module walk stopped at the type, a `use` of a `pub const` or `static` (`use sim::RANK_COUNT;`) linked nothing, and a type rustfmt wrapped below its path (`h: &scheduler::\n Handle`) linked by the file's `use` of its last name. The fix, on the module walk: - rustPathTarget reads `Type::member` calls: the type is the item the path's modules name, or the one the `use` that binds its name names (rustUseItemsAt), and rustTypeMember finds its member: an enum's variant; else the type's own (inherent) function or `const` in the type's crate, a trait impl's only when it is the one of that name; a trait's own declared method. A type alias, `Self`, a type the module declares itself and a type path in any other position are left as they were. - Module items include `variable`s (a module-level `pub const`/`static`). - matchRustUseBoundName reads a qualifier written on the line above a type (rust-scopes' blanked code, so a commented-out path is none) and resolves the whole path. - Memoized per (type, member) and per path. - Manifest paths stay inside the project: a workspace member that leaves it (`../sibling`, an absolute path) is neither read nor listed (escapesRoot, in expandMembers), and rustCrateGraph drops a `[lib]`/`[[bin]]` path that leaves it, as it already did a dependency's. Validation: - rust-cross-crate.test.ts (PR 2631's 9 cases, credited), rust-type-member-paths.test.ts and rust-manifest-paths.test.ts: on main 10 of 15 fail; all pass. Every rust-* suite passes. On main the workspace map read `../outside/Cargo.toml`, `../vendor/x/Cargo.toml` and `/abs/crate/Cargo.toml` and listed `../vendor`; now only the project's. - A/B against main, native kernel, 7 Rust repos (every site the same as against PR #3014's own commit; re-checked on 60b0d7a): tokio +205 links / 139 retargeted / 230 chains gaining their head call, ripgrep +155 / 13 / 1, axum +25, clap +179 / 0 / 295, serde +28, dioxus +142 / 6 / 31, gleam +114 / 47 / 0; 0 removed. Retargets go to the type the code imports or its own crate's (tokio's Semaphore::new and loom mocks to tokio::sync, ripgrep's Error::from, gleam's Printer::new); express and flask byte-identical. - Cost, native kernel, medians of 3 interleaved runs (dioxus of 7): tokio CPU 32.1 -> 29.7 s, peak RSS 1,000 -> 1,010 MB; gleam 29.1 -> 28.1 s, 1,010 -> 1,004 MB; dioxus 38.7 -> 40.1 s, 1,111 -> 1,115 MB (timed on one thread, rustPathTarget 1.24 -> 1.32 s over 17,198 calls). Builds on PR #2631 by @BGamboa13. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@BGamboa13

…'s own function A Rust call through a type, `sim::items::ItemPool::for_def(…)` into another crate of the workspace or `ItemPool::for_def(…)` under `use sim::items::ItemPool;`, was matched by its qualified name alone, so a namesake type's function in another crate or module could take it (a workspace's `client` crate's `ItemPool::for_def`). The module walk stopped at the type, a `use` of a `pub const` or `static` (`use sim::RANK_COUNT;`) linked nothing, and a type rustfmt wrapped below its path (`h: &scheduler::\n Handle`) linked by the file's `use` of its last name. The fix, on the module walk: - rustPathTarget reads `Type::member` calls: the type is the item the path's modules name, or the one the `use` that binds its name names (rustUseItemsAt), and rustTypeMember finds its member: an enum's variant; else the type's own (inherent) function or `const` in the type's crate, a trait impl's only when it is the one of that name; a trait's own declared method. A type alias, `Self`, a type the module declares itself and a type path in any other position are left as they were. - Module items include `variable`s (a module-level `pub const`/`static`). - matchRustUseBoundName reads a qualifier written on the line above a type (rust-scopes' blanked code, so a commented-out path is none) and resolves the whole path. - Memoized per (type, member) and per path. - Manifest paths stay inside the project: a workspace member that leaves it (`../sibling`, an absolute path) is neither read nor listed (escapesRoot, in expandMembers), and rustCrateGraph drops a `[lib]`/`[[bin]]` path that leaves it, as it already did a dependency's. Validation: - rust-cross-crate.test.ts (PR 2631's 9 cases, credited), rust-type-member-paths.test.ts and rust-manifest-paths.test.ts: on main 10 of 15 fail; all pass. Every rust-* suite passes. On main the workspace map read `../outside/Cargo.toml`, `../vendor/x/Cargo.toml` and `/abs/crate/Cargo.toml` and listed `../vendor`; now only the project's. - A/B against main, native kernel, 7 Rust repos (every site the same as against PR #3014's own commit; re-checked on 60b0d7a): tokio +205 links / 139 retargeted / 230 chains gaining their head call, ripgrep +155 / 13 / 1, axum +25, clap +179 / 0 / 295, serde +28, dioxus +142 / 6 / 31, gleam +114 / 47 / 0; 0 removed. Retargets go to the type the code imports or its own crate's (tokio's Semaphore::new and loom mocks to tokio::sync, ripgrep's Error::from, gleam's Printer::new); express and flask byte-identical. - Cost, native kernel, medians of 3 interleaved runs (dioxus of 7): tokio CPU 32.1 -> 29.7 s, peak RSS 1,000 -> 1,010 MB; gleam 29.1 -> 28.1 s, 1,010 -> 1,004 MB; dioxus 38.7 -> 40.1 s, 1,111 -> 1,115 MB (timed on one thread, rustPathTarget 1.24 -> 1.32 s over 17,198 calls). Builds on PR #2631 by @BGamboa13. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@BGamboa13

…'s own function (#3025) A Rust call through a type, `sim::items::ItemPool::for_def(…)` into another crate of the workspace or `ItemPool::for_def(…)` under `use sim::items::ItemPool;`, was matched by its qualified name alone, so a namesake type's function in another crate or module could take it (a workspace's `client` crate's `ItemPool::for_def`). The module walk stopped at the type, a `use` of a `pub const` or `static` (`use sim::RANK_COUNT;`) linked nothing, and a type rustfmt wrapped below its path (`h: &scheduler::\n Handle`) linked by the file's `use` of its last name. The fix, on the module walk: - rustPathTarget reads `Type::member` calls: the type is the item the path's modules name, or the one the `use` that binds its name names (rustUseItemsAt), and rustTypeMember finds its member: an enum's variant; else the type's own (inherent) function or `const` in the type's crate, a trait impl's only when it is the one of that name; a trait's own declared method. A type alias, `Self`, a type the module declares itself and a type path in any other position are left as they were. - Module items include `variable`s (a module-level `pub const`/`static`). - matchRustUseBoundName reads a qualifier written on the line above a type (rust-scopes' blanked code, so a commented-out path is none) and resolves the whole path. - Memoized per (type, member) and per path. - Manifest paths stay inside the project: a workspace member that leaves it (`../sibling`, an absolute path) is neither read nor listed (escapesRoot, in expandMembers), and rustCrateGraph drops a `[lib]`/`[[bin]]` path that leaves it, as it already did a dependency's. Validation: - rust-cross-crate.test.ts (PR 2631's 9 cases, credited), rust-type-member-paths.test.ts and rust-manifest-paths.test.ts: on main 10 of 15 fail; all pass. Every rust-* suite passes. On main the workspace map read `../outside/Cargo.toml`, `../vendor/x/Cargo.toml` and `/abs/crate/Cargo.toml` and listed `../vendor`; now only the project's. - A/B against main, native kernel, 7 Rust repos (every site the same as against PR #3014's own commit; re-checked on 60b0d7a): tokio +205 links / 139 retargeted / 230 chains gaining their head call, ripgrep +155 / 13 / 1, axum +25, clap +179 / 0 / 295, serde +28, dioxus +142 / 6 / 31, gleam +114 / 47 / 0; 0 removed. Retargets go to the type the code imports or its own crate's (tokio's Semaphore::new and loom mocks to tokio::sync, ripgrep's Error::from, gleam's Printer::new); express and flask byte-identical. - Cost, native kernel, medians of 3 interleaved runs (dioxus of 7): tokio CPU 32.1 -> 29.7 s, peak RSS 1,000 -> 1,010 MB; gleam 29.1 -> 28.1 s, 1,010 -> 1,004 MB; dioxus 38.7 -> 40.1 s, 1,111 -> 1,115 MB (timed on one thread, rustPathTarget 1.24 -> 1.32 s over 17,198 calls). Builds on PR #2631 by @BGamboa13. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

colbymchenry · 2026-10-30T09:28:58Z

Thank you for this, @BGamboa13! Your cross-crate work has landed in #3025, built on the module walk main gained in #3014: a call through a type that a path or a use names, like sim::items::ItemPool::for_def(…) into another workspace crate or ItemPool::for_def(…) under use sim::items::ItemPool;, now reaches that type's own function or variant instead of a namesake's, renamed and non-member path dependencies included, and uses of pub const/static items link. Your test cases are in, credited to you, so this PR can close.

This was referenced Oct 20, 2026

fix(rust): a private item, or one another crate holds, no longer takes a name a file imports #2692

Merged

fix(rust): a name a use brings in is the item of the module its path walks #2702

Merged

This was referenced Oct 29, 2026

fix(rust): use bindings follow Rust's scopes, and module paths walk the crate's modules #3014

Merged

fix(rust): calls through a type a path or a use names reach that type's own function #3025

Merged

colbymchenry closed this Oct 30, 2026

Navigation Menu

Repository navigation

fix(rust): resolve paths into other crates of a Cargo workspace - #2631

fix(rust): resolve paths into other crates of a Cargo workspace#2631
BGamboa13 wants to merge 1 commit into
colbymchenry:mainfrom
BGamboa13:feat/rust-cargo-cross-crate

BGamboa13 commented Oct 17, 2026

Uh oh!

colbymchenry commented Oct 30, 2026

Uh oh!

Reviewers

Uh oh!

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

Conversation

BGamboa13 commented Oct 17, 2026

fix(rust): resolve paths into other crates of a Cargo workspace

Problem

What changes

Precision evidence

Recall

Benchmarks

Tests

Relation to existing issues/PRs

Not included

Uh oh!

colbymchenry commented Oct 30, 2026

Uh oh!

Reviewers

Uh oh!

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants