gitnexus 1.6.10-rc.21 → 1.6.10-rc.211

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

@@ -6,6 +6,7 @@
  * analysis.
  */
 import { findAncestorBeforeBoundary, FUNCTION_NODE_TYPES } from '../../utils/ast-helpers.js';
+import { walkToScope } from '../../utils/scope-tree-walk.js';
 const PYTHON_METHOD_CONTAINER_TYPES = new Set(['class_definition']);
 export function pythonFunctionDefinitionLabel(functionNode, defaultLabel) {
     if (defaultLabel !== 'Function')
@@ -15,11 +16,14 @@ export function pythonFunctionDefinitionLabel(functionNode, defaultLabel) {
 }
 // ─── bindingScopeFor ──────────────────────────────────────────────────────
 /** Python has no block scope, so the central extractor's "innermost
- *  enclosing scope" default is already correct: `for x in …` creates
- *  `x` in the enclosing function/module scope (because we never emit a
- *  `@scope.block` for the for-loop body), comprehension variables stay
- *  in their expression context, etc. Returns `null` to delegate. */
-export function pythonBindingScopeFor(_decl, _innermost, _tree) {
+ *  enclosing scope" default is already correct for ordinary bindings.
+ *  Constructor-injected instance fields are the exception: their marker is
+ *  anchored inside `__init__`, but compound receiver resolution needs the
+ *  field type on the enclosing Class scope. */
+export function pythonBindingScopeFor(decl, innermost, tree) {
+    if (decl['@type-binding.instance-field'] !== undefined) {
+        return walkToScope(innermost, tree, 'Class');
+    }
     return null;
 }
 // ─── importOwningScope ────────────────────────────────────────────────────

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

@@ -6,6 +6,8 @@ import { getTreeSitterBufferSize } from '../../constants.js';
 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([
@@ -13,6 +15,46 @@ const ATTR_CALL_NAMES = new Set([
     'attr_reader',
     'attr_writer',
 ]);
+const RUBY_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(['method', 'singleton_method', 'lambda']),
+    callNodeTypes: new Set(['call']),
+    parameterListNodeTypes: new Set(['method_parameters', 'argument_list']),
+    parameterNodeTypes: new Set([
+        'identifier',
+        'optional_parameter',
+        'splat_parameter',
+        'hash_splat_parameter',
+        'block_parameter',
+    ]),
+    bindingNodeTypes: new Set(['assignment']),
+    assignmentNodeTypes: new Set(['assignment', 'operator_assignment']),
+    identifierNodeTypes: new Set([
+        'identifier',
+        'constant',
+        'instance_variable',
+        'class_variable',
+        'global_variable',
+    ]),
+    functionScopedValueBindings: true,
+    callableProtocolMethods: new Set(['call']),
+    // A bare receiver-less identifier in value position is a method CALL in
+    // Ruby (`action = process` stores process's RETURN value) — only explicit
+    // reference forms (method(:x), &:x, lambda/proc) reference the callable.
+    bareNamesAreCalls: true,
+    extractCallableReference: (node) => {
+        if (node.type !== 'call')
+            return undefined;
+        const method = node.childForFieldName('method');
+        if (method?.text !== 'method' && method?.text !== 'public_method')
+            return undefined;
+        const args = node.childForFieldName('arguments');
+        const symbol = args?.namedChildren.find((child) => child !== null && child.type === 'simple_symbol');
+        if (symbol === undefined)
+            return undefined;
+        const name = symbol.text.replace(/^:/, '');
+        return name.length === 0 ? undefined : { name, anchor: symbol };
+    },
+};
 /**
  * Build the full `.`-joined qualified owner name for a heritage/attr call by
  * walking ALL enclosing class/module ancestors (not just the immediate one),
@@ -42,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) {
@@ -83,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'];
@@ -94,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;
         }
@@ -106,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;
         }
@@ -133,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;
         }
@@ -215,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
@@ -400,6 +599,7 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
     // flow through `emitHeritageEdges` (the `__heritage__:` import path above),
     // an independent lane that stays intact when the legacy heritage leg is gated off.
     out.push(...synthesizeRubySuperclassReferences(tree.rootNode));
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, RUBY_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
 /**

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,10 +1,23 @@
-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';
 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']),
+    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('::', '.'),
+};
 export function emitRustScopeCaptures(sourceText, _filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
@@ -82,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
@@ -114,9 +147,16 @@ 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));
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, RUST_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
 /**
@@ -161,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/interpret.js

@@ -1,6 +1,22 @@
 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 ──────────────────────────────────────────────────────
 export function interpretRustImport(captures) {
     const kind = captures['@import.kind']?.text;
@@ -104,6 +120,7 @@ export function normalizeRustTypeName(text) {
         if (inner !== null)
             t = inner;
     }
+    t = stripDynBound(t);
     const bracket = t.indexOf('<');
     if (bracket !== -1)
         t = t.slice(0, bracket);
@@ -168,6 +185,7 @@ function normalizeRustReturnType(text) {
             }
         }
     }
+    t = stripDynBound(t);
     const bracket = t.indexOf('<');
     if (bracket !== -1)
         t = t.slice(0, bracket);

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.