cgraphx 2.0.2 → 2.0.3

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

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpretRustImport = interpretRustImport;
+exports.interpretRustTypeBinding = interpretRustTypeBinding;
+exports.normalizeRustTypeName = normalizeRustTypeName;
+const REF_PREFIX_RE = /^&\s*(mut\s+)?/;
+const PTR_PREFIX_RE = /^\*\s*(const|mut)?\s*/;
+const DYN_PREFIX_RE = /^dyn\s+/;
+const ENUM_VARIANT_NAMES = new Set(['Some', 'None', 'Ok', 'Err']);
+// `dyn Trait`, `&dyn Trait`, `Box<dyn Trait>` all name a trait object whose
+// receiver-dispatch target is the trait itself (#2604) — strip the `dyn`
+// keyword and any auto-trait/lifetime bound list (`dyn Trait + Send`) down to
+// the principal trait name. Reference/pointer sigils are stripped by the
+// caller first; wrapper unwrapping (Box<T> etc.) runs before this so the
+// unwrapped inner text still gets the same treatment.
+function stripDynBound(t) {
+    if (!DYN_PREFIX_RE.test(t))
+        return t;
+    t = t.replace(DYN_PREFIX_RE, '');
+    const plus = t.indexOf('+');
+    if (plus !== -1)
+        t = t.slice(0, plus);
+    return t.trim();
+}
+// ─── interpretImport ──────────────────────────────────────────────────────
+function interpretRustImport(captures) {
+    const kind = captures['@import.kind']?.text;
+    const source = captures['@import.source']?.text;
+    const name = captures['@import.name']?.text;
+    const alias = captures['@import.alias']?.text;
+    if (kind === undefined || source === undefined)
+        return null;
+    if (kind === 'wildcard')
+        return { kind: 'wildcard', targetRaw: source };
+    if (kind === 'namespace') {
+        if (name === undefined)
+            return null;
+        return { kind: 'namespace', localName: name, importedName: name, targetRaw: source };
+    }
+    if (kind === 'reexport') {
+        if (name === undefined)
+            return null;
+        const originalName = captures['@import.original-name']?.text;
+        return {
+            kind: 'reexport',
+            localName: alias ?? name,
+            importedName: originalName ?? name,
+            targetRaw: source,
+        };
+    }
+    // kind === 'named'
+    if (name === undefined)
+        return null;
+    const originalName = captures['@import.original-name']?.text;
+    return {
+        kind: 'named',
+        localName: alias ?? name,
+        importedName: originalName ?? name,
+        targetRaw: source,
+    };
+}
+// ─── interpretTypeBinding ─────────────────────────────────────────────────
+function interpretRustTypeBinding(captures) {
+    const name = captures['@type-binding.name']?.text;
+    const type = captures['@type-binding.type']?.text;
+    if (name === undefined || type === undefined)
+        return null;
+    let source = 'annotation';
+    let normalizedType;
+    if (captures['@type-binding.self'] !== undefined) {
+        source = 'self';
+        normalizedType = normalizeRustTypeName(type);
+    }
+    else if (captures['@type-binding.constructor'] !== undefined) {
+        source = 'constructor-inferred';
+        normalizedType = normalizeRustTypeName(type);
+    }
+    else if (captures['@type-binding.call-return'] !== undefined) {
+        if (ENUM_VARIANT_NAMES.has(type))
+            return null;
+        source = 'constructor-inferred';
+        normalizedType = normalizeRustCallReturnType(type);
+    }
+    else if (captures['@type-binding.return'] !== undefined) {
+        source = 'return-annotation';
+        normalizedType = normalizeRustReturnType(type);
+    }
+    else if (captures['@type-binding.assignment'] !== undefined) {
+        source = 'assignment-inferred';
+        normalizedType = normalizeRustTypeName(type);
+    }
+    else if (captures['@type-binding.alias'] !== undefined) {
+        source = 'assignment-inferred';
+        normalizedType = normalizeRustTypeName(type);
+    }
+    else if (captures['@type-binding.parameter'] !== undefined) {
+        source = 'parameter-annotation';
+        normalizedType = normalizeRustTypeName(type);
+    }
+    else {
+        normalizedType = normalizeRustTypeName(type);
+    }
+    return { boundName: name, rawTypeName: normalizedType, source };
+}
+function normalizeRustTypeName(text) {
+    let t = text.trim();
+    // Strip reference prefixes (&, &mut, *const, *mut)
+    while (t.startsWith('&'))
+        t = t.replace(REF_PREFIX_RE, '');
+    while (t.startsWith('*'))
+        t = t.replace(PTR_PREFIX_RE, '');
+    // Unwrap common smart-pointer/container wrappers to their inner type
+    const wrappers = ['Box', 'Option', 'Arc', 'Rc', 'Mutex', 'RwLock', 'RefCell', 'Cell'];
+    for (const w of wrappers) {
+        if (t.startsWith(`${w}<`)) {
+            const inner = extractFirstGenericArg(t);
+            if (inner !== null) {
+                t = inner;
+                break;
+            }
+        }
+    }
+    if (t.startsWith('Vec<')) {
+        const inner = extractFirstGenericArg(t);
+        if (inner !== null)
+            t = inner;
+    }
+    t = stripDynBound(t);
+    const bracket = t.indexOf('<');
+    if (bracket !== -1)
+        t = t.slice(0, bracket);
+    // Take last segment of qualified paths (crate::foo::Bar → Bar)
+    const lastColon = t.lastIndexOf('::');
+    if (lastColon !== -1)
+        t = t.slice(lastColon + 2);
+    return t.trim();
+}
+function extractFirstGenericArg(text) {
+    const open = text.indexOf('<');
+    if (open === -1)
+        return null;
+    let depth = 0;
+    for (let i = open; i < text.length; i++) {
+        if (text[i] === '<')
+            depth++;
+        else if (text[i] === '>') {
+            depth--;
+            if (depth === 0) {
+                const inner = text.slice(open + 1, i).trim();
+                const comma = findTopLevelComma(inner);
+                return comma === -1 ? inner : inner.slice(0, comma).trim();
+            }
+        }
+    }
+    return null;
+}
+function findTopLevelComma(text) {
+    let depth = 0;
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === '<')
+            depth++;
+        else if (text[i] === '>')
+            depth--;
+        else if (text[i] === ',' && depth === 0)
+            return i;
+    }
+    return -1;
+}
+function normalizeRustCallReturnType(text) {
+    let t = text.trim();
+    // For scoped calls like `Foo::new()`, extract the type part before `::`
+    const scopeIdx = t.indexOf('::');
+    if (scopeIdx !== -1) {
+        t = t.slice(0, scopeIdx);
+    }
+    return normalizeRustTypeName(t);
+}
+function normalizeRustReturnType(text) {
+    let t = text.trim();
+    while (t.startsWith('&'))
+        t = t.replace(REF_PREFIX_RE, '');
+    // Unwrap Result<T, E>, Option<T> for return types
+    const wrappers = ['Result', 'Option'];
+    for (const w of wrappers) {
+        if (t.startsWith(`${w}<`)) {
+            const inner = extractFirstGenericArg(t);
+            if (inner !== null) {
+                t = inner;
+                break;
+            }
+        }
+    }
+    t = stripDynBound(t);
+    const bracket = t.indexOf('<');
+    if (bracket !== -1)
+        t = t.slice(0, bracket);
+    const lastColon = t.lastIndexOf('::');
+    if (lastColon !== -1)
+        t = t.slice(lastColon + 2);
+    return t.trim();
+}

package/dist/core/code/engine/core/ingestion/languages/rust/merge-bindings.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustMergeBindings = rustMergeBindings;
+const TIER = {
+    local: 0,
+    namespace: 1,
+    import: 2,
+    reexport: 3,
+    wildcard: 4,
+};
+function rustMergeBindings(existing, incoming, _scopeId) {
+    const seen = new Set();
+    return [...existing, ...incoming]
+        .sort((a, b) => (TIER[a.origin] ?? 99) - (TIER[b.origin] ?? 99) || a.def.nodeId.localeCompare(b.def.nodeId))
+        .filter((binding) => {
+        if (seen.has(binding.def.nodeId))
+            return false;
+        seen.add(binding.def.nodeId);
+        return true;
+    });
+}

package/dist/core/code/engine/core/ingestion/languages/rust/method-owners.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.populateRustOwners = populateRustOwners;
+const walkers_js_1 = require("../../scope-resolution/scope/walkers.js");
+/**
+ * Populate `ownerId` on Rust method defs.
+ *
+ * Rust methods are declared inside `impl TypeName { ... }` blocks, not
+ * directly inside struct bodies. The tree-sitter query creates Class scopes
+ * for impl blocks, and the generic `populateClassOwnedMembers` handles methods
+ * that are structurally nested inside those Class scopes. But we also need to
+ * bridge the impl block's methods to the actual struct def, since the impl
+ * block is semantically "owned by" the struct.
+ *
+ * Strategy:
+ * 1. Run the generic `populateClassOwnedMembers` (handles property fields in
+ *    structs and methods in impl blocks).
+ * 2. For each method in an impl block's Class scope whose ownerId points to
+ *    the impl block, re-point ownerId to the struct def (if found in the
+ *    same module).
+ */
+function populateRustOwners(parsed) {
+    (0, walkers_js_1.populateClassOwnedMembers)(parsed);
+    populateRustImplOwners(parsed);
+    // #2730: tag defs declared inside `mod` blocks with their enclosing module
+    // path (`inner`, `a.b`) on the `namespacePrefix` sidecar. Rust modules are
+    // Namespace scopes owning a Namespace def (see the `mod_item` capture), so
+    // the shared C++-era pass applies unchanged. Qualified call resolution reads
+    // this to tell `inner::dispatch` apart from a same-named crate-root `fn`.
+    // Rust `qualifiedName`s never encode the enclosing module, so the shared
+    // "already namespaced" guard must be off: with it on, `mod a { pub fn a() }`
+    // matched by coincidence and the member was left looking like it belonged to
+    // the parent module (#2741 review).
+    (0, walkers_js_1.tagNamespacePrefixes)(parsed, { qualifiedNamesCarryNamespace: false });
+}
+function populateRustImplOwners(parsed) {
+    // Build a map of struct name → def nodeId from all scopes.
+    const structByName = new Map();
+    for (const scope of parsed.scopes) {
+        for (const def of scope.ownedDefs) {
+            if ((0, walkers_js_1.isClassLike)(def.type) && def.qualifiedName) {
+                structByName.set(def.qualifiedName, def.nodeId);
+            }
+        }
+    }
+    if (structByName.size === 0)
+        return;
+    const structBySuffix = new Map();
+    for (const [qname, nodeId] of structByName) {
+        const dot = qname.lastIndexOf('.');
+        const suffix = dot !== -1 ? qname.slice(dot + 1) : qname;
+        structBySuffix.set(suffix, nodeId);
+    }
+    for (const scope of parsed.scopes) {
+        if (scope.kind !== 'Function')
+            continue;
+        const methodDefs = scope.ownedDefs.filter((d) => d.type === 'Method' && d.ownerId === undefined);
+        if (methodDefs.length === 0)
+            continue;
+        let receiverType;
+        for (const [, tb] of scope.typeBindings) {
+            if (tb.source === 'self') {
+                receiverType = tb.rawName;
+                break;
+            }
+        }
+        if (receiverType === undefined)
+            continue;
+        const ownerId = structByName.get(receiverType) ?? structBySuffix.get(receiverType);
+        if (ownerId !== undefined) {
+            for (const def of methodDefs) {
+                def.ownerId = ownerId;
+            }
+        }
+    }
+}

package/dist/core/code/engine/core/ingestion/languages/rust/module-path.js

@@ -0,0 +1,222 @@
+"use strict";
+/**
+ * Rust module paths — the module tree, expressed over the scope model.
+ *
+ * rustc resolves `a::b::dispatch` against a MODULE TREE, not a file tree: `mod`
+ * is an item with its own `DefId`, and a path's leading segments name modules in
+ * the *type* namespace (which is why a same-named `fn` can never shadow them —
+ * functions live in the value namespace). GitNexus models the same tree in two
+ * halves, and this module joins them:
+ *
+ *   - **Inline modules** (`mod inner { … }`) are `Namespace` scopes owning a
+ *     `Namespace` def, so the shared `tagNamespacePrefixes` pass stamps members
+ *     with `namespacePrefix = 'inner'` / `'outer.inner'`.
+ *   - **File modules** (`mod tools;` loading `tools.rs` or `tools/mod.rs`) leave
+ *     no in-file marker at all — the module path lives in the FILE PATH relative
+ *     to the crate root. That half is reconstructed here.
+ *
+ * ## Module identity carries its crate
+ *
+ * A module is `{ crateRoot, segments }`, never bare segments. A cargo workspace
+ * routinely gives several members the same internal module name — `util`,
+ * `error`, `config`, `types` are near-universal — and identity by segments alone
+ * makes `crates/a/src/tools.rs` and `crates/b/src/tools.rs` the same module. That
+ * mis-binds a call across crates when only one defines the member, and (worse)
+ * ties the lookup when both do, so qualified resolution refuses and the call
+ * falls back to the lexical walk that #2730 exists to prevent. Rust has no
+ * implicit cross-crate paths: reaching another crate requires naming it, so two
+ * modules in different crates are never the same module.
+ *
+ * Everything here is pure path arithmetic over the workspace file set; no I/O.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRustModuleIndex = buildRustModuleIndex;
+exports.couldNameAModule = couldNameAModule;
+exports.moduleOfFile = moduleOfFile;
+exports.moduleOfDef = moduleOfDef;
+exports.resolveAnchoredModulePath = resolveAnchoredModulePath;
+exports.sameModule = sameModule;
+/** Files that make their directory a crate root (`crate::` anchors here). */
+const CRATE_ROOT_FILES = new Set(['main.rs', 'lib.rs']);
+/** A module file whose name does NOT contribute a path segment. */
+const MODULE_DIR_FILE = 'mod.rs';
+/**
+ * Index the workspace's crate roots: every directory holding a `main.rs` or
+ * `lib.rs`. A cargo workspace has one per member (`crates/noob/src`), a plain
+ * package exactly one (`src`). Longest-first ordering makes `moduleOfFile` pick
+ * the innermost enclosing crate for nested layouts.
+ *
+ * Cargo also auto-discovers a binary target per `src/bin/<name>.rs`. Each is a
+ * separate crate with its own `crate::` root, and its submodules live under
+ * `src/bin/<name>/`. Treating those files as ordinary modules of the library
+ * invented the module path `bin::<name>`, which made `crate::helper()` inside a
+ * binary resolve into the LIBRARY — downgrading an edge the lexical walk had
+ * previously got right (#2741 review).
+ */
+function buildRustModuleIndex(allFilePaths) {
+    const roots = new Set();
+    for (const filePath of allFilePaths) {
+        const slash = filePath.lastIndexOf('/');
+        const base = slash === -1 ? filePath : filePath.slice(slash + 1);
+        if (!CRATE_ROOT_FILES.has(base))
+            continue;
+        roots.add(slash === -1 ? '' : filePath.slice(0, slash));
+    }
+    // Auto-discovered binary targets: `<crateRoot>/bin/<name>.rs`, and the
+    // directory form `<crateRoot>/bin/<name>/main.rs` (already a root above).
+    const standaloneRootFiles = new Map();
+    for (const filePath of allFilePaths) {
+        if (!filePath.endsWith('.rs'))
+            continue;
+        const slash = filePath.lastIndexOf('/');
+        if (slash === -1)
+            continue;
+        const dir = filePath.slice(0, slash);
+        if (!dir.endsWith('/bin'))
+            continue;
+        const parent = dir.slice(0, -'/bin'.length);
+        if (!roots.has(parent))
+            continue;
+        const own = filePath.slice(0, -'.rs'.length);
+        standaloneRootFiles.set(filePath, own);
+        roots.add(own);
+    }
+    const crateRoots = [...roots].sort((a, b) => b.length - a.length);
+    // Flat set of every module segment name in the workspace, for the negative
+    // filter. Built from the same single pass over file paths.
+    const moduleNames = new Set();
+    const index = { crateRoots, standaloneRootFiles, moduleNames: new Set() };
+    for (const filePath of allFilePaths) {
+        const module = moduleOfFile(filePath, index);
+        if (module === undefined)
+            continue;
+        for (const segment of module.segments)
+            moduleNames.add(segment);
+    }
+    return { crateRoots, standaloneRootFiles, moduleNames };
+}
+/**
+ * Could this qualifier name a module that exists in the workspace?
+ *
+ * A negative answer is authoritative and cheap: if the head segment matches no
+ * module name anywhere, no candidate channel can resolve it. Anchors keep their
+ * meaning (`crate::`/`self::`/`super::` are relative to the caller, so the head
+ * to test is the first non-anchor segment); an all-anchor qualifier (`self::f()`)
+ * names the caller's own module and is always worth trying.
+ */
+function couldNameAModule(qualifier, knownModuleNames) {
+    for (const segment of qualifier) {
+        if (segment === 'crate' || segment === '$crate' || segment === 'self' || segment === 'super') {
+            continue;
+        }
+        return knownModuleNames.has(segment);
+    }
+    return true;
+}
+/**
+ * Module identity of the file itself: its crate root plus the `::`-segments
+ * below it.
+ *
+ *   src/main.rs                     → { src,             [] }   (crate root module)
+ *   src/tools.rs                    → { src,             ['tools'] }
+ *   src/a/mod.rs                    → { src,             ['a'] }
+ *   src/a/b.rs                      → { src,             ['a', 'b'] }
+ *   crates/noob/src/tools/mod.rs    → { crates/noob/src, ['tools'] }
+ *
+ * Returns `undefined` for a file under no known crate root — the caller then has
+ * no module identity to reason about and must refuse rather than guess.
+ */
+function moduleOfFile(filePath, index) {
+    // A `src/bin/<name>.rs` entry file is its own crate root, not a module of the
+    // surrounding library.
+    const standalone = index.standaloneRootFiles.get(filePath);
+    if (standalone !== undefined)
+        return { crateRoot: standalone, segments: [] };
+    for (const crateRoot of index.crateRoots) {
+        const prefix = crateRoot === '' ? '' : `${crateRoot}/`;
+        if (crateRoot !== '' && !filePath.startsWith(prefix))
+            continue;
+        const rel = filePath.slice(prefix.length);
+        if (!rel.includes('/') && CRATE_ROOT_FILES.has(rel))
+            return { crateRoot, segments: [] };
+        const segments = rel.split('/');
+        const last = segments.pop();
+        if (last === undefined)
+            return undefined;
+        if (last !== MODULE_DIR_FILE) {
+            if (!last.endsWith('.rs'))
+                return undefined;
+            segments.push(last.slice(0, -'.rs'.length));
+        }
+        return { crateRoot, segments };
+    }
+    return undefined;
+}
+/** Full module identity of a definition: its file's module plus any `mod` blocks around it. */
+function moduleOfDef(filePath, namespacePrefix, index) {
+    const fileModule = moduleOfFile(filePath, index);
+    if (fileModule === undefined)
+        return undefined;
+    if (namespacePrefix === undefined || namespacePrefix === '')
+        return fileModule;
+    return {
+        crateRoot: fileModule.crateRoot,
+        segments: [...fileModule.segments, ...namespacePrefix.split('.')],
+    };
+}
+/**
+ * Resolve a written path's leading segments to a module, from the calling
+ * module. Mirrors rustc's anchor handling:
+ *
+ *   crate::a::b   → the caller's OWN crate, segments ['a','b']
+ *   self::a       → callerModule ++ ['a']
+ *   super::a      → callerModule[:-1] ++ ['a']
+ *   a::b          → relative; the caller resolves this against the candidate
+ *                   channels (child module, `use` binding), so it is returned
+ *                   as-is for the caller to try in context.
+ *
+ * An anchored path always stays inside the caller's crate — `crate::` names the
+ * current crate, and `super::`/`self::` are relative to it — so the resolved
+ * module inherits `callerModule.crateRoot`.
+ *
+ * `super` chains (`super::super::x`) are consumed left to right. Returns
+ * `undefined` when the chain walks above the crate root — an invalid path that
+ * must not silently resolve to something else.
+ */
+function resolveAnchoredModulePath(qualifier, callerModule) {
+    if (qualifier.length === 0)
+        return undefined;
+    const crateRoot = callerModule.crateRoot;
+    const head = qualifier[0];
+    if (head === 'crate' || head === '$crate') {
+        return { module: { crateRoot, segments: qualifier.slice(1) }, anchored: true };
+    }
+    if (head === 'self') {
+        return {
+            module: { crateRoot, segments: [...callerModule.segments, ...qualifier.slice(1)] },
+            anchored: true,
+        };
+    }
+    if (head === 'super') {
+        let i = 0;
+        const base = [...callerModule.segments];
+        while (i < qualifier.length && qualifier[i] === 'super') {
+            if (base.length === 0)
+                return undefined; // above the crate root
+            base.pop();
+            i++;
+        }
+        return { module: { crateRoot, segments: [...base, ...qualifier.slice(i)] }, anchored: true };
+    }
+    return { module: { crateRoot, segments: [...qualifier] }, anchored: false };
+}
+/**
+ * Identity comparison for two modules. The crate root participates: two modules
+ * with the same internal path in DIFFERENT crates are different modules, and
+ * conflating them is what let a workspace mis-bind or refuse (#2730 review H1).
+ */
+function sameModule(a, b) {
+    return (a.crateRoot === b.crateRoot &&
+        a.segments.length === b.segments.length &&
+        a.segments.every((seg, i) => seg === b.segments[i]));
+}