cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/rust/captures.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitRustScopeCaptures = emitRustScopeCaptures;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const query_js_1 = require("./query.js");
+const cache_stats_js_1 = require("./cache-stats.js");
+const import_decomposer_js_1 = require("./import-decomposer.js");
+const receiver_binding_js_1 = require("./receiver-binding.js");
+const constants_js_1 = require("../../constants.js");
+const safe_parse_js_1 = require("../../../tree-sitter/safe-parse.js");
+const callable_flow_captures_js_1 = require("../../utils/callable-flow-captures.js");
+const receiver_chain_captures_js_1 = require("../../utils/receiver-chain-captures.js");
+const RUST_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(['function_item', 'closure_expression']),
+    callNodeTypes: new Set(['call_expression']),
+    parameterListNodeTypes: new Set(['parameters', 'arguments']),
+    parameterNodeTypes: new Set(['parameter', 'self_parameter']),
+    bindingNodeTypes: new Set(['let_declaration']),
+    assignmentNodeTypes: new Set(['assignment_expression']),
+    identifierNodeTypes: new Set(['identifier', 'type_identifier', 'field_identifier']),
+    callableReferenceNodeTypes: new Set(['scoped_identifier']),
+    normalizeQualifiedName: (raw) => raw.replaceAll('::', '.'),
+};
+function emitRustScopeCaptures(sourceText, _filePath, cachedTree) {
+    let tree = cachedTree;
+    if (tree === undefined) {
+        tree = (0, safe_parse_js_1.parseSourceSafe)((0, query_js_1.getRustParser)(), sourceText, undefined, {
+            bufferSize: (0, constants_js_1.getTreeSitterBufferSize)(sourceText),
+        });
+        (0, cache_stats_js_1.recordRustCacheMiss)();
+    }
+    else {
+        (0, cache_stats_js_1.recordRustCacheHit)();
+    }
+    const rawMatches = (0, query_js_1.getRustScopeQuery)().matches(tree.rootNode);
+    const out = [];
+    for (const m of rawMatches) {
+        const grouped = {};
+        // Parallel tag -> captured SyntaxNode map: the query hands us each matched
+        // node as c.node, so anchors resolve via a type-guarded lookup (nodeIfType)
+        // instead of re-deriving them with findNodeAtRange(tree.rootNode, ...) per
+        // match — the O(matches x rootChildren) root-walk fixed for go #1915 /
+        // python #1918, mirrored here.
+        const nodeMap = {};
+        for (const c of m.captures) {
+            const tag = '@' + c.name;
+            if (tag.startsWith('@_'))
+                continue;
+            grouped[tag] = (0, ast_helpers_js_1.nodeToCapture)(tag, c.node);
+            nodeMap[tag] = c.node;
+        }
+        if (Object.keys(grouped).length === 0)
+            continue;
+        // Decompose use declarations into individual import captures
+        if (grouped['@import.statement'] !== undefined) {
+            const useNode = (0, ast_helpers_js_1.nodeIfType)(nodeMap['@import.statement'], 'use_declaration');
+            if (useNode !== null) {
+                out.push(...(0, import_decomposer_js_1.splitRustUseDeclaration)(useNode));
+                continue;
+            }
+        }
+        // Synthesize self receiver bindings for methods inside impl blocks
+        let cachedImplLookup;
+        if (grouped['@scope.function'] !== undefined) {
+            const fnNode = (0, ast_helpers_js_1.nodeIfType)(nodeMap['@scope.function'], 'function_item');
+            if (fnNode !== null) {
+                const implNode = findEnclosingImpl(fnNode);
+                cachedImplLookup = { fnNode, implNode };
+                const receiver = (0, receiver_binding_js_1.synthesizeRustReceiverBinding)(fnNode, implNode);
+                if (receiver !== null)
+                    out.push(receiver);
+            }
+        }
+        // Attach declaration arity for functions/methods
+        const declAnchor = grouped['@declaration.function'];
+        if (declAnchor !== undefined) {
+            const fnNode = (0, ast_helpers_js_1.nodeIfType)(nodeMap['@declaration.function'], 'function_item');
+            if (fnNode !== null) {
+                const implNode = cachedImplLookup?.fnNode === fnNode
+                    ? cachedImplLookup.implNode
+                    : findEnclosingImpl(fnNode);
+                const traitNode = implNode === null ? findEnclosingTrait(fnNode) : null;
+                // Reclassify as method if inside an impl block or trait definition
+                if (implNode !== null || traitNode !== null) {
+                    const nameCap = grouped['@declaration.name'];
+                    delete grouped['@declaration.function'];
+                    grouped['@declaration.method'] = (0, ast_helpers_js_1.syntheticCapture)('@declaration.method', fnNode, fnNode.text);
+                    if (nameCap !== undefined) {
+                        grouped['@declaration.name'] = nameCap;
+                    }
+                }
+                const arity = computeRustDeclarationArity(fnNode);
+                if (arity.parameterCount !== undefined) {
+                    grouped['@declaration.parameter-count'] = (0, ast_helpers_js_1.syntheticCapture)('@declaration.parameter-count', fnNode, String(arity.parameterCount));
+                }
+                if (arity.requiredParameterCount !== undefined) {
+                    grouped['@declaration.required-parameter-count'] = (0, ast_helpers_js_1.syntheticCapture)('@declaration.required-parameter-count', fnNode, String(arity.requiredParameterCount));
+                }
+            }
+        }
+        // `Self` in a type binding names the enclosing impl's type, not a type
+        // called "Self". `let fresh = Self { … }` inside `impl User` binds
+        // `fresh: User`; recorded verbatim it binds `fresh: Self`, which resolves
+        // to nothing and leaves the receiver's type unknown.
+        //
+        // The type-env channel already substitutes this
+        // (`type-extractors/rust.ts` → `findEnclosingImplType`); the
+        // scope-resolution channel did not, so the two disagreed. That went
+        // unnoticed while `lookupCore` Step 1 still walked the lexical chain for
+        // named receivers — the impl scope binds the method by name, so
+        // `fresh.validate()` resolved by accident. #2714 stopped that walk for
+        // named receivers and the gap became a lost edge (#2699 follow-up).
+        const tbTypeNode = nodeMap['@type-binding.type'];
+        if (grouped['@type-binding.type']?.text === 'Self' && tbTypeNode !== undefined) {
+            const implNode = findEnclosingImpl(tbTypeNode);
+            const implTypeNode = implNode?.childForFieldName('type') ?? null;
+            if (implTypeNode !== null) {
+                grouped['@type-binding.type'] = (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', tbTypeNode, implTypeNode.text);
+            }
+        }
+        // Hoist return-type bindings from impl block functions to module level.
+        // The auto-hoist in the scope-extractor places a type binding whose
+        // anchor matches its innermost scope on the parent scope. By using the
+        // impl_item node as the anchor (which matches the impl's Class scope),
+        // the binding lands on the Module scope — making it visible to the
+        // compound receiver's hoistTypeBindingsToModule walk.
+        if (grouped['@type-binding.return'] !== undefined &&
+            grouped['@type-binding.name'] !== undefined) {
+            const tbReturnAnchor = grouped['@type-binding.return'];
+            const fnNode = (0, ast_helpers_js_1.nodeIfType)(nodeMap['@type-binding.return'], 'function_item');
+            if (fnNode !== null) {
+                const implNode = findEnclosingImpl(fnNode);
+                if (implNode !== null) {
+                    out.push({
+                        '@type-binding.name': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.name', implNode, grouped['@type-binding.name'].text),
+                        '@type-binding.type': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', implNode, grouped['@type-binding.type'].text),
+                        '@type-binding.return': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.return', implNode, tbReturnAnchor.text),
+                    });
+                }
+            }
+        }
+        // Attach call arity for call expressions
+        const callAnchorNode = nodeMap['@reference.call.free'] ??
+            nodeMap['@reference.call.member'] ??
+            nodeMap['@reference.call.constructor'];
+        if (callAnchorNode !== undefined) {
+            const callNode = (0, ast_helpers_js_1.nodeIfType)(callAnchorNode, 'call_expression', 'struct_expression');
+            if (callNode !== null) {
+                const arity = computeRustCallArity(callNode);
+                grouped['@reference.arity'] = (0, ast_helpers_js_1.syntheticCapture)('@reference.arity', callNode, String(arity));
+            }
+        }
+        // Structural receiver chain for a call whose receiver is itself an
+        // expression, so resolution can type it by folding over structure
+        // instead of re-parsing the receiver's source text. Self-gating: a
+        // non-call match, an absent receiver, or a chain with no nameable base
+        // all leave `grouped` untouched.
+        (0, receiver_chain_captures_js_1.synthesizeReceiverChainCapture)(grouped, nodeMap['@reference.receiver']);
+        out.push(grouped);
+    }
+    out.push(...synthesizeRustInheritanceReferences(tree.rootNode));
+    out.push(...(0, callable_flow_captures_js_1.synthesizeCallableFlowCaptures)(tree.rootNode, RUST_CALLABLE_CAPTURE_OPTIONS));
+    return out;
+}
+/**
+ * Synthesize `@reference.inherits` captures from Rust trait `impl` blocks so
+ * the registry-primary scope-resolution path can emit the IMPLEMENTS edge for
+ * `impl Trait for Struct` (mirrors the legacy heritage-capture leg, removed in
+ * #942, which the worker pipeline drops for registry-primary languages — #1951).
+ *
+ * Rust inheritance is structurally unlike a base list on a type declaration:
+ * the relationship lives on `impl_item { trait: T, type: S }`, meaning
+ * `S IMPLEMENTS T`. The shared `preEmitInheritanceEdges` derives an edge's
+ * SOURCE from the enclosing *class* def of the `@reference.inherits` site, but
+ * an `impl_item` scope owns no class-like def (the struct `S` is declared
+ * elsewhere as a `struct_item`), so `findEnclosingClassDef` returns undefined
+ * and that pass emits nothing for these sites (it still marks them handled,
+ * suppressing the generic reference bridge). The real IMPLEMENTS edge is
+ * therefore emitted by `rustScopeResolver.emitHeritageEdges`, which reads these
+ * sites back from `parsedFiles[*].referenceSites`.
+ *
+ * To carry both ends of the relationship through a single reference site we
+ * encode: `@reference.name` = the trait `T` (becomes `site.name`, the IMPLEMENTS
+ * target) and `@reference.receiver` = the struct `S` (becomes
+ * `site.explicitReceiver.name`, the IMPLEMENTS source).
+ *
+ * Parity is intentionally pinned to the legacy heritage query's `impl_item`
+ * patterns: both `trait:` and `type:` normalize to the base's trailing bare
+ * `type_identifier` — directly, via a `scoped_type_identifier`'s `name:` tail
+ * (`crate::traits::Drawable` → `Drawable`; KTD-1 tail resolution), or through a
+ * `generic_type`'s `type:` field (which may itself be either). Inherent impls
+ * (`impl S {}`, no `trait:` field) still emit nothing.
+ */
+function synthesizeRustInheritanceReferences(root) {
+    const out = [];
+    (0, ast_helpers_js_1.walkNamedTree)(root, (node) => {
+        if (node.type !== 'impl_item')
+            return;
+        const traitField = node.childForFieldName('trait');
+        const typeField = node.childForFieldName('type');
+        if (traitField === null || typeField === null)
+            return;
+        const traitName = bareTypeIdentifier(traitField);
+        const structName = bareTypeIdentifier(typeField);
+        if (traitName === null || structName === null)
+            return;
+        out.push({
+            '@reference.inherits': (0, ast_helpers_js_1.nodeToCapture)('@reference.inherits', traitName),
+            '@reference.name': (0, ast_helpers_js_1.nodeToCapture)('@reference.name', traitName),
+            '@reference.receiver': (0, ast_helpers_js_1.syntheticCapture)('@reference.receiver', structName, structName.text),
+        });
+    });
+    return out;
+}
+/**
+ * Normalize a `trait:` / `type:` impl_item field to the base's trailing bare
+ * `type_identifier`, matching exactly the node shapes the legacy heritage
+ * query accepted (kept at parity — see the `impl_item` heritage arm in
+ * tree-sitter-queries.ts):
+ *   - `type_identifier`                                  → the node itself
+ *   - `scoped_type_identifier name: (type_identifier)`   → the trailing `name:` id
+ *     (`crate::traits::Drawable` → `Drawable`; KTD-1 tail resolution — the
+ *     simple name then resolves scope-aware via `emitRustTraitImplEdges`)
+ *   - `generic_type type: <any of the above>`            → recurse into `type:`
+ *     (covers `Box<T>` and `m::Wrapped<T>`)
+ * Any other node type returns null (no edge), keeping this emitter at parity
+ * with the legacy query.
+ */
+function bareTypeIdentifier(node) {
+    if (node.type === 'type_identifier')
+        return node;
+    if (node.type === 'scoped_type_identifier') {
+        const tail = node.childForFieldName('name');
+        return tail !== null && tail.type === 'type_identifier' ? tail : null;
+    }
+    if (node.type === 'generic_type') {
+        const inner = node.childForFieldName('type');
+        return inner !== null ? bareTypeIdentifier(inner) : null;
+    }
+    return null;
+}
+function findEnclosingImpl(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (current.type === 'impl_item')
+            return current;
+        if (current.type === 'source_file' || current.type === 'mod_item')
+            return null;
+        current = current.parent;
+    }
+    return null;
+}
+function findEnclosingTrait(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (current.type === 'trait_item')
+            return current;
+        if (current.type === 'source_file' || current.type === 'mod_item')
+            return null;
+        current = current.parent;
+    }
+    return null;
+}
+function computeRustDeclarationArity(fnNode) {
+    const params = fnNode.childForFieldName('parameters');
+    if (params === null)
+        return {};
+    let count = 0;
+    for (let i = 0; i < params.namedChildCount; i++) {
+        const child = params.namedChild(i);
+        if (child === null)
+            continue;
+        if (child.type === 'self_parameter')
+            continue;
+        if (child.type === 'parameter')
+            count++;
+    }
+    // Rust has no default parameters or overloading
+    return { parameterCount: count, requiredParameterCount: count };
+}
+function computeRustCallArity(callNode) {
+    if (callNode.type === 'struct_expression') {
+        const body = callNode.childForFieldName('body');
+        if (body === null)
+            return 0;
+        let count = 0;
+        for (let i = 0; i < body.namedChildCount; i++) {
+            const t = body.namedChild(i)?.type;
+            if (t === 'field_initializer' || t === 'shorthand_field_initializer')
+                count++;
+        }
+        return count;
+    }
+    const args = callNode.childForFieldName('arguments');
+    if (args === null)
+        return 0;
+    let count = 0;
+    for (let i = 0; i < args.namedChildCount; i++) {
+        const child = args.namedChild(i);
+        if (child !== null)
+            count++;
+    }
+    return count;
+}

package/dist/core/code/engine/core/ingestion/languages/rust/import-decomposer.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitRustUseDeclaration = splitRustUseDeclaration;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+/**
+ * Decompose a Rust `use_declaration` into individual import captures.
+ * Handles simple paths, grouped imports ({A, B}), wildcards (*),
+ * renames (as), and `pub use` re-exports.
+ */
+function splitRustUseDeclaration(node) {
+    if (node.type !== 'use_declaration')
+        return [];
+    const isReexport = hasVisibilityModifier(node);
+    const argument = getUseArgument(node);
+    if (argument === null)
+        return [];
+    return decomposeUseArgument(argument, '', isReexport, node);
+}
+function hasVisibilityModifier(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        if (node.child(i)?.type === 'visibility_modifier')
+            return true;
+    }
+    return false;
+}
+function getUseArgument(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child === null)
+            continue;
+        if (child.type === 'scoped_identifier' ||
+            child.type === 'scoped_use_list' ||
+            child.type === 'use_wildcard' ||
+            child.type === 'use_as_clause' ||
+            child.type === 'identifier' ||
+            child.type === 'use_list') {
+            return child;
+        }
+    }
+    return null;
+}
+function decomposeUseArgument(node, prefixPath, isReexport, anchor) {
+    switch (node.type) {
+        case 'scoped_identifier': {
+            const path = buildScopedPath(node);
+            const segments = path.split('::');
+            const name = segments[segments.length - 1];
+            return [
+                makeImportCapture(anchor, isReexport ? 'reexport' : 'named', joinPaths(prefixPath, path), name, undefined),
+            ];
+        }
+        case 'scoped_use_list': {
+            const pathNode = node.childForFieldName('path');
+            const listNode = node.childForFieldName('list');
+            const pathStr = pathNode ? buildNodePath(pathNode) : '';
+            const fullPrefix = joinPaths(prefixPath, pathStr);
+            if (listNode === null)
+                return [];
+            return decomposeUseList(listNode, fullPrefix, isReexport, anchor);
+        }
+        case 'use_list': {
+            return decomposeUseList(node, prefixPath, isReexport, anchor);
+        }
+        case 'use_wildcard': {
+            const wcPath = buildWildcardPath(node);
+            return [makeImportCapture(anchor, 'wildcard', joinPaths(prefixPath, wcPath), '*', undefined)];
+        }
+        case 'use_as_clause': {
+            const pathChild = node.childForFieldName('path');
+            const aliasChild = node.childForFieldName('alias');
+            if (pathChild === null || aliasChild === null)
+                return [];
+            const originalName = pathChild.type === 'scoped_identifier' ? buildScopedPath(pathChild) : pathChild.text;
+            const aliasName = aliasChild.text;
+            const segments = originalName.split('::');
+            const importedName = segments[segments.length - 1];
+            return [
+                makeImportCapture(anchor, isReexport ? 'reexport' : 'named', joinPaths(prefixPath, originalName), importedName, aliasName),
+            ];
+        }
+        case 'identifier': {
+            return [
+                makeImportCapture(anchor, isReexport ? 'reexport' : 'named', joinPaths(prefixPath, node.text), node.text, undefined),
+            ];
+        }
+        default:
+            return [];
+    }
+}
+function decomposeUseList(listNode, prefix, isReexport, anchor) {
+    const out = [];
+    for (let i = 0; i < listNode.namedChildCount; i++) {
+        const child = listNode.namedChild(i);
+        if (child === null)
+            continue;
+        if (child.type === 'self') {
+            // `use crate::models::{self}` — imports the module itself
+            const segments = prefix.split('::').filter(Boolean);
+            const name = segments[segments.length - 1] ?? 'self';
+            out.push(makeImportCapture(anchor, 'namespace', prefix, name, undefined));
+        }
+        else {
+            out.push(...decomposeUseArgument(child, prefix, isReexport, anchor));
+        }
+    }
+    return out;
+}
+function buildScopedPath(node) {
+    if (node.type === 'scoped_identifier') {
+        const parts = [];
+        collectScopedParts(node, parts);
+        return parts.join('::');
+    }
+    return node.text;
+}
+function collectScopedParts(node, parts) {
+    if (node.type === 'scoped_identifier') {
+        const pathNode = node.childForFieldName('path');
+        const nameNode = node.childForFieldName('name');
+        if (pathNode)
+            collectScopedParts(pathNode, parts);
+        if (nameNode)
+            parts.push(nameNode.text);
+    }
+    else {
+        parts.push(node.text);
+    }
+}
+function buildNodePath(node) {
+    if (node.type === 'scoped_identifier') {
+        return buildScopedPath(node);
+    }
+    return node.text;
+}
+function buildWildcardPath(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child === null)
+            continue;
+        if (child.type === 'scoped_identifier')
+            return buildScopedPath(child);
+        if (child.type === 'identifier')
+            return child.text;
+    }
+    return '';
+}
+function joinPaths(prefix, suffix) {
+    if (!prefix)
+        return suffix;
+    if (!suffix)
+        return prefix;
+    return `${prefix}::${suffix}`;
+}
+function makeImportCapture(anchor, kind, source, name, alias) {
+    return {
+        '@import.statement': (0, ast_helpers_js_1.syntheticCapture)('@import.statement', anchor, anchor.text),
+        '@import.kind': (0, ast_helpers_js_1.syntheticCapture)('@import.kind', anchor, kind),
+        '@import.source': (0, ast_helpers_js_1.syntheticCapture)('@import.source', anchor, source),
+        '@import.name': (0, ast_helpers_js_1.syntheticCapture)('@import.name', anchor, alias ?? name),
+        ...(alias !== undefined
+            ? {
+                '@import.alias': (0, ast_helpers_js_1.syntheticCapture)('@import.alias', anchor, alias),
+                '@import.original-name': (0, ast_helpers_js_1.syntheticCapture)('@import.original-name', anchor, name),
+            }
+            : {}),
+    };
+}

package/dist/core/code/engine/core/ingestion/languages/rust/import-target.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRustImportTarget = resolveRustImportTarget;
+/**
+ * Resolve a Rust `use` import path to a repo-relative file path.
+ *
+ * Rust module resolution rules:
+ *   - `crate::foo::bar` → `src/foo/bar.rs` or `src/foo/bar/mod.rs`
+ *   - `super::foo` → parent directory's `foo.rs` or `foo/mod.rs`
+ *   - `self::foo` → same directory's `foo.rs` or `foo/mod.rs`
+ *   - External crate imports (no `crate::`/`super::`/`self::`) → null
+ */
+function resolveRustImportTarget(targetRaw, fromFile, allFilePaths, _resolutionConfig) {
+    if (!targetRaw)
+        return null;
+    const segments = targetRaw.split('::').filter(Boolean);
+    if (segments.length === 0)
+        return null;
+    const fromNormalized = fromFile.replace(/\\/g, '/');
+    const fromDir = fromNormalized.includes('/')
+        ? fromNormalized.slice(0, fromNormalized.lastIndexOf('/'))
+        : '';
+    if (segments[0] === 'crate') {
+        const cratePath = segments.slice(1);
+        return resolveModulePath(cratePath, findSrcRoot(fromNormalized), allFilePaths);
+    }
+    if (segments[0] === 'super') {
+        const parentDir = fromDir.includes('/') ? fromDir.slice(0, fromDir.lastIndexOf('/')) : '';
+        const restPath = segments.slice(1);
+        return resolveModulePath(restPath, parentDir, allFilePaths);
+    }
+    if (segments[0] === 'self') {
+        const restPath = segments.slice(1);
+        return resolveModulePath(restPath, fromDir, allFilePaths);
+    }
+    // External crate — try workspace-level resolution
+    const workspaceResult = resolveWorkspaceCrate(segments, allFilePaths);
+    if (workspaceResult !== null)
+        return workspaceResult;
+    // Fallback: treat as implicit crate-relative (Rust 2015 edition or
+    // when the first segment matches a sibling module name).
+    return resolveModulePath(segments, findSrcRoot(fromNormalized), allFilePaths);
+}
+function findSrcRoot(filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    const srcIdx = normalized.lastIndexOf('/src/');
+    if (srcIdx !== -1)
+        return normalized.slice(0, srcIdx + 4); // includes trailing /src
+    if (normalized.startsWith('src/'))
+        return 'src';
+    return '';
+}
+function resolveModulePath(pathSegments, baseDir, allFilePaths) {
+    if (pathSegments.length === 0) {
+        const modPath = baseDir ? `${baseDir}/mod.rs` : 'mod.rs';
+        if (allFilePaths.has(modPath))
+            return modPath;
+        return null;
+    }
+    const modulePath = pathSegments.join('/');
+    // Try direct file
+    const directFile = baseDir ? `${baseDir}/${modulePath}.rs` : `${modulePath}.rs`;
+    if (allFilePaths.has(directFile))
+        return directFile;
+    // Try mod.rs inside directory
+    const modFile = baseDir ? `${baseDir}/${modulePath}/mod.rs` : `${modulePath}/mod.rs`;
+    if (allFilePaths.has(modFile))
+        return modFile;
+    // Try partial path resolution: for `use crate::models::User` where
+    // User is a type inside models.rs, resolve to `src/models.rs`
+    if (pathSegments.length >= 2) {
+        const parentPath = pathSegments.slice(0, -1).join('/');
+        const parentFile = baseDir ? `${baseDir}/${parentPath}.rs` : `${parentPath}.rs`;
+        if (allFilePaths.has(parentFile))
+            return parentFile;
+        const parentModFile = baseDir ? `${baseDir}/${parentPath}/mod.rs` : `${parentPath}/mod.rs`;
+        if (allFilePaths.has(parentModFile))
+            return parentModFile;
+    }
+    // Fallback: try increasingly shorter path prefixes
+    for (let i = pathSegments.length - 2; i >= 1; i--) {
+        const prefix = pathSegments.slice(0, i).join('/');
+        const prefixFile = baseDir ? `${baseDir}/${prefix}.rs` : `${prefix}.rs`;
+        if (allFilePaths.has(prefixFile))
+            return prefixFile;
+        const prefixModFile = baseDir ? `${baseDir}/${prefix}/mod.rs` : `${prefix}/mod.rs`;
+        if (allFilePaths.has(prefixModFile))
+            return prefixModFile;
+    }
+    return null;
+}
+function resolveWorkspaceCrate(segments, allFilePaths) {
+    const crateName = segments[0];
+    const restSegments = segments.slice(1);
+    const candidates = [
+        restSegments.length > 0
+            ? `${crateName}/src/${restSegments.join('/')}.rs`
+            : `${crateName}/src/lib.rs`,
+        restSegments.length > 0
+            ? `${crateName}/src/${restSegments.join('/')}/mod.rs`
+            : `${crateName}/src/lib.rs`,
+    ];
+    for (const candidate of candidates) {
+        if (allFilePaths.has(candidate))
+            return candidate;
+    }
+    return null;
+}

package/dist/core/code/engine/core/ingestion/languages/rust/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRustImportTarget = exports.rustReceiverBinding = exports.rustImportOwningScope = exports.rustBindingScopeFor = exports.rustMergeBindings = exports.rustArityCompatibility = exports.synthesizeRustReceiverBinding = exports.splitRustUseDeclaration = exports.normalizeRustTypeName = exports.interpretRustTypeBinding = exports.interpretRustImport = exports.resetRustCaptureCacheStats = exports.getRustCaptureCacheStats = exports.emitRustScopeCaptures = void 0;
+/**
+ * Rust scope-resolution hooks (RFC #909 Ring 3).
+ */
+var captures_js_1 = require("./captures.js");
+Object.defineProperty(exports, "emitRustScopeCaptures", { enumerable: true, get: function () { return captures_js_1.emitRustScopeCaptures; } });
+var cache_stats_js_1 = require("./cache-stats.js");
+Object.defineProperty(exports, "getRustCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.getRustCaptureCacheStats; } });
+Object.defineProperty(exports, "resetRustCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.resetRustCaptureCacheStats; } });
+var interpret_js_1 = require("./interpret.js");
+Object.defineProperty(exports, "interpretRustImport", { enumerable: true, get: function () { return interpret_js_1.interpretRustImport; } });
+Object.defineProperty(exports, "interpretRustTypeBinding", { enumerable: true, get: function () { return interpret_js_1.interpretRustTypeBinding; } });
+Object.defineProperty(exports, "normalizeRustTypeName", { enumerable: true, get: function () { return interpret_js_1.normalizeRustTypeName; } });
+var import_decomposer_js_1 = require("./import-decomposer.js");
+Object.defineProperty(exports, "splitRustUseDeclaration", { enumerable: true, get: function () { return import_decomposer_js_1.splitRustUseDeclaration; } });
+var receiver_binding_js_1 = require("./receiver-binding.js");
+Object.defineProperty(exports, "synthesizeRustReceiverBinding", { enumerable: true, get: function () { return receiver_binding_js_1.synthesizeRustReceiverBinding; } });
+var arity_js_1 = require("./arity.js");
+Object.defineProperty(exports, "rustArityCompatibility", { enumerable: true, get: function () { return arity_js_1.rustArityCompatibility; } });
+var merge_bindings_js_1 = require("./merge-bindings.js");
+Object.defineProperty(exports, "rustMergeBindings", { enumerable: true, get: function () { return merge_bindings_js_1.rustMergeBindings; } });
+var simple_hooks_js_1 = require("./simple-hooks.js");
+Object.defineProperty(exports, "rustBindingScopeFor", { enumerable: true, get: function () { return simple_hooks_js_1.rustBindingScopeFor; } });
+Object.defineProperty(exports, "rustImportOwningScope", { enumerable: true, get: function () { return simple_hooks_js_1.rustImportOwningScope; } });
+Object.defineProperty(exports, "rustReceiverBinding", { enumerable: true, get: function () { return simple_hooks_js_1.rustReceiverBinding; } });
+var import_target_js_1 = require("./import-target.js");
+Object.defineProperty(exports, "resolveRustImportTarget", { enumerable: true, get: function () { return import_target_js_1.resolveRustImportTarget; } });