gitnexus 1.6.10-rc.99 → 1.6.10

package/dist/core/ingestion/languages/ruby/captures.js

@@ -7,6 +7,7 @@ import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { splitQualifiedName } from '../../utils/qualified-name.js';
 import { encodeMarker } from '../../utils/heritage-marker.js';
 import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+import { synthesizeReceiverChainCapture } from '../../utils/receiver-chain-captures.js';
 const FUNCTION_NODE_TYPES = ['method', 'singleton_method'];
 const HERITAGE_CALL_NAMES = new Set(['include', 'extend', 'prepend']);
 const ATTR_CALL_NAMES = new Set([
@@ -83,6 +84,123 @@ function buildEnclosingQualifiedName(callNode) {
     }
     return segments.length > 0 ? segments.join('.') : undefined;
 }
+/**
+ * Does this `@ivar` write land on an INSTANCE of the enclosing LEXICAL class?
+ *
+ * In Ruby an instance variable belongs to whatever `self` is at the point of
+ * the write, so this is really a question about `self`, and `self` is an
+ * instance of the enclosing lexical class only inside an ordinary `def` whose
+ * own definition site is that class's body. Every other arrangement writes an
+ * ivar some instance of this class will never see:
+ *
+ *   class C
+ *     @shared = Outer.new        # class body:       self == C
+ *     def self.build             # singleton_method: self == C
+ *       @pool = Outer.new
+ *     end
+ *     class << self              # singleton_class:  self == C
+ *       def warm; @cache = Outer.new; end
+ *     end
+ *     Other.class_eval do        # block receiver:   self == Other
+ *       def warm; @far = Outer.new; end
+ *     end
+ *     other.instance_eval { @alien = Outer.new }   # self == other
+ *     def run; @pool.inner; end  # reads nil — @pool was never set on an instance
+ *   end
+ *
+ * So the walk stops on the FIRST ancestor that decides who `self` is, and
+ * answers true only for an ordinary `method` reached without crossing any
+ * boundary that could have moved `self` elsewhere. `method` alone is NOT
+ * sufficient — a `def` nested in a `class << self` body, or in a `class_eval`
+ * block, is reached through a `method` node first — hence the flag rather than
+ * an early return (#2807).
+ *
+ * ── WHY BLOCKS ARE A HARD STOP, WITHOUT LOOKING AT THE CALL THEY BELONG TO ──
+ *
+ * A block is the one construct whose `self` (and whose "default definee", the
+ * class a `def` inside it attaches to) is chosen by its RECEIVER, not by its
+ * syntax. `Foo.class_eval do … end`, `Class.new do … end`, `Struct.new(:x) do …
+ * end`, `Data.define(:x) do … end`, `Module.new`, `refine`, `define_method`,
+ * `instance_eval`, `instance_exec`, `module_eval` and `class_exec` all rebind
+ * it; `[1].each do … end` does not.
+ *
+ * Telling those apart would need an enumeration of every method that rebinds a
+ * block's `self`, and that set is OPEN: any user-defined method can do it to a
+ * block it merely receives —
+ *
+ *   def helper(&blk) = Foo.class_eval(&blk)
+ *   helper { def warm; @far = Outer.new; end }   # attaches to Foo, not here
+ *
+ * — so no allow-list of "safe" call names is sound, and a deny-list of known
+ * rebinders is exactly the incomplete enumeration that produced this bug. The
+ * only complete answer available from the block's own syntax is that ownership
+ * is unprovable, so every block boundary is a stop. That over-discards a plain
+ * `each`/`tap` block, whose `self` really is the instance; per the safety
+ * doctrine (see `scope-resolution/passes/compound-receiver.ts`) a missed edge is
+ * the acceptable cost and a fabricated edge on the wrong class is not.
+ *
+ * A `class` / `module` keyword nested INSIDE a block still terminates the walk
+ * with a true answer, and correctly so: that keyword sets the definee lexically
+ * no matter what surrounds it, so `Class.new do class Inner; def m; @a = …`
+ * writes a real `Inner` instance field.
+ *
+ * ── FORMS THAT CANNOT REACH HERE AT ALL ────────────────────────────────────
+ *
+ * `obj.instance_variable_set(:@a, Outer.new)` is a `call`, not an `assignment`,
+ * and `Foo.class_eval "def warm; @a = Outer.new; end"` hides its body in a
+ * `string` node. Neither parses into the `(assignment left: (instance_variable)
+ * …)` pattern in query.ts, so neither ever produces the marker this gate reads.
+ *
+ * Deliberately conservative. A write this returns false for simply binds no
+ * type at all, which costs at most a missed edge; returning true too eagerly
+ * invents a call from a receiver that is always nil.
+ */
+function isRubyInstanceIvarWrite(ivarNode) {
+    if (ivarNode === undefined)
+        return false;
+    let insideMethodBody = false;
+    for (let ancestor = ivarNode.parent; ancestor !== null; ancestor = ancestor.parent) {
+        switch (ancestor.type) {
+            // `def self.x` / `def obj.x`, and `class << self` / `class << obj`.
+            case 'singleton_method':
+            case 'singleton_class':
+                return false;
+            // Every block body: `do … end` and `{ … }` are the only two the grammar
+            // produces. `lambda` (`->`) always wraps its body in one of them, so it
+            // can never be the first boundary today — it is listed because the
+            // boundary IS the lambda, and a grammar change must not silently
+            // un-guard it.
+            case 'do_block':
+            case 'block':
+            case 'lambda':
+                return false;
+            // `BEGIN { … }` / `END { … }` are program-level bodies whose execution is
+            // relocated out of the enclosing method (before the program, and at exit);
+            // Ruby warns when they appear in a method body at all. Rather than assert
+            // whose `self` runs them, the doctrine applies: unprovable, so discard.
+            // Reachable — tree-sitter parses `END { @a = Outer.new }` inside a `def`
+            // as an `end_block` under that method's body.
+            case 'begin_block':
+            case 'end_block':
+                return false;
+            case 'method':
+                insideMethodBody = true;
+                break;
+            // The owning body. Reaching it without crossing any of the boundaries
+            // above means the write is an instance write exactly when a `def` body
+            // enclosed it.
+            case 'class':
+            case 'module':
+            case 'program':
+                return insideMethodBody;
+            // Everything else is control flow that cannot move `self`: `if`/`unless`
+            // (`then`), `case`/`when`, `while`, `for`/`do`, `begin`/`rescue`/`ensure`.
+            default:
+                break;
+        }
+    }
+    return false;
+}
 export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
@@ -124,6 +242,22 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
         }
         if (Object.keys(grouped).length === 0)
             continue;
+        // A tree-sitter pattern cannot say "and no singleton ancestor", so the
+        // ownership test is a walk and the whole binding is dropped here when `self`
+        // is the class object rather than an instance.
+        //
+        // Dropping the MARKER alone is not enough, and the class-body shape is why:
+        // with the marker gone `rubyBindingScopeFor` declines to hoist and the
+        // binding falls back to its innermost scope — which for `@shared = Outer.new`
+        // written straight in the class body already IS the Class scope. It would
+        // arrive at the wrong place by default. Discarding the match is the only
+        // uniform answer, and it costs nothing that existed before: these ivar
+        // patterns are new in #2807, so a class-object ivar simply goes back to
+        // binding nothing, exactly as it did before the pattern was added.
+        if (grouped['@type-binding.ivar-field'] !== undefined &&
+            !isRubyInstanceIvarWrite(nodeMap['@type-binding.ivar-field'])) {
+            continue;
+        }
         // Decompose require/require_relative/load into import captures
         if (grouped['@import.statement'] !== undefined) {
             const anchor = grouped['@import.statement'];
@@ -135,6 +269,12 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
                     continue;
                 }
             }
+            // 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.
+            synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
             out.push(grouped);
             continue;
         }
@@ -147,6 +287,12 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
                 if (receiver !== null)
                     out.push(receiver);
             }
+            // 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.
+            synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
             out.push(grouped);
             continue;
         }
@@ -174,6 +320,12 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
                     grouped['@declaration.parameter-types'] = syntheticCapture('@declaration.parameter-types', fnNode, JSON.stringify(arity.parameterTypes));
                 }
             }
+            // 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.
+            synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
             out.push(grouped);
             continue;
         }
@@ -256,6 +408,12 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
                 grouped['@reference.arity'] = 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.
+        synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
         out.push(grouped);
     }
     // Second pass: member-call-return type bindings

package/dist/core/ingestion/languages/ruby/import-target.js

@@ -7,7 +7,7 @@
  *   - External gems             → null (unresolvable within the repo)
  */
 import { resolveRubyImportInternal } from '../../import-resolvers/ruby.js';
-import { buildSuffixIndex } from '../../import-resolvers/utils.js';
+import { getWorkspaceFileIndex } from '../../import-resolvers/workspace-file-index.js';
 import { isHeritageMarker } from '../../utils/heritage-marker.js';
 // ─── resolveRubyImportTarget ──────────────────────────────────────────────
 /**
@@ -78,8 +78,10 @@ function resolveRelative(targetRaw, fromDir, allFilePaths) {
  * via suffix matching using the existing Ruby import resolver.
  */
 function resolveBare(targetRaw, allFilePaths) {
-    const normalizedFileList = [...allFilePaths].map((f) => f.replace(/\\/g, '/'));
-    const allFileList = [...allFilePaths];
-    const index = buildSuffixIndex(normalizedFileList, allFileList);
-    return resolveRubyImportInternal(targetRaw, normalizedFileList, allFileList, index);
+    // Was: two array materializations plus a full `buildSuffixIndex` per require,
+    // thrown away on return — every require paid to index every file in the repo
+    // (#2880). `buildSuffixIndex` is a pure function of the file set, so this is a
+    // hoist, not a behaviour change.
+    const { normalized, all, index } = getWorkspaceFileIndex(allFilePaths);
+    return resolveRubyImportInternal(targetRaw, normalized, all, index);
 }

package/dist/core/ingestion/languages/ruby/query.js

@@ -77,6 +77,64 @@ const RUBY_SCOPE_QUERY = `
 (singleton_method
   name: (identifier) @declaration.name) @declaration.function
 
+;; ── Declarations — closure bound to a local ──────────────────────────────
+;;
+;; handler = ->(x) { target(x) } / lambda { |x| ... } / proc { |x| ... }
+;;
+;; Anchor discipline (same contract as javascript/query.ts): @declaration.function
+;; sits on the INNER (block), NOT on the assignment wrapper and NOT on the
+;; (lambda) node — the block is what carries @scope.block above, so anchoring
+;; there aligns anchor.range with the scope range. That alignment is what lets
+;; pickCallerCallableDef accept a Block-kind scope as a callable boundary.
+;; do_block/block stay @scope.block deliberately — do NOT re-kind them.
+;;
+;; The call forms are restricted to lambda/proc by name. An unrestricted
+;; (call block: (block)) would match ANY method call with a block, so
+;; mapped = items.map { |i| ... } would wrongly declare mapped a callable.
+;; Separate #eq? patterns rather than one #match? alternation: alternation
+;; predicates are a known hazard on this tree-sitter line.
+;; BOTH block forms in every pattern. do...end produces (do_block), braces
+;; produce (block), and do/end is the dominant MULTI-LINE style — covering only
+;; braces left lambda-do-end with a Block scope owning nothing, so its
+;; calls fell through to the enclosing method. @scope.block above already covers
+;; both, so the two channels now agree.
+;;
+;; The !receiver constraint is load-bearing: without it #eq? tests the method
+;; NAME only, so MyMod.lambda {...} / obj.proc {...} would be captured as
+;; closure bindings. Verified against the grammar: with !receiver those are
+;; rejected while bare lambda/proc still match.
+(assignment
+  left: (identifier) @declaration.name
+  right: (lambda body: [(block) (do_block)] @declaration.function))
+
+(assignment
+  left: (identifier) @declaration.name
+  right: (call
+    !receiver
+    method: (identifier) @_lambda-kw
+    block: [(block) (do_block)] @declaration.function)
+  (#eq? @_lambda-kw "lambda"))
+
+(assignment
+  left: (identifier) @declaration.name
+  right: (call
+    !receiver
+    method: (identifier) @_proc-kw
+    block: [(block) (do_block)] @declaration.function)
+  (#eq? @_proc-kw "proc"))
+
+;; Proc.new { ... } / Proc.new do ... end — the explicit constructor form.
+;; Receiver IS required here and must be the Proc constant, so this cannot
+;; collide with the bare-call patterns above.
+(assignment
+  left: (identifier) @declaration.name
+  right: (call
+    receiver: (constant) @_proc-const
+    method: (identifier) @_new-kw
+    block: [(block) (do_block)] @declaration.function)
+  (#eq? @_proc-const "Proc")
+  (#eq? @_new-kw "new"))
+
 ;; ── Declarations — variable assignment ───────────────────────────────────
 
 (assignment
@@ -118,6 +176,41 @@ const RUBY_SCOPE_QUERY = `
     method: (identifier) @_new_method2
     (#eq? @_new_method2 "new"))) @type-binding.constructor
 
+;; Instance-variable constructor: \`@service = UserService.new\` (#2807).
+;; The patterns above bind locals and constants; an instance variable — the
+;; only way a Ruby object gets a field at all — bound nothing, so \`@service.run\`
+;; had no receiver type and the fold declined the whole chain.
+;;
+;; \`@type-binding.name\` is captured on the \`instance_variable\` node, so the
+;; bound name keeps its \`@\` sigil and matches the receiver text at the call
+;; site verbatim. The narrow \`@type-binding.ivar-field\` marker rides the same
+;; node for \`rubyBindingScopeFor\` to hoist on; anchorCaptureFor takes the
+;; broadest range, so the assignment stays the anchor and the source stays
+;; \`constructor-inferred\`.
+;;
+;; These patterns match unconditionally HERE; captures.ts then discards the
+;; whole binding via \`isRubyInstanceIvarWrite\` unless \`self\` at the write is
+;; provably an instance of the enclosing lexical class — which rules out
+;; \`def self.x\`, \`class << self\`, the class body itself, and any write reached
+;; through a block, whose \`self\` its receiver chooses (\`class_eval\`,
+;; \`Class.new\`, \`instance_eval\`, \`define_method\`, …). A tree-sitter pattern
+;; cannot state "and no singleton or block ancestor", so the ownership test has
+;; to be a walk.
+
+(assignment
+  left: (instance_variable) @type-binding.name @type-binding.ivar-field
+  right: (call
+    receiver: (constant) @type-binding.type
+    method: (identifier) @_new_ivar
+    (#eq? @_new_ivar "new"))) @type-binding.constructor
+
+(assignment
+  left: (instance_variable) @type-binding.name @type-binding.ivar-field
+  right: (call
+    receiver: (scope_resolution) @type-binding.type
+    method: (identifier) @_new_ivar_q
+    (#eq? @_new_ivar_q "new"))) @type-binding.constructor
+
 ;; Constant constructor: SERVICE = UserService.new (left is constant, not identifier)
 
 (assignment

package/dist/core/ingestion/languages/ruby/scope-resolver.js

@@ -241,6 +241,8 @@ function expandRubyWildcardNames(targetModuleScope, parsedFiles) {
     return names;
 }
 export const rubyScopeResolver = {
+    // Construction is a selector on the class: `Service.new.do_work` (#2708).
+    constructionSyntax: { selector: 'new' },
     language: SupportedLanguages.Ruby,
     languageProvider: rubyProvider,
     importEdgeReason: 'ruby-scope: import',

package/dist/core/ingestion/languages/ruby/simple-hooks.d.ts

@@ -1,6 +1,6 @@
 import type { CaptureMatch, ParsedImport, Scope, ScopeId, ScopeTree, TypeRef, NodeLabel } from '../../../../_shared/index.js';
 import type { SyntaxNode } from '../../utils/ast-helpers.js';
-export declare function rubyBindingScopeFor(decl: CaptureMatch, innermost: Scope, _tree: ScopeTree): ScopeId | null;
+export declare function rubyBindingScopeFor(decl: CaptureMatch, innermost: Scope, tree: ScopeTree): ScopeId | null;
 /**
  * Ruby `require` / `include` inside a function or class body should attach
  * at that scope, not module scope.

package/dist/core/ingestion/languages/ruby/simple-hooks.js

@@ -1,9 +1,30 @@
-export function rubyBindingScopeFor(decl, innermost, _tree) {
+import { walkToScope } from '../../utils/scope-tree-walk.js';
+export function rubyBindingScopeFor(decl, innermost, tree) {
     // Keep self typeBindings in the method's Function scope so
     // populateClassOwnedMembers can match Method defs to their receiver types.
     if (decl['@type-binding.self'] !== undefined) {
         return innermost.id;
     }
+    // `@ivar = Foo.new` in `initialize` (or any method) declares a FIELD of the
+    // enclosing class, so its type binding belongs on the Class scope — the only
+    // place `typeOfMemberOnClass` reads it. Left on the method's own Function
+    // scope it would be invisible to every other method (#2807).
+    //
+    // Gated on the marker that pattern emits, never on `@type-binding.constructor`
+    // at large: that capture also fires for `x = Foo.new` locals, and hoisting
+    // those to the class would leak a method local into every sibling method.
+    //
+    // Reaching this hook already means the write is an INSTANCE write. `Capture`
+    // carries only name/range/text — no AST node — so this hook cannot ask whose
+    // `self` owns the ivar; `isRubyInstanceIvarWrite` (captures.ts) answers that
+    // upstream and discards the binding entirely whenever `self` is anything but
+    // an instance of the enclosing lexical class — the class object itself
+    // (`def self.x`, `class << self`, the class body), or whatever object a block
+    // receiver rebinds it to (`class_eval`, `Class.new`, `instance_eval`, …).
+    // None of those reach an instance, so none may be published as its field.
+    if (decl['@type-binding.ivar-field'] !== undefined) {
+        return walkToScope(innermost, tree, 'Class');
+    }
     return null;
 }
 /**

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

@@ -1,4 +1,4 @@
-import { nodeIfType, nodeToCapture, syntheticCapture, walkNamedTree, } from '../../utils/ast-helpers.js';
+import { findChild, nodeIfType, nodeToCapture, syntheticCapture, walkNamedTree, } from '../../utils/ast-helpers.js';
 import { getRustParser, getRustScopeQuery } from './query.js';
 import { recordRustCacheHit, recordRustCacheMiss } from './cache-stats.js';
 import { splitRustUseDeclaration } from './import-decomposer.js';
@@ -6,6 +6,7 @@ import { synthesizeRustReceiverBinding } from './receiver-binding.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+import { synthesizeReceiverChainCapture } from '../../utils/receiver-chain-captures.js';
 const RUST_CALLABLE_CAPTURE_OPTIONS = {
     functionNodeTypes: new Set(['function_item', 'closure_expression']),
     callNodeTypes: new Set(['call_expression']),
@@ -94,6 +95,26 @@ export function emitRustScopeCaptures(sourceText, _filePath, cachedTree) {
                 }
             }
         }
+        // `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'] = 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
@@ -126,6 +147,12 @@ export function emitRustScopeCaptures(sourceText, _filePath, cachedTree) {
                 grouped['@reference.arity'] = 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.
+        synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
         out.push(grouped);
     }
     out.push(...synthesizeRustInheritanceReferences(tree.rootNode));
@@ -174,10 +201,21 @@ function synthesizeRustInheritanceReferences(root) {
         const structName = bareTypeIdentifier(typeField);
         if (traitName === null || structName === null)
             return;
+        // The trait's generic ARGUMENTS (`impl Validator<String> for V`), so
+        // interface dispatch can tell one instantiation of a trait from another
+        // (#2912). Emitted as a sub-tag rather than by widening the anchor: the
+        // anchor is the bare `type_identifier` inside the `generic_type`, and its
+        // range is part of the inheritance edge's id.
+        const traitArguments = traitField.type === 'generic_type' ? findChild(traitField, 'type_arguments') : null;
         out.push({
             '@reference.inherits': nodeToCapture('@reference.inherits', traitName),
             '@reference.name': nodeToCapture('@reference.name', traitName),
             '@reference.receiver': syntheticCapture('@reference.receiver', structName, structName.text),
+            ...(traitArguments === null
+                ? {}
+                : {
+                    '@reference.type-arguments': nodeToCapture('@reference.type-arguments', traitArguments),
+                }),
         });
     });
     return out;

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

@@ -1,4 +1,4 @@
-import { isClassLike, populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { isClassLike, populateClassOwnedMembers, tagNamespacePrefixes, } from '../../scope-resolution/scope/walkers.js';
 /**
  * Populate `ownerId` on Rust method defs.
  *
@@ -19,6 +19,16 @@ import { isClassLike, populateClassOwnedMembers } from '../../scope-resolution/s
 export function populateRustOwners(parsed) {
     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).
+    tagNamespacePrefixes(parsed, { qualifiedNamesCarryNamespace: false });
 }
 function populateRustImplOwners(parsed) {
     // Build a map of struct name → def nodeId from all scopes.

package/dist/core/ingestion/languages/rust/module-path.d.ts

@@ -0,0 +1,126 @@
+/**
+ * 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.
+ */
+/**
+ * A module's full identity: the crate it belongs to, plus its `::`-path inside
+ * that crate. `segments` is empty for the crate-root module itself.
+ */
+export interface RustModule {
+    /** Crate-root directory (`src`, `crates/noob/src`, or `''` at repo root). */
+    readonly crateRoot: string;
+    readonly segments: readonly string[];
+}
+export interface RustModuleIndex {
+    /** Crate-root directories, longest first, so nested crates win. */
+    readonly crateRoots: readonly string[];
+    /**
+     * Every module name derivable from a FILE PATH, as a flat set of single
+     * segments. Inline `mod x { … }` names are absent by construction — they exist
+     * in no path — so this is only half of the negative filter's input; the
+     * resolver unions it with the inline module names it collects from the scope
+     * model (#2742).
+     */
+    readonly moduleNames: ReadonlySet<string>;
+    /**
+     * Entry files that are a crate root in their own right rather than a module of
+     * the surrounding crate — `src/bin/<name>.rs` auto-discovered binary targets.
+     * Maps the entry file to the directory its own submodules live under.
+     */
+    readonly standaloneRootFiles: ReadonlyMap<string, string>;
+}
+/**
+ * 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).
+ */
+export declare function buildRustModuleIndex(allFilePaths: ReadonlySet<string>): RustModuleIndex;
+/**
+ * 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.
+ */
+export declare function couldNameAModule(qualifier: readonly string[], knownModuleNames: ReadonlySet<string>): boolean;
+/**
+ * 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.
+ */
+export declare function moduleOfFile(filePath: string, index: RustModuleIndex): RustModule | undefined;
+/** Full module identity of a definition: its file's module plus any `mod` blocks around it. */
+export declare function moduleOfDef(filePath: string, namespacePrefix: string | undefined, index: RustModuleIndex): RustModule | undefined;
+/**
+ * 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.
+ */
+export declare function resolveAnchoredModulePath(qualifier: readonly string[], callerModule: RustModule): {
+    readonly module: RustModule;
+    readonly anchored: boolean;
+} | undefined;
+/**
+ * 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).
+ */
+export declare function sameModule(a: RustModule, b: RustModule): boolean;