ucn 5.3.5 → 5.3.6

package/core/cache.js

@@ -710,7 +710,8 @@ function clearAllCaches() {
 // v215: receiver-type provenance records the originating AST fact (#355).
 // v224 (#355 recovery): Go declaration origins; Rust aliases, wrapper patterns,
 // copied bindings and qualified macro receivers; TS indexed array evidence.
-const CACHE_FORMAT_VERSION = 224;
+// v225 (fix #357): Rust `use path::name as local` bindings record the original name with a paired `renames` alias.
+const CACHE_FORMAT_VERSION = 225;
 const USAGE_CACHE_FILE = 'usage-results.json';
 
 /**

package/core/callers.js

@@ -2885,6 +2885,42 @@ function findCallers(index, name, options = {}) {
                 // modules must not exclude: a binding to an unresolved module
                 // whose first segment matches a project directory routes
                 // visible instead.
+                // Rust item renames are name-level ownership (fix #357): a
+                // bare call spelled by a `use path::name as local` alias
+                // denotes exactly the item that binding resolves to. Two
+                // renames of one source name from different modules
+                // (`use alpha::widget as a; use beta::widget as b`) used to
+                // fall through to file-level import evidence, which BOTH
+                // modules satisfy, so each pin confirmed both sites. The
+                // paired binding decides: resolves into a target file →
+                // confirmable; resolves to another project file → excluded
+                // other-definition-import; unresolvable → visible (a resolver
+                // gap is never exclusion evidence).
+                if (calledAs && !call.isMethod && !call.receiver &&
+                    fileEntry.language === 'rust' && call.name === calledAs) {
+                    const paired = (fileEntry.importBindings || []).filter(b =>
+                        b.alias === call.name);
+                    if (paired.length > 0) {
+                        const tFiles = new Set(targetDefs.map(d => d.file).filter(Boolean));
+                        let verdict = 'unknown';
+                        for (const b of paired) {
+                            const resolved = _rustBindingResolvedFiles(index, fileEntry, filePath, b);
+                            if (resolved.size === 0) { verdict = 'unknown'; break; }
+                            const hit = [...resolved].some(f => tFiles.has(f));
+                            if (hit) { verdict = 'target'; break; }
+                            verdict = 'other';
+                        }
+                        if (verdict === 'other') {
+                            recordExcluded(filePath, call.line, 'other-definition-import');
+                            continue;
+                        }
+                        if (verdict === 'unknown' && collectAccount) {
+                            routeUnverified(filePath, fileEntry, call, 'no-import-link', calledAs);
+                            continue;
+                        }
+                    }
+                }
+
                 if (!bindingId && !call.isMethod &&
                     langTraits(fileEntry.language)?.typeSystem === 'structural' &&
                     (fileEntry.importBindings || []).length > 0) {
@@ -4235,7 +4271,9 @@ function findCallers(index, name, options = {}) {
                     let aliasResolvedFile = null;
                     if (receiverName && !tTypes.has(receiverName)) {
                         for (const im of (fileEntry.importBindings || [])) {
-                            if (im.name !== receiverName) continue;
+                            // fix #357: Rust rename bindings carry the local
+                            // name as `alias` (the original is `name`).
+                            if ((im.alias || im.name) !== receiverName) continue;
                             // fix #353: C# `using BH = Beta.Helper` (and Java
                             // dotted paths) split on `.`; Rust paths on `::`.
                             const orig = String(im.module || '').split(/::|\./).pop();
@@ -11722,12 +11760,22 @@ function _calleeStructuralModuleRoute(index, fileEntry, call, language) {
 }
 
 function _calleeStructuralImportedNameRoute(index, fileEntry, call, language) {
-    const lookupName = call.resolvedName || call.name;
+    let lookupName = call.resolvedName || call.name;
     let bindings = (fileEntry?.importBindings || []).filter(b => b.name === lookupName);
     if (call.resolvedName && bindings.some(b => b.alias)) {
         const paired = bindings.filter(b => b.alias === call.name);
         if (paired.length > 0) bindings = paired;
     }
+    // fix #357: a call spelled by a rename's LOCAL alias (Rust `use m::a as
+    // b; b()`) pairs with exactly the binding carrying that alias, and the
+    // exported item is the binding's ORIGINAL name.
+    if (bindings.length === 0) {
+        const aliased = (fileEntry?.importBindings || []).filter(b => b.alias === call.name);
+        if (aliased.length > 0 && new Set(aliased.map(b => b.name)).size === 1) {
+            bindings = aliased;
+            lookupName = aliased[0].name;
+        }
+    }
     if (bindings.length === 0) return null;
     return _calleeStructuralBindingRoute(index, fileEntry, call, language, bindings, lookupName, true);
 }

package/core/index-ir.js

@@ -12,9 +12,14 @@ function createImportBindings(imports) {
     return imports.flatMap(item => (item.names || [])
         .filter(name => name && name !== '*' && name !== '_' && name !== '.')
         .map(name => {
-            const rename = (item.renames || []).find(candidate => candidate.original === name);
+            // A rename may be recorded under its original name (Python
+            // `from m import a as b` lists 'a') or under its local alias
+            // (Rust `use m::a as b` lists 'b', fix #357); both yield the
+            // binding {name: original, alias: local}.
+            const rename = (item.renames || []).find(candidate =>
+                candidate.original === name || candidate.local === name);
             return {
-                name,
+                name: rename ? rename.original : name,
                 module: item.module,
                 ...(item.type && { kind: item.type }),
                 ...(item.line != null && { line: item.line }),

package/languages/rust.js

@@ -3221,7 +3221,7 @@ function findImportsInCode(code, parser) {
         const right = String(suffix || '').replace(/^::/, '');
         return left && right ? `${left}::${right}` : left || right;
     };
-    const addLeaf = (module, localName, type = 'use', dynamic = false, line) => {
+    const addLeaf = (module, localName, type = 'use', dynamic = false, line, rename = null) => {
         if (!module || !localName) return;
         imports.push({
             module,
@@ -3229,6 +3229,7 @@ function findImportsInCode(code, parser) {
             type,
             dynamic,
             line,
+            ...(rename && { renames: [rename] }),
         });
     };
     const collectUseTree = (node, prefix, line) => {
@@ -3250,13 +3251,20 @@ function findImportsInCode(code, parser) {
             const pathNode = node.namedChild(0);
             const aliasNode = node.childForFieldName('alias') || node.namedChild(1);
             if (pathNode && aliasNode) {
-                addLeaf(joinUsePath(prefix, pathNode.text), aliasNode.text,
-                    'use', false, line);
                 // fix #353: `use alpha::widget as renamed; renamed()` — the
                 // alias pairing feeds findCallers' import-rename surface
                 // (calledAs), exactly like Python/JS `import x as y`.
+                // fix #357: `renames` pairs the alias with ITS record so
+                // createImportBindings emits {name: original, alias: local}
+                // (the #348 Python shape); two renames of one source name
+                // from different modules each pair with their own module
+                // instead of both bindings matching both calls. `names`
+                // keeps the local spelling (parser contract, imports command).
                 const original = String(pathNode.text).split('::').pop();
-                if (original && original !== aliasNode.text && original !== 'self') {
+                const renamed = original && original !== aliasNode.text && original !== 'self';
+                addLeaf(joinUsePath(prefix, pathNode.text), aliasNode.text,
+                    'use', false, line, renamed ? { original, local: aliasNode.text } : null);
+                if (renamed) {
                     if (!imports.aliases) imports.aliases = [];
                     imports.aliases.push({ original, local: aliasNode.text });
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "5.3.5",
+  "version": "5.3.6",
   "mcpName": "io.github.mleoca/ucn",
   "description": "Auditable AST code intelligence for AI agents: 18 task-oriented commands through one MCP tool, CLI, or agent skill. Supports JS/TS, Python, Go, Rust, Java, C, C++, C#, and HTML.",
   "main": "index.js",