ucn 5.5.0 → 5.5.1

package/core/rust-modules.js

@@ -89,11 +89,29 @@ function moduleTree(index) {
  */
 function rustPathModule(index, filePath, line, qualifier) {
     if (!isRustEntry(index.files.get(filePath)) || !qualifier) return null;
+    const tree = moduleTree(index);
+    const inline = tree.inlineByFile.get(filePath) || [];
+    // The answer depends on the line only through the inline modules around
+    // it (fix #405: path calls asked once per site; fix #405b: files with
+    // inline modules too).
+    const memo = tree.pathMemo || (tree.pathMemo = new Map());
+    let byFile = memo.get(filePath);
+    if (!byFile) memo.set(filePath, byFile = new Map());
+    const chain = inline.length > 0 ? rustInlineChainAt(inline, line) : null;
+    const key = chain?.length > 0 ? `${chain.join('::')}\0${qualifier}` : qualifier;
+    let resolved = byFile.get(key);
+    if (resolved === undefined) {
+        resolved = resolvePathModule(tree, filePath, line, qualifier, inline);
+        byFile.set(key, resolved);
+    }
+    return resolved;
+}
+
+function resolvePathModule(tree, filePath, line, qualifier, inline) {
     const segments = String(qualifier).split('::');
     if (segments.some(segment => !/^[A-Za-z_][A-Za-z0-9_]*$/.test(segment))) return null;
-    const tree = moduleTree(index);
     const own = tree.moduleOf(filePath);
-    const current = [...own.segs, ...rustInlineChainAt(tree.inlineByFile.get(filePath) || [], line)];
+    const current = [...own.segs, ...rustInlineChainAt(inline, line)];
     const has = segs => tree.entries.has(`${own.root}\0${segs.join('::')}`);
     let segs;
     let i = 0;

package/core/type-denotation.js

@@ -774,11 +774,14 @@ function rustScopedLine(index, filePath, line, name) {
     if (line == null) return null;
     const fileEntry = index.files.get(filePath);
     if (fileEntry?.language !== 'rust') return null;
-    const declares = (index.symbols.get(name) || []).some(definition => definition.file === filePath &&
-        (TYPE_KINDS.has(definition.type) || definition.type === 'type'));
-    const imports = (fileEntry.importBindings || []).some(binding =>
-        binding.name !== '*' && (binding.alias || binding.name) === name && binding.module);
-    return declares || imports ? line : null;
+    // Per file and name (fix #405: every `T::new()` site asked again).
+    const scoped = memoized(index, `scoped\x00${filePath}\x00${name}`, () => {
+        const declares = (index.symbols.get(name) || []).some(definition => definition.file === filePath &&
+            (TYPE_KINDS.has(definition.type) || definition.type === 'type'));
+        return declares || (fileEntry.importBindings || []).some(binding =>
+            binding.name !== '*' && (binding.alias || binding.name) === name && binding.module);
+    });
+    return scoped ? line : null;
 }
 
 /** Bindings visible at `line`: those of the innermost enclosing scope that
@@ -946,6 +949,30 @@ function projectTypeNamed(index, name) {
     return (index.symbols.get(name) || []).some(definition => TYPE_KINDS.has(definition.type));
 }
 
+/**
+ * The type a call record writes and what it denotes in its file. A record
+ * never changes once its file's calls are read, so the answer is kept per
+ * record object while the index lives (fix #405b: orientation refines every
+ * definition of a name over the same records, and each refinement asked
+ * again per record).
+ */
+function siteDenotation(index, filePath, fileEntry, call) {
+    const memos = memoOf(index);
+    let memo = memos.get('\x01site');
+    if (!memo) memos.set('\x01site', memo = new WeakMap());
+    let site = memo.get(call);
+    if (site === undefined) {
+        const written = siteWrittenType(index, fileEntry, call);
+        site = {
+            written,
+            denotation: written ? externalTypeDenotation(index, filePath, written.name, written.qualifier,
+                call.line, { unscoped: written.unscoped === true }) : null,
+        };
+        memo.set(call, site);
+    }
+    return site;
+}
+
 /**
  * Verdict for a call site against candidate target definitions (the pinned
  * targets on the caller side, every same-name callable on the callee side).
@@ -961,10 +988,7 @@ function externalTypeGate(index, filePath, fileEntry, call, targetsOrThunk) {
     // every project type with the method set satisfies; the existing
     // package-qualified physics routes it (possible dispatch).
     if (fileEntry.language === 'go') return null;
-    const written = siteWrittenType(index, fileEntry, call);
-    if (!written) return null;
-    const denotation = externalTypeDenotation(index, filePath, written.name, written.qualifier, call.line,
-        { unscoped: written.unscoped === true });
+    const { written, denotation } = siteDenotation(index, filePath, fileEntry, call);
     if (!denotation) return null;
     const { original, via } = denotation;
     // Only a real collision needs the gate: without a project type of that

package/languages/rust.js

@@ -126,6 +126,16 @@ function buildMacroItemRecoveryTree(code, parser, tree) {
     return { tree: recovered, itemCount, declarationNameStarts, callRecovery };
 }
 
+/**
+ * The item-body call recovery of an expanded file parsed by the caller
+ * (fix #405): what rustMacroItemCallRecovery computes for it once its
+ * declaration trees are primed with `tree`. Its walk builds the tree's flat
+ * node list, which the call extraction then reads.
+ */
+function rustExpandedItemRecovery(code, parser, tree) {
+    return buildMacroItemRecoveryTree(code, parser, tree)?.callRecovery || null;
+}
+
 /**
  * Rust macro invocation bodies are token trees, even when they contain item
  * declarations verbatim. Reparse only item-position bodies in a byte- and
@@ -2193,13 +2203,19 @@ const DECLARATION_NODE_TYPES = [
  * extracts them (fix #374: the declarations a macro expansion generates,
  * without walking the rest of the expanded file).
  */
-function parseDeclarationsIn(code, roots) {
+function parseDeclarationsIn(code, roots, { descendants = null } = {}) {
     const lines = code.split('\n');
     const functions = [], classes = [], stateObjects = [];
     const processedFn = new Set(), processedCls = new Set();
-    for (const root of roots) {
+    // `descendants(root, i)`: the root's descendant nodes the caller already
+    // listed (a superset of DECLARATION_NODE_TYPES, in document order).
+    for (let i = 0; i < roots.length; i++) {
+        const root = roots[i];
         const nodes = DECLARATION_NODE_TYPES.includes(root.type) ? [root] : [];
-        for (const node of nodes.concat(root.descendantsOfType(DECLARATION_NODE_TYPES))) {
+        const below = descendants
+            ? descendants(root, i).filter(node => DECLARATION_NODE_TYPES.includes(node.type))
+            : root.descendantsOfType(DECLARATION_NODE_TYPES);
+        for (const node of nodes.concat(below)) {
             _processFunction(node, functions, processedFn, lines, code);
             _processClass(node, classes, processedCls, lines, code);
             _processState(node, stateObjects, lines);
@@ -3737,8 +3753,17 @@ function rustFieldAliasOf(identNode) {
     return null;
 }
 
-function findCallsInCode(code, parser) {
-    const tree = parseTree(parser, code);
+/**
+ * Call records of Rust code. `options` (fix #405, macro-expansion calls):
+ * `tree` - the already parsed tree of `code` (an expanded file parsed with
+ * included ranges), whose item-recovery facts are `itemRecovery` (null when
+ * none); `skip(node)` - nodes whose subtrees are not read (other units of an
+ * expanded file: every scope the extractor keeps is a function's own, so a
+ * unit's records do not depend on its sibling units).
+ */
+function findCallsInCode(code, parser, options = {}) {
+    const tree = options.tree || parseTree(parser, code);
+    const skip = typeof options.skip === 'function' ? options.skip : null;
     const calls = [];
     // Words of every value-binding pattern seen so far in document order
     // (fix #369). A binding shadows a bare call only if it precedes the call,
@@ -4378,7 +4403,7 @@ function findCallsInCode(code, parser) {
     // Item bodies of item-position macros (`quickcheck! { fn p(..) { .. } }`,
     // fix #401) are parsed as items: their calls are read from that parse,
     // with their functions' scopes and local types, instead of as tokens.
-    const itemRecovery = rustMacroItemCallRecovery(code, parser);
+    const itemRecovery = options.tree ? (options.itemRecovery || null) : rustMacroItemCallRecovery(code, parser);
     const recoveredTokenTrees = new Set((itemRecovery?.ranges || []).map(([start]) => start - 1));
 
     const visitNode = (node) => {
@@ -5227,17 +5252,21 @@ function findCallsInCode(code, parser) {
             }
         }
     };
-    traverseTree(tree.rootNode, visitNode, { onLeave: leaveNode });
+    traverseTree(tree.rootNode, skip ? node => (skip(node) ? false : visitNode(node)) : visitNode,
+        { onLeave: leaveNode });
     if (itemRecovery) {
         const ranges = itemRecovery.ranges;
         const inside = node => ranges.some(([start, end]) => node.startIndex >= start && node.endIndex <= end);
         const overlaps = node => ranges.some(([start, end]) => node.startIndex < end && node.endIndex > start);
         traverseTree(itemRecovery.tree.rootNode, node => {
+            if (skip && skip(node)) return false;
             if (inside(node)) return visitNode(node);
             return overlaps(node);
         }, { onLeave: node => { if (inside(node)) leaveNode(node); } });
     }
 
+    // A tree handed in is an expanded file: no unexpanded item bodies.
+    if (options.tree) return calls;
     const declaration = declarationTrees(code, parser);
     if (!declaration.macroItemRecovery) return calls;
     const functions = findFunctions(code, parser);
@@ -5974,6 +6003,8 @@ function isEntryPoint(symbol) {
 
 module.exports = {
     primeDeclarationTrees,
+    DECLARATION_NODE_TYPES,
+    rustExpandedItemRecovery,
     parseDeclarationsIn,
     rustMacroInvocationContext,
     findFunctions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "5.5.0",
+  "version": "5.5.1",
   "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",