ucn 5.5.0 → 5.5.2

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
@@ -682,7 +692,6 @@ function extractAttributesWithArgs(node, codeOrLines) {
 }
 
 // --- Module-scope constants for state object detection ---
-const _STATE_PATTERN = /^([A-Z][A-Z0-9_]+|DEFAULT_[A-Z_]+)$/;
 
 // --- Single-pass helpers: extracted from find* callbacks ---
 
@@ -747,7 +756,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
         const paramsNode = node.childForFieldName('parameters');
 
         if (nameNode) {
-            const { startLine, endLine, indent } = nodeToLocation(node, lines);
+            const { startLine, endLine, indent, sourceSpan } = nodeToLocation(node, lines);
             const text = node.text;
 
             const qualifiers = rustFunctionQualifiers(node);
@@ -788,6 +797,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
                 ...(callbackParamTypes && { callbackParamTypes }),
                 startLine,
                 endLine,
+                sourceSpan,
                 indent,
                 modifiers,
                 ...(returnType && { returnType }),
@@ -816,7 +826,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
                     const fName = child.childForFieldName('name');
                     const fParams = child.childForFieldName('parameters');
                     if (fName) {
-                        const { startLine, endLine, indent } = nodeToLocation(child, lines);
+                        const { startLine, endLine, indent, sourceSpan } = nodeToLocation(child, lines);
                         const visibility = extractVisibility(child.text);
                         const returnType = extractReturnType(child);
                         const docstring = extractRustDocstring(lines, startLine);
@@ -833,6 +843,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
                             ...(iteratorItemType && { iteratorItemType }),
                             startLine,
                             endLine,
+                            sourceSpan,
                             indent,
                             modifiers,
                             ...(returnType && { returnType }),
@@ -1068,7 +1079,7 @@ function _processClass(node, types, processedRanges, lines, code) {
 
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
-            const { startLine, endLine } = nodeToLocation(node, lines);
+            const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
             const docstring = extractRustDocstring(lines, startLine);
             const visibility = extractVisibility(node.text);
             const generics = extractGenerics(node);
@@ -1082,6 +1093,7 @@ function _processClass(node, types, processedRanges, lines, code) {
                 name: nameNode.text,
                 startLine,
                 endLine,
+                sourceSpan,
                 type: node.type === 'union_item' ? 'union' : 'struct',
                 members,
                 modifiers,
@@ -1102,7 +1114,7 @@ function _processClass(node, types, processedRanges, lines, code) {
 
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
-            const { startLine, endLine } = nodeToLocation(node, lines);
+            const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
             const docstring = extractRustDocstring(lines, startLine);
             const visibility = extractVisibility(node.text);
             const generics = extractGenerics(node);
@@ -1114,6 +1126,7 @@ function _processClass(node, types, processedRanges, lines, code) {
                 name: nameNode.text,
                 startLine,
                 endLine,
+                sourceSpan,
                 type: 'enum',
                 members: extractEnumVariants(node, lines),
                 modifiers,
@@ -1133,7 +1146,7 @@ function _processClass(node, types, processedRanges, lines, code) {
 
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
-            const { startLine, endLine } = nodeToLocation(node, lines);
+            const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
             const docstring = extractRustDocstring(lines, startLine);
             const visibility = extractVisibility(node.text);
             const generics = extractGenerics(node);
@@ -1143,6 +1156,7 @@ function _processClass(node, types, processedRanges, lines, code) {
                 name: nameNode.text,
                 startLine,
                 endLine,
+                sourceSpan,
                 type: 'trait',
                 members: extractTraitMembers(node, lines),
                 modifiers: visibility ? [visibility] : [],
@@ -1161,7 +1175,7 @@ function _processClass(node, types, processedRanges, lines, code) {
         if (processedRanges.has(rangeKey)) return true;
         processedRanges.add(rangeKey);
 
-        const { startLine, endLine } = nodeToLocation(node, lines);
+        const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
         const implInfo = extractImplInfo(node);
         const docstring = extractRustDocstring(lines, startLine);
         const derefTarget = extractDerefTarget(node, implInfo.traitName);
@@ -1177,6 +1191,7 @@ function _processClass(node, types, processedRanges, lines, code) {
             name: implInfo.name,
             startLine,
             endLine,
+            sourceSpan,
             type: 'impl',
             traitName: implInfo.traitName,
                 ...rustBlockItemScope(node),
@@ -1200,7 +1215,7 @@ function _processClass(node, types, processedRanges, lines, code) {
 
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
-            const { startLine, endLine } = nodeToLocation(node, lines);
+            const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
             const docstring = extractRustDocstring(lines, startLine);
             const visibility = extractVisibility(node.text);
             const attributes = extractAttributes(node, lines);
@@ -1211,6 +1226,7 @@ function _processClass(node, types, processedRanges, lines, code) {
                 name: nameNode.text,
                 startLine,
                 endLine,
+                sourceSpan,
                 type: 'module',
                 members: [],
                 modifiers,
@@ -1228,7 +1244,7 @@ function _processClass(node, types, processedRanges, lines, code) {
 
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
-            const { startLine, endLine } = nodeToLocation(node, lines);
+            const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
             const docstring = extractRustDocstring(lines, startLine);
             const inferred = _inferMacroReturn(node, nameNode.text);
 
@@ -1255,6 +1271,7 @@ function _processClass(node, types, processedRanges, lines, code) {
                 name: nameNode.text,
                 startLine,
                 endLine,
+                sourceSpan,
                 type: 'macro',
                 members: [],
                 modifiers,
@@ -1284,7 +1301,7 @@ function _processClass(node, types, processedRanges, lines, code) {
 
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
-            const { startLine, endLine } = nodeToLocation(node, lines);
+            const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
             const docstring = extractRustDocstring(lines, startLine);
             const visibility = extractVisibility(node.text);
             // `pub type StyledString = SpannedString<Style>;` — the alias IS
@@ -1300,6 +1317,7 @@ function _processClass(node, types, processedRanges, lines, code) {
                 name: nameNode.text,
                 startLine,
                 endLine,
+                sourceSpan,
                 type: 'type',
                 members: [],
                 modifiers: visibility ? [visibility] : [],
@@ -1367,15 +1385,19 @@ function extractDerefTarget(implNode, traitName) {
  * Returns true if node was matched, false otherwise
  */
 function _processState(node, objects, lines) {
-    // Handle const and static items (only top-level). The declared type
+    // Const and static items have value identity regardless of spelling or
+    // module nesting. Associated items are extracted with their owner.
+    // The declared type
     // (fix #392) types the item when it is a method receiver (`FLAGS.iter()`).
     if (node.type === 'const_item' || node.type === 'static_item') {
-        if (!node.parent || node.parent.type !== 'source_file') return false;
+        for (let scope = node.parent; scope; scope = scope.parent) {
+            if (scope.type === 'impl_item' || scope.type === 'trait_item') return false;
+        }
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
             const name = nameNode.text;
-            if (_STATE_PATTERN.test(name)) {
-                const { startLine, endLine } = nodeToLocation(node, lines);
+            {
+                const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
                 // Only a plain type path (behind any references) is recorded:
                 // a generic wrapper (`Lazy<T>`, `Mutex<T>`) owns the methods
                 // or derefs to its argument. A `static mut` is never typed.
@@ -1389,7 +1411,7 @@ function _processState(node, objects, lines) {
                     node.children.some(child => child.type === 'mutable_specifier');
                 const plain = typeNode && (typeNode.type === 'type_identifier' ||
                     typeNode.type === 'scoped_type_identifier');
-                objects.push({ name, startLine, endLine,
+                objects.push({ name, startLine, endLine, sourceSpan, ...rustBlockItemScope(node),
                     ...(plain && !mutable && { valueType: typeNode.text,
                         ...(deref && { valueDerefVia: deref.via }) }) });
             }
@@ -1517,6 +1539,45 @@ function rustRawPointerTypeOf(typeNode) {
     return current.children.some(child => child.type === 'mutable_specifier') ? '*mut' : '*const';
 }
 
+const primitiveTypeInfoCache = new (require('../core/source-memo').BoundedMap)({ maxEntries: 256 });
+const derefTypeInfoCache = new (require('../core/source-memo').BoundedMap)({ maxEntries: 256 });
+
+/** Source-only target of a written deref wrapper; core verifies its binding. */
+function getDerefTypeInfo(text, parser) {
+    if (typeof text !== 'string' || !text.includes('<')) return null;
+    if (derefTypeInfoCache.has(text)) return derefTypeInfoCache.get(text);
+    const tree = parseTree(parser, `type __ucn_type = ${text};`);
+    const items = tree.rootNode.namedChildren.filter(node => !node.type.endsWith('comment'));
+    const item = items.length === 1 && items[0].type === 'type_item' ? items[0] : null;
+    const declared = !tree.rootNode.hasError && item?.childForFieldName('type');
+    const chain = declared && rustStdDerefChain(declared);
+    const info = chain ? Object.freeze({
+        via: Object.freeze([...chain.via]), innerText: chain.inner.text,
+    }) : null;
+    derefTypeInfoCache.set(text, info);
+    return info;
+}
+
+/** Primitive identity of a declared type, independent of nominal names. */
+function getPrimitiveTypeInfo(text, parser) {
+    if (typeof text !== 'string' || (!text.includes('[') && !text.includes('*'))) return null;
+    if (primitiveTypeInfoCache.has(text)) return primitiveTypeInfoCache.get(text);
+    const tree = parseTree(parser, `type __ucn_type = ${text};`);
+    const items = tree.rootNode.namedChildren.filter(node => !node.type.endsWith('comment'));
+    const item = items.length === 1 && items[0].type === 'type_item' ? items[0] : null;
+    const declared = !tree.rootNode.hasError && item?.childForFieldName('type');
+    const deref = declared && rustDerefTypedName(declared);
+    const inner = deref?.inner || declared;
+    const type = rustSliceTypeOf(inner) || rustRawPointerTypeOf(inner);
+    const info = type ? Object.freeze({
+        type,
+        ...(deref && { derefVia: Object.freeze([...deref.via]),
+            derefOuterRef: deref.outerRef }),
+    }) : null;
+    primitiveTypeInfoCache.set(text, info);
+    return info;
+}
+
 /**
  * Standard-library wrappers whose `Deref::Target` is their (first) type
  * argument (fix #401): smart pointers, `ManuallyDrop`, lazy cells, `RefCell`
@@ -1671,11 +1732,12 @@ function extractStructFields(structNode, codeOrLines) {
             // `self.0.method()` exactly.
             if (field.type === 'visibility_modifier' ||
                 field.type === 'attribute_item') continue;
-            const { startLine, endLine } = nodeToLocation(field, code);
+            const { startLine, endLine, sourceSpan } = nodeToLocation(field, code);
             fields.push({
                 name: String(position++),
                 startLine,
                 endLine,
+                sourceSpan,
                 memberType: 'field',
                 fieldType: field.text,
             });
@@ -1686,7 +1748,7 @@ function extractStructFields(structNode, codeOrLines) {
     for (let i = 0; i < bodyNode.namedChildCount; i++) {
         const field = bodyNode.namedChild(i);
         if (field.type === 'field_declaration') {
-            const { startLine, endLine } = nodeToLocation(field, code);
+            const { startLine, endLine, sourceSpan } = nodeToLocation(field, code);
             const nameNode = field.childForFieldName('name');
             const typeNode = field.childForFieldName('type');
 
@@ -1700,6 +1762,7 @@ function extractStructFields(structNode, codeOrLines) {
                     name: nameNode.text,
                     startLine,
                     endLine,
+                    sourceSpan,
                     memberType: 'field',
                     ...(visibility && { modifiers: [visibility] }),
                     ...(typeNode && { fieldType: typeNode.text })
@@ -1853,7 +1916,7 @@ function extractEnumVariants(enumNode, codeOrLines) {
         if (child.type === 'enum_variant') {
             const nameNode = child.childForFieldName('name');
             if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(child, code);
+                const { startLine, endLine, sourceSpan } = nodeToLocation(child, code);
                 // Check for tuple/struct variant data
                 let params = undefined;
                 // A unit variant names its value, a tuple variant its
@@ -1870,6 +1933,7 @@ function extractEnumVariants(enumNode, codeOrLines) {
                     name: nameNode.text,
                     startLine,
                     endLine,
+                    sourceSpan,
                     memberType: 'variant',
                     ...(params !== undefined && { params }),
                     ...(valueShape && { valueShape }),
@@ -1894,7 +1958,7 @@ function extractTraitMembers(traitNode, codeOrLines) {
         if (child.type === 'function_item' || child.type === 'function_signature_item') {
             const nameNode = child.childForFieldName('name');
             if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(child, code);
+                const { startLine, endLine, sourceSpan } = nodeToLocation(child, code);
                 const paramsNode = child.childForFieldName('parameters');
                 const returnType = extractReturnType(child);
                 const iteratorItemType = extractRustIteratorItemType(child);
@@ -1911,6 +1975,7 @@ function extractTraitMembers(traitNode, codeOrLines) {
                     name: nameNode.text,
                     startLine,
                     endLine,
+                    sourceSpan,
                     memberType: 'method',
                     isMethod: true,
                     ...(qualifiers.async && { isAsync: true }),
@@ -2050,7 +2115,7 @@ function extractImplMembers(implNode, codeOrLines, typeName) {
             const paramsNode = child.childForFieldName('parameters');
 
             if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(child, code);
+                const { startLine, endLine, sourceSpan } = nodeToLocation(child, code);
                 const text = child.text;
                 const returnType = extractReturnType(child);
                 const iteratorItemType = extractRustIteratorItemType(child);
@@ -2100,6 +2165,7 @@ function extractImplMembers(implNode, codeOrLines, typeName) {
                     ...(callbackParamTypes && { callbackParamTypes }),
                     startLine,
                     endLine,
+                    sourceSpan,
                     memberType: 'method',
                     isAsync: qualifiers.async,
                     isMethod: hasSelf,  // Only true methods (with self) — associated functions are false
@@ -2179,10 +2245,51 @@ function parse(code, parser) {
             const names = rustAsyncClosureNames(tree);
             return names.length > 0 ? { asyncClosureNames: names } : {};
         })(),
+        ...(() => {
+            const itemMacros = rustModuleItemMacros(tree.rootNode);
+            return itemMacros.length > 0 ? { itemMacros } : {};
+        })(),
         imports: [], exports: [],
     };
 }
 
+/**
+ * Macro invocations in item position of a module (fix #422): `name!(..)`
+ * directly in a file or an inline module body, with the identifier words
+ * of their arguments. Such an invocation may declare items named by those
+ * words, so a lookup of one of them in that module cannot rule out a name
+ * the expansion binds.
+ */
+function rustModuleItemMacros(root) {
+    const out = [];
+    const visit = container => {
+        for (let i = 0; i < container.namedChildCount; i++) {
+            let item = container.namedChild(i);
+            if (item.type === 'expression_statement' && item.namedChildCount === 1) item = item.namedChild(0);
+            if (item.type === 'macro_invocation') {
+                const macro = item.childForFieldName('macro');
+                if (!macro) continue;
+                const name = macro.type === 'scoped_identifier'
+                    ? macro.childForFieldName('name')?.text : macro.text;
+                if (!name) continue;
+                const words = new Set();
+                for (const child of item.namedChildren) {
+                    if (child.type !== 'token_tree') continue;
+                    for (const token of child.descendantsOfType('identifier')) words.add(token.text);
+                }
+                out.push({ name, line: item.startPosition.row + 1, words: [...words].sort() });
+                continue;
+            }
+            if (item.type === 'mod_item') {
+                const body = item.childForFieldName('body');
+                if (body) visit(body);
+            }
+        }
+    };
+    visit(root);
+    return out;
+}
+
 const DECLARATION_NODE_TYPES = [
     'function_item', 'foreign_mod_item', 'struct_item', 'union_item', 'enum_item', 'trait_item', 'impl_item',
     'mod_item', 'macro_definition', 'type_item', 'const_item', 'static_item',
@@ -2193,13 +2300,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);
@@ -2686,7 +2799,10 @@ function extractCallsFromTokenTree(tree, enclosingFunction, calls, getReceiverTy
         // associated-call shape `Type::default()`. It is still an AST token,
         // so admitting it here preserves the AST-first rule while recovering
         // calls nested inside macro token trees (assert_eq!, matches!, ...).
-        if (tok.type !== 'identifier' && tok.type !== 'default') continue;
+        // Primitive type words can also name value-namespace functions and
+        // methods (`width.char(...)`). The following call-shape check still
+        // requires argument tokens, so type annotations are not calls.
+        if (tok.type !== 'identifier' && tok.type !== 'default' && tok.type !== 'primitive_type') continue;
         const next = children[i + 1];
         const prev = children[i - 1];
         // $metavariable(...) — a macro fragment, not a named call
@@ -2771,6 +2887,8 @@ function extractCallsFromTokenTree(tree, enclosingFunction, calls, getReceiverTy
                 isPathCall: true,
                 receiver: segments.length > 0 ? segments.join('::') : undefined,
                 ...(tokenArgTypes && { argTypes: tokenArgTypes }),
+                ...(segments.length > 0 && rustReceiverScopeBindingField(tok, segments.join('::'))),
+                ...(segments.length > 0 && rustTokenTreeMayBind(tok, segments[0]) && { macroScopeUnknown: true }),
                 ...macroFields,
                 enclosingFunction
             };
@@ -2860,6 +2978,9 @@ function extractCallsFromTokenTree(tree, enclosingFunction, calls, getReceiverTy
                 callEnd: callArgs.endIndex,
                 isMethod: false,
                 ...macroFields,
+                ...(rustBareNameShadowedByLocal(tok, tok.text) && { localShadow: true }),
+                ...rustScopeBindingField(tok, tok.text),
+                ...(rustTokenTreeMayBind(tok, tok.text) && { macroScopeUnknown: true }),
                 enclosingFunction
             };
             calls.push(record);
@@ -3369,6 +3490,41 @@ function rustMacroCallIdentity(macroNode) {
  * value then has the fn's declared return type, which lets a trait path call
  * (`Trait::assoc(..)`) infer its Self from the declaration.
  */
+/**
+ * Where a call's value goes with a written type (fix #422): a struct
+ * expression's field (`Self { inner: Default::default() }` ->
+ * `{ fieldInit: { struct: 'Self', field: 'inner' } }`) or an annotated `let`
+ * (`let x: T = T::new()` -> `{ expectedType: 'T' }`). The type a
+ * Self-returning trait member is selected by.
+ */
+function rustExpectedTypeFields(node) {
+    const parent = node.parent;
+    if (parent?.type === 'field_initializer' && sameNode(parent.childForFieldName('value'), node)) {
+        const field = parent.childForFieldName('field');
+        const expression = parent.parent?.type === 'field_initializer_list' ? parent.parent.parent : null;
+        const nameNode = expression?.type === 'struct_expression' ? expression.childForFieldName('name') : null;
+        const struct = rustPlainPathText(nameNode?.type === 'generic_type_with_turbofish'
+            ? nameNode.childForFieldName('type') : nameNode) || (nameNode?.type === 'type_identifier' ? nameNode.text : null);
+        if (field?.type === 'field_identifier' && struct) return { fieldInit: { struct, field: field.text } };
+        return null;
+    }
+    if (parent?.type === 'let_declaration' && sameNode(parent.childForFieldName('value'), node)) {
+        const type = parent.childForFieldName('type');
+        if (type) return { expectedType: type.text.replace(/\s+/g, '') };
+    }
+    // An argument of a plain or path function call (`run(Default::default())`,
+    // fix #434): the callee's declared parameter type at that position.
+    if (parent?.type === 'arguments' && parent.parent?.type === 'call_expression') {
+        const callee = parent.parent.childForFieldName('function');
+        const path = callee?.type === 'identifier' ? callee.text : rustPlainPathText(callee);
+        if (!path) return null;
+        const index = parent.namedChildren.filter(child => !child.type.endsWith('comment'))
+            .findIndex(child => sameNode(child, node));
+        if (index >= 0) return { argumentOf: { callee: path, index } };
+    }
+    return null;
+}
+
 function rustFunctionReturnPosition(node) {
     const parent = node.parent;
     if (!parent) return false;
@@ -3426,6 +3582,283 @@ function rustPatternBindsName(pattern, name) {
     return false;
 }
 
+/**
+ * Join two Rust use-path pieces (`a::b` + `c` -> `a::b::c`).
+ */
+function rustJoinUsePath(prefix, suffix) {
+    // Paths are compared as written without whitespace (`a:: b` is `a::b`).
+    const left = String(prefix || '').replace(/\s+/g, '').replace(/::$/, '');
+    const right = String(suffix || '').replace(/\s+/g, '').replace(/^::/, '');
+    return left && right ? `${left}::${right}` : left || right;
+}
+
+/**
+ * Every binding a `use` tree makes (fix #422): `visit({ path, local,
+ * original })` for a named leaf (the path ends with the item's ORIGINAL
+ * name; `local` is the name the scope binds, an alias for `as`), and
+ * `visit({ path, glob: true })` for `path::*`. `use a::b::{self}` binds
+ * `b` to the path `a::b`.
+ */
+function walkRustUseTree(node, prefix, visit) {
+    if (!node || node.type === 'visibility_modifier') return;
+    if (node.type === 'scoped_use_list') {
+        const pathNode = node.childForFieldName('path');
+        const listNode = node.childForFieldName('list');
+        if (listNode) walkRustUseTree(listNode, rustJoinUsePath(prefix, pathNode?.text), visit);
+        return;
+    }
+    if (node.type === 'use_list') {
+        for (let i = 0; i < node.namedChildCount; i++) walkRustUseTree(node.namedChild(i), prefix, visit);
+        return;
+    }
+    if (node.type === 'use_as_clause') {
+        const pathNode = node.namedChild(0);
+        const aliasNode = node.childForFieldName('alias') || node.namedChild(1);
+        if (pathNode && aliasNode) {
+            const original = String(pathNode.text).replace(/\s+/g, '').split('::').pop();
+            visit({ path: rustJoinUsePath(prefix, pathNode.text), local: aliasNode.text, original, node });
+        }
+        return;
+    }
+    if (node.type === 'use_wildcard') {
+        visit({ path: rustJoinUsePath(prefix, node.namedChild(0)?.text), glob: true, node });
+        return;
+    }
+    if (node.type === 'identifier' || node.type === 'scoped_identifier' ||
+        node.type === 'crate' || node.type === 'self' || node.type === 'super') {
+        if (node.text === 'self' && prefix) {
+            const local = prefix.split('::').pop();
+            visit({ path: prefix, local, original: local, node });
+            return;
+        }
+        const local = node.text.replace(/\s+/g, '').split('::').pop();
+        visit({ path: rustJoinUsePath(prefix, node.text), local, original: local, node });
+    }
+}
+
+// Item kinds a block declares in the value namespace, and in the type
+// namespace (fix #422). A tuple or unit struct names a value too.
+const RUST_BLOCK_VALUE_ITEMS = new Set(['function_item', 'const_item', 'static_item']);
+const RUST_BLOCK_TYPE_ITEMS = new Set(['struct_item', 'enum_item', 'union_item', 'trait_item',
+    'type_item', 'mod_item']);
+
+/**
+ * The names a block's own items and `use` declarations bind (fix #422):
+ * `{ value: Map, type: Map, globs }`, each map name -> `{ kind: 'use', path,
+ * line }` or `{ kind: 'item', line }`. Rust resolves a name through the
+ * innermost block that binds it, its explicit names before its globs.
+ */
+function rustBlockBindingTable(block) {
+    let value = null;
+    let type = null;
+    let globs = null;
+    const bind = (map, name, binding) => {
+        if (!name) return map;
+        const out = map || new Map();
+        if (!out.has(name)) out.set(name, binding);
+        return out;
+    };
+    for (let i = 0; i < block.namedChildCount; i++) {
+        const item = block.namedChild(i);
+        if (item.type === 'use_declaration') {
+            const line = item.startPosition.row + 1;
+            for (let j = 0; j < item.namedChildCount; j++) {
+                walkRustUseTree(item.namedChild(j), '', leaf => {
+                    if (leaf.glob) {
+                        if (leaf.path) (globs || (globs = [])).push(leaf.path);
+                        return;
+                    }
+                    const binding = { kind: 'use', path: leaf.path, line };
+                    value = bind(value, leaf.local, binding);
+                    type = bind(type, leaf.local, binding);
+                });
+            }
+            continue;
+        }
+        if (item.type === 'foreign_mod_item') {
+            const body = item.namedChildren.find(child => child.type === 'declaration_list');
+            for (const decl of body?.namedChildren || []) {
+                if (decl.type !== 'function_signature_item' && decl.type !== 'static_item') continue;
+                const nameNode = decl.childForFieldName('name');
+                value = bind(value, nameNode?.text, { kind: 'item', line: decl.startPosition.row + 1 });
+            }
+            continue;
+        }
+        const nameNode = (RUST_BLOCK_VALUE_ITEMS.has(item.type) || RUST_BLOCK_TYPE_ITEMS.has(item.type))
+            ? item.childForFieldName('name') : null;
+        if (!nameNode) continue;
+        const binding = { kind: 'item', line: item.startPosition.row + 1 };
+        if (RUST_BLOCK_VALUE_ITEMS.has(item.type)) {
+            value = bind(value, nameNode.text, binding);
+            continue;
+        }
+        type = bind(type, nameNode.text, binding);
+        if (item.type === 'struct_item' && rustStructValueShape(item)) value = bind(value, nameNode.text, binding);
+    }
+    return value || type || globs ? { value, type, globs } : EMPTY_BLOCK_TABLE;
+}
+
+const EMPTY_BLOCK_TABLE = Object.freeze({ value: null, type: null, globs: null });
+
+/**
+ * What the enclosing blocks of `node` bind `name` to in namespace `ns`
+ * ('value' or 'type'), fix #422: the innermost block naming it explicitly
+ * (`{ kind, path?, line }`), with `innerGlobs` when a nearer block has glob
+ * imports that may provide it, or `{ kind: 'globs', paths }` when only
+ * blocks' globs may. null when no block between the node and its module
+ * binds the name (the module's own scope decides). Items of outer blocks
+ * are visible inside nested fns and impls; an inline module starts a new
+ * scope.
+ */
+const rustBlockTablesByTree = new WeakMap();
+
+/** The memo of block binding tables for the tree holding `node`. */
+function rustBlockTables(node) {
+    const tree = node?.tree;
+    if (!tree) return new Map();
+    let tables = rustBlockTablesByTree.get(tree);
+    if (!tables) rustBlockTablesByTree.set(tree, tables = new Map());
+    return tables;
+}
+
+/**
+ * The receiver a bracketed path head spells (fix #422): `<T as Trait>` ->
+ * `{ receiver: 'Trait', selfType: 'T' }`, `<T>` -> `{ receiver: 'T' }`;
+ * null for any other head.
+ */
+function rustQualifiedPathHead(pathNode) {
+    if (pathNode?.type !== 'bracketed_type') return null;
+    const inner = pathNode.namedChild(0);
+    const plainPath = n => n && (n.type === 'type_identifier' || n.type === 'scoped_type_identifier' ||
+        n.type === 'identifier' || n.type === 'scoped_identifier') ? n.text.replace(/\s+/g, '') : null;
+    if (inner?.type === 'qualified_type') {
+        const trait = plainPath(inner.childForFieldName('alias'));
+        if (!trait) return null;
+        const selfType = plainPath(inner.childForFieldName('type'));
+        return { receiver: trait, ...(selfType && { selfType }) };
+    }
+    const typeName = plainPath(inner);
+    return typeName ? { receiver: typeName } : null;
+}
+
+const rustTokenTreeScopeFacts = new WeakMap();
+const RUST_SCOPING_KEYWORD = /\b(?:use|fn|mod|impl)\b/;
+
+/**
+ * Whether the macro invocation holding a token may bind `name` itself
+ * (fix #422): its tokens hold a `use`, `fn`, `mod` or `impl` keyword (items
+ * and imports scoped by what the macro expands to), or spell `name` other
+ * than as a callee (a `let`, closure parameter or pattern). The scopes
+ * around the invocation then do not decide what the call names. The tokens
+ * are read only when the invocation's text can hold such a token: every
+ * keyword token spells its keyword there, and a second token spelling the
+ * name spells it a second time.
+ */
+function rustTokenTreeMayBind(token, name) {
+    let top = null;
+    for (let p = token.parent; p && p.type === 'token_tree'; p = p.parent) top = p;
+    if (!top) return false;
+    const tree = top.tree;
+    let byTree = tree ? rustTokenTreeScopeFacts.get(tree) : null;
+    if (tree && !byTree) rustTokenTreeScopeFacts.set(tree, byTree = new Map());
+    let facts = byTree?.get(top.id);
+    if (!facts) {
+        const text = top.text;
+        facts = { text, keyword: RUST_SCOPING_KEYWORD.test(text), tokens: null };
+        byTree?.set(top.id, facts);
+    }
+    const tokens = () => facts.tokens || (facts.tokens = rustTokenTreeTokens(top));
+    if (facts.keyword && tokens().scoped) return true;
+    return rustWordSpelledTwice(facts.text, name) && tokens().words.has(name);
+}
+
+/** The keyword tokens and the non-callee identifier words of a token tree. */
+function rustTokenTreeTokens(top) {
+    const facts = { scoped: false, words: new Set() };
+    const visit = node => {
+        const children = node.children;
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            const type = child.type;
+            if (type === 'use' || type === 'fn' || type === 'mod' || type === 'impl') facts.scoped = true;
+            if (type === 'token_tree') { visit(child); continue; }
+            if (type !== 'identifier') continue;
+            const next = children[i + 1];
+            const callee = next && ((next.type === 'token_tree' && next.child(0)?.type === '(') ||
+                next.type === '!' || next.type === '::');
+            if (!callee) facts.words.add(child.text);
+        }
+    };
+    visit(top);
+    return facts;
+}
+
+/** ASCII identifier characters: any other character counts as a boundary, so no token is missed. */
+function rustAsciiWordChar(code) {
+    return (code >= 48 && code <= 57) || (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || code === 95;
+}
+
+/** Whether `word` stands at least twice in `text` between non-word characters. */
+function rustWordSpelledTwice(text, word) {
+    if (!word) return false;
+    let count = 0;
+    for (let at = text.indexOf(word); at !== -1; at = text.indexOf(word, at + 1)) {
+        if (at > 0 && rustAsciiWordChar(text.charCodeAt(at - 1))) continue;
+        if (rustAsciiWordChar(text.charCodeAt(at + word.length))) continue;
+        if (++count >= 2) return true;
+    }
+    return false;
+}
+
+/**
+ * A plain path's text without whitespace or type arguments (`a::b::T`,
+ * `Vec::<u8>` -> `Vec`), or null for any other path head.
+ */
+function rustPlainPathText(pathNode) {
+    if (!pathNode) return null;
+    if (pathNode.type === 'generic_type') return rustPlainPathText(pathNode.childForFieldName('type'));
+    if (!['identifier', 'scoped_identifier', 'type_identifier', 'scoped_type_identifier',
+        'self', 'super', 'crate'].includes(pathNode.type)) return null;
+    const text = pathNode.text.replace(/\s+/g, '');
+    return /^[A-Za-z_][A-Za-z0-9_]*(::[A-Za-z_][A-Za-z0-9_]*)*$/.test(text) ? text : null;
+}
+
+/** `scopeBinding` record field of a bare value name (fix #422), or null. */
+function rustScopeBindingField(node, name) {
+    const binding = rustBlockScopeBinding(node, name, 'value', rustBlockTables(node));
+    return binding ? { scopeBinding: binding } : null;
+}
+
+/** `receiverScopeBinding` of a path's first segment in the type namespace (fix #422). */
+function rustReceiverScopeBindingField(node, receiver) {
+    const head = String(receiver || '').split('::')[0];
+    if (!head || head === 'crate' || head === 'self' || head === 'super' || head === 'Self' ||
+        !/^[A-Za-z_][A-Za-z0-9_]*$/.test(head)) return null;
+    const binding = rustBlockScopeBinding(node, head, 'type', rustBlockTables(node));
+    return binding ? { receiverScopeBinding: binding } : null;
+}
+
+function rustBlockScopeBinding(node, name, ns, tables) {
+    let globs = null;
+    for (let p = node.parent; p; p = p.parent) {
+        if (p.type === 'mod_item' || p.type === 'source_file') break;
+        if (p.type !== 'block') continue;
+        let table = tables.get(p.id);
+        if (!table) {
+            table = rustBlockBindingTable(p);
+            tables.set(p.id, table);
+        }
+        const hit = table[ns]?.get(name);
+        if (hit) {
+            const binding = { ...hit };
+            if (globs) binding.innerGlobs = globs;
+            return binding;
+        }
+        if (table.globs) globs = (globs || []).concat(table.globs);
+    }
+    return globs ? { kind: 'globs', paths: globs } : null;
+}
+
 function rustBareNameShadowedByLocal(callNode, name) {
     let child = callNode;
     for (let p = callNode.parent; p; child = p, p = p.parent) {
@@ -3737,8 +4170,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 +4820,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) => {
@@ -4501,6 +4943,7 @@ function findCallsInCode(code, parser) {
                     ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp }),
                     ...(mayBeLocallyBound(funcNode.text) &&
                         rustBareNameShadowedByLocal(node, funcNode.text) && { localShadow: true }),
+                    ...rustScopeBindingField(node, funcNode.text),
                 });
             } else if (funcNode.type === 'field_expression') {
                 // Method call: obj.method()
@@ -4847,8 +5290,13 @@ function findCallsInCode(code, parser) {
                 // Turbofish receivers (`Vec::<String>::new`) carry the type
                 // arguments as their own `::`-split segments — drop them so
                 // the receiver is the plain type/module path (fix #222).
-                const recvSegments = segments.slice(0, -1)
+                let recvSegments = segments.slice(0, -1)
                     .filter(s => !s.startsWith('<') && !s.endsWith('>'));
+                // A qualified path (fix #422): `<T as Trait>::m(x)` names
+                // the trait's member with Self = T; `<T>::m()` is `T::m()`.
+                const qualified = rustQualifiedPathHead(funcNode.childForFieldName('path'));
+                if (qualified) recvSegments = qualified.receiver.split('::');
+                const receiverText = recvSegments.length > 0 ? recvSegments.join('::') : undefined;
                 calls.push({
                     name: name,
                     line: node.startPosition.row + 1,
@@ -4858,7 +5306,9 @@ function findCallsInCode(code, parser) {
                     ...(consumingMethod && { consumingMethod }),
                     isMethod: segments.length > 1,
                     isPathCall: true,  // Distinguishes Type::func()/module::func() from obj.method()
-                    receiver: recvSegments.length > 0 ? recvSegments.join('::') : undefined,
+                    receiver: receiverText,
+                    ...(qualified?.selfType && { receiverQualifiedSelf: qualified.selfType }),
+                    ...(receiverText && rustReceiverScopeBindingField(node, receiverText)),
                     argCount,
                     ...(segments.length > 1 && (() => {
                         const argTypes = rustArgTypesOfNode(argNodes, astArgTypeOfName);
@@ -4872,6 +5322,7 @@ function findCallsInCode(code, parser) {
                     enclosingFunction,
                     ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp }),
                     ...(rustFunctionReturnPosition(node) && { returnPosition: true }),
+                    ...(receiverText && rustExpectedTypeFields(node)),
                 });
             }
             return true;
@@ -5057,6 +5508,32 @@ function findCallsInCode(code, parser) {
             }
         }
 
+        // Path values passed as arguments (fix #422): `case(&t,
+        // T::unknown_bits)`, `.map(Self::parse)`. A method value is
+        // path-only in Rust; the path's qualifier decides what it names.
+        if (node.type === 'scoped_identifier' && node.parent?.type === 'arguments') {
+            const nameNode = node.childForFieldName('name');
+            const pathNode = node.childForFieldName('path');
+            const qualified = rustQualifiedPathHead(pathNode);
+            const receiver = qualified ? qualified.receiver : rustPlainPathText(pathNode);
+            if (nameNode?.type === 'identifier' && receiver) {
+                calls.push({
+                    name: nameNode.text,
+                    line: nameNode.startPosition.row + 1,
+                    callStart: node.startIndex,
+                    callEnd: node.endIndex,
+                    isMethod: true,
+                    isPathCall: true,
+                    receiver,
+                    ...(qualified?.selfType && { receiverQualifiedSelf: qualified.selfType }),
+                    ...rustReceiverScopeBindingField(node, receiver),
+                    isFunctionReference: true,
+                    isPotentialCallback: true,
+                    enclosingFunction: getCurrentEnclosingFunction(),
+                });
+            }
+        }
+
         // Track local variable types from let declarations
         // Pattern 1: let s = Server { ... } (struct expression)
         // Pattern 2: let s = Server::new() / ::from() / ::default() (scoped constructor)
@@ -5227,17 +5704,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);
@@ -5273,12 +5754,7 @@ function findImportsInCode(code, parser) {
     const tree = parseTree(parser, code);
     const imports = [];
 
-    const joinUsePath = (prefix, suffix) => {
-        const left = String(prefix || '').replace(/::$/, '');
-        const right = String(suffix || '').replace(/^::/, '');
-        return left && right ? `${left}::${right}` : left || right;
-    };
-    const addLeaf = (module, localName, type = 'use', dynamic = false, line, rename = null) => {
+    const addLeaf = (module, localName, type = 'use', dynamic = false, line, rename = null, scope = null) => {
         if (!module || !localName) return;
         imports.push({
             module,
@@ -5287,63 +5763,33 @@ function findImportsInCode(code, parser) {
             dynamic,
             line,
             ...(rename && { renames: [rename] }),
+            // A `use` in a block binds its names in that block only (fix
+            // #422): its lines bound where the bindings are visible.
+            ...scope,
         });
     };
-    const collectUseTree = (node, prefix, line) => {
-        if (!node || node.type === 'visibility_modifier') return;
-        if (node.type === 'scoped_use_list') {
-            const pathNode = node.childForFieldName('path');
-            const listNode = node.childForFieldName('list');
-            const nextPrefix = joinUsePath(prefix, pathNode?.text);
-            if (listNode) collectUseTree(listNode, nextPrefix, line);
+    const collectUseTree = (node, line, scope) => walkRustUseTree(node, '', leaf => {
+        if (leaf.glob) {
+            addLeaf(leaf.path, '*', 'use-glob', true, line, null, scope);
             return;
         }
-        if (node.type === 'use_list') {
-            for (let i = 0; i < node.namedChildCount; i++) {
-                collectUseTree(node.namedChild(i), prefix, line);
-            }
-            return;
+        // 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 renamed = leaf.node.type === 'use_as_clause' && leaf.original &&
+            leaf.original !== leaf.local && leaf.original !== 'self';
+        addLeaf(leaf.path, leaf.local, 'use', false, line,
+            renamed ? { original: leaf.original, local: leaf.local } : null, scope);
+        if (renamed) {
+            if (!imports.aliases) imports.aliases = [];
+            imports.aliases.push({ original: leaf.original, local: leaf.local });
         }
-        if (node.type === 'use_as_clause') {
-            const pathNode = node.namedChild(0);
-            const aliasNode = node.childForFieldName('alias') || node.namedChild(1);
-            if (pathNode && aliasNode) {
-                // 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();
-                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 });
-                }
-            }
-            return;
-        }
-        if (node.type === 'use_wildcard') {
-            const pathNode = node.namedChild(0);
-            addLeaf(joinUsePath(prefix, pathNode?.text), '*',
-                'use-glob', true, line);
-            return;
-        }
-        if (node.type === 'identifier' || node.type === 'scoped_identifier' ||
-            node.type === 'crate' || node.type === 'self' || node.type === 'super') {
-            if (node.text === 'self' && prefix) {
-                addLeaf(prefix, prefix.split('::').pop(), 'use', false, line);
-                return;
-            }
-            const module = joinUsePath(prefix, node.text);
-            addLeaf(module, node.text.split('::').pop(), 'use', false, line);
-        }
-    };
+    });
 
     traverseTreeCached(tree.rootNode, (node) => {
         // use declarations
@@ -5356,9 +5802,16 @@ function findImportsInCode(code, parser) {
             // bindings `crate::haystack::Haystack` and
             // `crate::haystack::Builder`, rather than the lossy old
             // `{ module: "crate", name: "haystack" }` approximation.
+            const scope = rustBlockItemScope(node);
+            // A `use` is an item: its visibility decides which modules a
+            // glob of its module reaches it from (fix #422).
+            const visibility = node.namedChildren.find(child => child.type === 'visibility_modifier')
+                ?.text.replace(/\s+/g, '');
+            const recordScope = scope.lexicalScopeStartLine != null || visibility
+                ? { ...scope, ...(visibility && { visibility }) } : null;
             for (let i = 0; i < node.namedChildCount; i++) {
                 const child = node.namedChild(i);
-                collectUseTree(child, '', line);
+                collectUseTree(child, line, recordScope);
             }
             return true;
         }
@@ -5973,7 +6426,13 @@ function isEntryPoint(symbol) {
 }
 
 module.exports = {
+    // Query-time type lookup uses the same lexical ribs as call extraction.
+    typePathScopeBinding: (node, written) => rustReceiverScopeBindingField(node, written)?.receiverScopeBinding || null,
+    getPrimitiveTypeInfo,
+    getDerefTypeInfo,
     primeDeclarationTrees,
+    DECLARATION_NODE_TYPES,
+    rustExpandedItemRecovery,
     parseDeclarationsIn,
     rustMacroInvocationContext,
     findFunctions,