fix(rust): resolve bare calls through exact use bindings

CHANGELOG.md

@@ -118,6 +118,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - In JavaScript and TypeScript, a default import now links to what the module's `export default` statement exports, wherever the statement sits in the file. Before, a module that declares its default, like `export default function Vans() {…}` or `export default class Store {…}`, had its default import linked to the first function it exports instead: in a React Router data-router app, where a page exports its `loader` or `action` above the page component, `import Vans, { loader as vansLoader } from './pages/Vans'` made the route `/vans` and every use of `Vans` lead to the loader. A component file that also exports a styled or memoized component no longer hands its default import to that component, and an anonymous default, like `export default function () {…}` or `export default () => …`, is no longer linked to a function exported beside it or nested inside it. A module loaded with `require('./x').default` is read the same way. Re-index JavaScript and TypeScript projects after upgrading.
 - In React and Vue, a tag for a component the file imports from a package, like `<Button>` from antd, `<Typography>` from `@mui/material/Typography`, `<Link>` from react-router-dom or `<Card>` from ant-design-vue, no longer links to a component, function or class in your repository that only shares its name. Before, the tag linked to whatever the repository had by that name, so `codegraph_explore`, callers and impact followed renders that never happen: in SigNoz, antd's `<Button>` tags showed up as callers of a styled link on its 404 page, and in Material UI dashboards like mantis and berry, `<Typography>` and `<Button>` tags showed up as callers of the theme's style overrides. A package here is one that a `package.json` above the file lists and that no file in the repository answers to. A tag imported through a path alias like `components/Modal`, from a workspace package of the repository, or under a name no `package.json` lists still links as before. Re-index React and Vue projects after upgrading.
 - In React with TypeScript, a component that renders a generic component and passes it type arguments, like outline's `<PaginatedList<Document> items={…} />` or excalidraw's `<DropdownMenuItemContentRadio<"contain" | "overlap"> …>`, now links to the component it renders. Before, a tag followed by type arguments was skipped, so the generic component looked unused by the screens that render it, and `codegraph_explore`'s call paths, callers and impact stopped short of it. Re-index React projects after upgrading.
+- In Rust, a call to a function brought in by `use`, like `take(3)` after `use crate::util::take;` (also through an `as` alias, a nested group or a `use` inside a function), and a call written as a module path, like `crate::util::take(3)` or `super::util::take(3)`, now link to the function that module declares. Before, they could land on a same-named function of another module, or on a same-named method declared above the function. (#2308)
 
 ## [1.6.2] - 2026-10-03
 

__tests__/rust-module-path-call.test.ts

@@ -0,0 +1,171 @@
+/**
+ * A Rust call written through a module path — `crate::util::take(3)`,
+ * `super::util::take(3)`, `self::util::take(3)`, `util::take(3)` after
+ * `use crate::util;` — is the free function that module declares, and so is
+ * a `use crate::util::take;`. A path never names a method (that takes
+ * `Type::method`), nor a function local to another function's body, even when
+ * the module's file declares one of the same name above the free function.
+ */
+import { describe, it, expect, afterAll, beforeAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-rust-module-path-'));
+  const files: Record<string, string> = {
+    'Cargo.toml': '[package]\nname = "app"\nversion = "0.1.0"\n',
+    'src/lib.rs': `mod util;
+mod only;
+mod a;
+mod caller;
+mod importer;
+mod handle;
+mod worker;
+
+pub fn via_self() -> usize {
+    self::util::take(1)
+}
+`,
+    'src/util.rs': `pub struct Buf;
+
+impl Buf {
+    pub fn take(&self, n: usize) -> usize {
+        n
+    }
+}
+
+pub trait Take {
+    fn take(&self) -> usize;
+}
+
+fn outer() -> usize {
+    fn take() -> usize {
+        0
+    }
+    take()
+}
+
+pub fn take(n: usize) -> usize {
+    n
+}
+`,
+    'src/only.rs': `pub struct Only;
+
+impl Only {
+    pub fn grab(&self) -> usize {
+        0
+    }
+}
+`,
+    'src/a/mod.rs': 'pub mod b;\n',
+    'src/a/b.rs': `pub struct Deep;
+
+impl Deep {
+    pub fn get(&self) -> usize {
+        0
+    }
+}
+
+pub fn get() -> usize {
+    1
+}
+`,
+    'src/importer.rs': 'use crate::util::take;\n',
+    'src/handle.rs': 'pub struct Handle;\n',
+    'src/worker.rs': `pub use crate::handle::Handle;
+mod dump;
+
+pub trait Lock {
+    type Handle;
+}
+
+pub struct Guard;
+
+impl Lock for Guard {
+    type Handle = u8;
+}
+`,
+    'src/worker/dump.rs': 'use super::Handle;\n',
+    'src/caller.rs': `use crate::util;
+
+pub fn via_crate() -> usize {
+    crate::util::take(1)
+}
+
+pub fn via_super() -> usize {
+    super::util::take(1)
+}
+
+pub fn via_module() -> usize {
+    util::take(1)
+}
+
+pub fn via_nested() -> usize {
+    crate::a::b::get()
+}
+
+pub fn via_method_only() -> usize {
+    crate::only::grab()
+}
+
+pub fn via_missing() -> usize {
+    crate::nowhere::take(1)
+}
+`,
+  };
+  for (const [rel, content] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+    fs.writeFileSync(path.join(root, rel), content);
+  }
+  cg = await CodeGraph.init(root, { index: true });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** What the function `name` in `file` calls, as `kind qualifiedName file:line`. */
+const callsFrom = (file: string, name: string): string[] => {
+  const fn = cg.getNodesInFile(file).find((n) => n.name === name)!;
+  return cg.getOutgoingEdgesFrom([fn.id]).filter((e) => e.kind === 'calls')
+    .map((e) => cg.getNode(e.target)!).map((t) => `${t.kind} ${t.qualifiedName} ${t.filePath}:${t.startLine}`);
+};
+
+describe('Rust calls through a module path', () => {
+  it('reach the free function the module declares, never a same-named method or local fn', () => {
+    const take = 'function take src/util.rs:20';
+    expect(callsFrom('src/caller.rs', 'via_crate')).toEqual([take]);
+    expect(callsFrom('src/caller.rs', 'via_super')).toEqual([take]);
+    expect(callsFrom('src/caller.rs', 'via_module')).toEqual([take]);
+    expect(callsFrom('src/lib.rs', 'via_self')).toEqual([take]);
+  });
+
+  it('bind a use of the function to it', () => {
+    const ids = cg.getNodesInFile('src/importer.rs').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'imports')
+      .map((e) => cg.getNode(e.target)!).map((t) => `${t.kind} ${t.qualifiedName} ${t.filePath}:${t.startLine}`);
+    expect(targets).toEqual(['function take src/util.rs:20']);
+  });
+
+  it('never bind a use to an associated type of the module\'s impl or trait', () => {
+    const ids = cg.getNodesInFile('src/worker/dump.rs').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind === 'imports')
+      .map((e) => cg.getNode(e.target)!).map((t) => `${t.kind} ${t.qualifiedName} ${t.filePath}:${t.startLine}`);
+    expect(targets.filter((t) => t.includes('src/worker.rs'))).toEqual([]);
+  });
+
+  it('walk a nested module path to its file', () => {
+    expect(callsFrom('src/caller.rs', 'via_nested')).toEqual(['function get src/a/b.rs:9']);
+  });
+
+  it('link nothing when the module declares no such free function, or is not in the index', () => {
+    expect(callsFrom('src/caller.rs', 'via_method_only')).toEqual([]);
+    expect(callsFrom('src/caller.rs', 'via_missing')).toEqual([]);
+  });
+});