gitnexus 1.6.6-rc.98 → 1.6.6

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

@@ -1,4 +1,4 @@
-import { findNodeAtRange, nodeToCapture, syntheticCapture, } from '../../utils/ast-helpers.js';
+import { 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';
@@ -20,18 +20,24 @@ export function emitRustScopeCaptures(sourceText, _filePath, cachedTree) {
     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] = 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 anchor = grouped['@import.statement'];
-            const useNode = findNodeAtRange(tree.rootNode, anchor.range, 'use_declaration');
+            const useNode = nodeIfType(nodeMap['@import.statement'], 'use_declaration');
             if (useNode !== null) {
                 out.push(...splitRustUseDeclaration(useNode));
                 continue;
@@ -40,8 +46,7 @@ export function emitRustScopeCaptures(sourceText, _filePath, cachedTree) {
         // Synthesize self receiver bindings for methods inside impl blocks
         let cachedImplLookup;
         if (grouped['@scope.function'] !== undefined) {
-            const scopeCap = grouped['@scope.function'];
-            const fnNode = findNodeAtRange(tree.rootNode, scopeCap.range, 'function_item');
+            const fnNode = nodeIfType(nodeMap['@scope.function'], 'function_item');
             if (fnNode !== null) {
                 const implNode = findEnclosingImpl(fnNode);
                 cachedImplLookup = { fnNode, implNode };
@@ -53,7 +58,7 @@ export function emitRustScopeCaptures(sourceText, _filePath, cachedTree) {
         // Attach declaration arity for functions/methods
         const declAnchor = grouped['@declaration.function'];
         if (declAnchor !== undefined) {
-            const fnNode = findNodeAtRange(tree.rootNode, declAnchor.range, 'function_item');
+            const fnNode = nodeIfType(nodeMap['@declaration.function'], 'function_item');
             if (fnNode !== null) {
                 const implNode = cachedImplLookup?.fnNode === fnNode
                     ? cachedImplLookup.implNode
@@ -86,7 +91,7 @@ export function emitRustScopeCaptures(sourceText, _filePath, cachedTree) {
         if (grouped['@type-binding.return'] !== undefined &&
             grouped['@type-binding.name'] !== undefined) {
             const tbReturnAnchor = grouped['@type-binding.return'];
-            const fnNode = findNodeAtRange(tree.rootNode, tbReturnAnchor.range, 'function_item');
+            const fnNode = nodeIfType(nodeMap['@type-binding.return'], 'function_item');
             if (fnNode !== null) {
                 const implNode = findEnclosingImpl(fnNode);
                 if (implNode !== null) {
@@ -99,12 +104,11 @@ export function emitRustScopeCaptures(sourceText, _filePath, cachedTree) {
             }
         }
         // Attach call arity for call expressions
-        const callAnchor = grouped['@reference.call.free'] ??
-            grouped['@reference.call.member'] ??
-            grouped['@reference.call.constructor'];
-        if (callAnchor !== undefined) {
-            const callNode = findNodeAtRange(tree.rootNode, callAnchor.range, 'call_expression') ??
-                findNodeAtRange(tree.rootNode, callAnchor.range, 'struct_expression');
+        const callAnchorNode = nodeMap['@reference.call.free'] ??
+            nodeMap['@reference.call.member'] ??
+            nodeMap['@reference.call.constructor'];
+        if (callAnchorNode !== undefined) {
+            const callNode = nodeIfType(callAnchorNode, 'call_expression', 'struct_expression');
             if (callNode !== null) {
                 const arity = computeRustCallArity(callNode);
                 grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(arity));
@@ -112,8 +116,86 @@ export function emitRustScopeCaptures(sourceText, _filePath, cachedTree) {
         }
         out.push(grouped);
     }
+    out.push(...synthesizeRustInheritanceReferences(tree.rootNode));
     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 = [];
+    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': nodeToCapture('@reference.inherits', traitName),
+            '@reference.name': nodeToCapture('@reference.name', traitName),
+            '@reference.receiver': 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) {

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

@@ -7,6 +7,7 @@ const RUST_SCOPE_QUERY = `
 (trait_item) @scope.class
 (impl_item) @scope.class
 (enum_item) @scope.class
+(union_item) @scope.class
 (function_item) @scope.function
 (closure_expression) @scope.function
 (block) @scope.block
@@ -29,6 +30,26 @@ const RUST_SCOPE_QUERY = `
 (enum_item
   name: (type_identifier) @declaration.name) @declaration.enum
 
+;; Declarations — union
+;; Deliberately tagged @declaration.struct (→ Struct label), NOT a
+;; @declaration.union: every registry-primary resolution gate —
+;; isLinkableLabel (node-lookup.ts), CALLABLE_OR_TYPE_LIKE
+;; (finalize-algorithm.ts), ClassLikeNodeLabel (class-types.ts) — includes
+;; Struct but EXCLUDES Union, so a Union-labeled node would be an
+;; unresolvable orphan. A Rust union is a type whose literal is a real
+;; constructor, so Struct is both the resolvable and the semantically
+;; honest label here. #1934 F71.
+(union_item
+  name: (type_identifier) @declaration.name) @declaration.struct
+
+;; Declarations — macro (macro_rules! foo { ... })
+;; Captured as @declaration.macro → Macro label. A macro invocation
+;; (@reference.macro, below) resolves to this definition via MacroRegistry,
+;; whose acceptedKinds is ['Macro'] ONLY — so an invoked macro never binds
+;; to a same-named free function (log!() is not fn log). #1934 F72.
+(macro_definition
+  name: (identifier) @declaration.name) @declaration.macro
+
 ;; Declarations — function (top-level or inside mod)
 (function_item
   name: (identifier) @declaration.name) @declaration.function
@@ -39,6 +60,10 @@ const RUST_SCOPE_QUERY = `
   type: (_) @declaration.field-type) @declaration.field
 
 ;; Declarations — variables (let bindings)
+;; Uses pattern:(identifier) — works for let x and let mut x (mutable_specifier
+;; is a sibling, not a wrapper). Destructuring patterns like let (a, b) use
+;; tuple_pattern etc. which pattern:(identifier) intentionally does not match;
+;; capturing them with (_) would produce "(a, b)" as the name, which is useless.
 (let_declaration
   pattern: (identifier) @declaration.name) @declaration.variable
 
@@ -108,8 +133,46 @@ const RUST_SCOPE_QUERY = `
     name: (identifier) @reference.name)) @reference.call.free
 
 ;; References — constructor calls (struct literal)
+;; tree-sitter-rust gives struct_expression.name one of three node types
+;; (type_identifier | scoped_type_identifier | generic_type_with_turbofish);
+;; the turbofish form additionally nests either a type_identifier or a
+;; scoped_identifier. We enumerate all four shapes below so the capture is
+;; always the trailing identifier (resolved scope-aware), not the full path:
+;;   bare              Foo {}
+;;   scoped            foo::bar::Baz {}
+;;   turbofish         Foo::<T> {}
+;;   scoped+turbofish  foo::Bar::<T> {}
+(struct_expression
+  name: (type_identifier) @reference.name) @reference.call.constructor
+
+;; Scoped struct (foo::bar::Baz {})
+(struct_expression
+  name: (scoped_type_identifier
+    name: (type_identifier) @reference.name)) @reference.call.constructor
+
+;; Turbofish struct (Foo::<T> {})
+(struct_expression
+  name: (generic_type_with_turbofish
+    type: (type_identifier) @reference.name)) @reference.call.constructor
+
+;; Scoped + turbofish struct (foo::Bar::<T> {}) — the turbofish wraps a
+;; scoped_identifier whose tail is an identifier (not a type_identifier).
 (struct_expression
-  name: (_) @reference.name) @reference.call.constructor
+  name: (generic_type_with_turbofish
+    type: (scoped_identifier
+      name: (identifier) @reference.name))) @reference.call.constructor
+
+;; References — macro invocations (disjoint namespace from functions)
+;; Resolved via MacroRegistry → Macro defs only (never fn of the same name).
+(macro_invocation
+  macro: (identifier) @reference.name) @reference.macro
+
+;; Scoped macro invocation (log::info!(…)) — capture the tail identifier,
+;; mirroring the scoped free-call pattern above, so the resolved name is
+;; the tail (info), not the full path (log::info).
+(macro_invocation
+  macro: (scoped_identifier
+    name: (identifier) @reference.name)) @reference.macro
 
 ;; References — field reads
 (field_expression

package/dist/core/ingestion/languages/rust/range-binding.js

@@ -1,6 +1,7 @@
 import { getRustParser } from './query.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
-import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { parseSourceSafe, ParseTimeoutError } from '../../../tree-sitter/safe-parse.js';
+import { logger } from '../../../logger.js';
 /**
  * Populate type bindings for patterns and iterators that the tree-sitter
  * query can't handle (they need runtime type lookup, not just syntax).
@@ -20,10 +21,24 @@ export function populateRustRangeBindings(parsedFiles, _indexes, ctx) {
         if (sourceText === undefined)
             continue;
         const cachedTree = ctx.treeCache?.get(parsed.filePath);
-        const tree = cachedTree ??
-            parseSourceSafe(parser, sourceText, undefined, {
-                bufferSize: getTreeSitterBufferSize(sourceText),
-            });
+        let tree;
+        if (cachedTree !== undefined) {
+            tree = cachedTree;
+        }
+        else {
+            try {
+                tree = parseSourceSafe(parser, sourceText, undefined, {
+                    bufferSize: getTreeSitterBufferSize(sourceText),
+                });
+            }
+            catch (err) {
+                if (err instanceof ParseTimeoutError) {
+                    logger.warn({ file: parsed.filePath }, 'rust range-binding: parse timed out, skipping file');
+                    continue;
+                }
+                throw err;
+            }
+        }
         for (const fn of tree.rootNode.descendantsOfType('function_item')) {
             const nameNode = fn.childForFieldName('name');
             const retType = fn.childForFieldName('return_type');
@@ -66,10 +81,24 @@ export function populateRustRangeBindings(parsedFiles, _indexes, ctx) {
         if (sourceText === undefined)
             continue;
         const cachedTree = ctx.treeCache?.get(parsed.filePath);
-        const tree = cachedTree ??
-            parseSourceSafe(parser, sourceText, undefined, {
-                bufferSize: getTreeSitterBufferSize(sourceText),
-            });
+        let tree;
+        if (cachedTree !== undefined) {
+            tree = cachedTree;
+        }
+        else {
+            try {
+                tree = parseSourceSafe(parser, sourceText, undefined, {
+                    bufferSize: getTreeSitterBufferSize(sourceText),
+                });
+            }
+            catch (err) {
+                if (err instanceof ParseTimeoutError) {
+                    logger.warn({ file: parsed.filePath }, 'rust range-binding: parse timed out, skipping file');
+                    continue;
+                }
+                throw err;
+            }
+        }
         const scopeMap = new Map(parsed.scopes.map((s) => [s.id, s]));
         const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
         if (moduleScope === undefined)
@@ -233,11 +262,10 @@ function processStructDestructuring(root, parsed, scopeMap, moduleScope, allFiel
         for (const fieldNode of patternNode.namedChildren) {
             let fieldName;
             if (fieldNode.type === 'field_pattern') {
+                // shorthand `{ a }` and full `{ b: c }` are both field_pattern; the
+                // `name` field is shorthand_field_identifier or field_identifier.
                 fieldName = fieldNode.childForFieldName('name')?.text;
             }
-            else if (fieldNode.type === 'shorthand_field_pattern') {
-                fieldName = fieldNode.firstNamedChild?.text;
-            }
             if (fieldName === undefined)
                 continue;
             let fieldType = lookupFieldType(typeName, fieldName, parsed, scopeMap, moduleScope);

package/dist/core/ingestion/languages/rust/receiver-binding.js

@@ -121,6 +121,15 @@ export function getImplTraitName(implNode) {
     }
     return null;
 }
+// NOTE: this strips reference/pointer sigils and generic arguments but NOT a
+// path qualifier, so `crate::traits::Drawable` stays qualified here — whereas
+// the inheritance synth (rust/captures.ts `bareTypeIdentifier`) resolves scoped
+// bases by their trailing simple name (`Drawable`). The two intentionally
+// diverge for scoped paths. This is inert today (`getImplTraitName` has no
+// ingestion consumer and Rust's `isSuperReceiver` is false, so nothing keys an
+// edge on this name); the synth is the single source of truth for the
+// inheritance edge. A future change that wires `getImplTraitName` into
+// resolution must reconcile this with the synth's tail-only normalization.
 function normalizeRustTypeName(text) {
     let t = text.trim();
     while (t.startsWith('&'))

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

@@ -4,8 +4,81 @@ import { rustProvider } from '../rust.js';
 import { rustArityCompatibility, rustMergeBindings, resolveRustImportTarget } from './index.js';
 import { populateRustOwners } from './method-owners.js';
 import { populateRustRangeBindings } from './range-binding.js';
-import { isClassLike } from '../../scope-resolution/scope/walkers.js';
+import { isClassLike, findClassBindingInScope, resolveAmbiguousInheritanceBaseViaImports, } from '../../scope-resolution/scope/walkers.js';
 import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
+import { generateId } from '../../../../lib/utils.js';
+/**
+ * Emit Rust `S IMPLEMENTS T` edges from `impl T for S` trait implementations.
+ *
+ * Rust inheritance is not a base list on the type declaration — it lives on
+ * `impl_item { trait: T, type: S }`. The shared `preEmitInheritanceEdges` pass
+ * derives an `@reference.inherits` site's edge SOURCE from the enclosing class
+ * def, but an `impl_item` scope owns no class-like def, so that pass cannot
+ * produce these edges (it only marks the sites handled). The `@reference.inherits`
+ * sites synthesized in `captures.ts` carry the trait `T` as `site.name` (target)
+ * and the struct `S` as `site.explicitReceiver.name` (source); this hook reads
+ * them back and emits the IMPLEMENTS edge with source `S`, target `T`, and the
+ * legacy `'trait-impl'` reason — matching the legacy heritage DAG (#1951).
+ *
+ * Resolution is scope-aware and import-aware, mirroring the shared
+ * `preEmitInheritanceEdges` pass: both `S` and `T` resolve from the `impl`
+ * block's own scope via `findClassBindingInScope` (scope-chain + single-match
+ * fallbacks), then `resolveAmbiguousInheritanceBaseViaImports` for a name that
+ * several modules declare (disambiguated by the referencing file's `use`
+ * imports). A trait `T` is commonly declared in a different file (e.g. the
+ * `rust-traits` fixture imports `Drawable`/`Clickable` from a sibling module);
+ * the scope chain reaches it through those `use` bindings. When a name does
+ * not resolve to exactly one class-like def — unresolved (e.g. a std trait
+ * like `Default`) OR ambiguous across modules (two same-named `struct`s /
+ * traits) — NO edge is emitted, restoring the legacy file-scoped path's
+ * "a wrong edge is worse than no edge" invariant. (The prior global
+ * simple-name index used last-write-wins and could source an `impl` edge from
+ * the wrong same-named def across modules.) Idempotent: pre-seeds the dedup
+ * set from existing IMPLEMENTS edges so a worker-mode legacy emission (or a
+ * re-resolution) is not duplicated.
+ */
+function emitRustTraitImplEdges(graph, parsedFiles, nodeLookup, scopes) {
+    if (scopes === undefined)
+        return;
+    const emitted = new Set();
+    for (const rel of graph.iterRelationshipsByType('IMPLEMENTS')) {
+        emitted.add(`${rel.sourceId}->${rel.targetId}`);
+    }
+    for (const parsed of parsedFiles) {
+        for (const site of parsed.referenceSites) {
+            if (site.kind !== 'inherits')
+                continue;
+            const structName = site.explicitReceiver?.name;
+            const traitName = site.name;
+            if (structName === undefined || structName === '' || traitName === '')
+                continue;
+            // Scope-aware (+ import-aware) resolution from the impl block's scope.
+            // Refuse when either end is unresolved or ambiguous.
+            const structDef = findClassBindingInScope(site.inScope, structName, scopes) ??
+                resolveAmbiguousInheritanceBaseViaImports(site.inScope, structName, scopes);
+            const traitDef = findClassBindingInScope(site.inScope, traitName, scopes) ??
+                resolveAmbiguousInheritanceBaseViaImports(site.inScope, traitName, scopes);
+            if (structDef === undefined || traitDef === undefined)
+                continue;
+            const structGraphId = resolveDefGraphId(structDef.filePath, structDef, nodeLookup);
+            const traitGraphId = resolveDefGraphId(traitDef.filePath, traitDef, nodeLookup);
+            if (structGraphId === undefined || traitGraphId === undefined)
+                continue;
+            const edgeKey = `${structGraphId}->${traitGraphId}`;
+            if (emitted.has(edgeKey))
+                continue;
+            emitted.add(edgeKey);
+            graph.addRelationship({
+                id: generateId('IMPLEMENTS', `${edgeKey}:trait-impl`),
+                sourceId: structGraphId,
+                targetId: traitGraphId,
+                type: 'IMPLEMENTS',
+                confidence: 0.85,
+                reason: 'trait-impl',
+            });
+        }
+    }
+}
 function buildRustMro(graph, parsedFiles, nodeLookup) {
     const baseMro = buildMro(graph, parsedFiles, nodeLookup, defaultLinearize);
     const defIdByGraphId = new Map();
@@ -52,6 +125,7 @@ export const rustScopeResolver = {
     mergeBindings: (existing, incoming, scopeId) => rustMergeBindings(existing, incoming, scopeId),
     arityCompatibility: (callsite, def) => rustArityCompatibility(def, callsite),
     buildMro: (graph, parsedFiles, nodeLookup) => buildRustMro(graph, parsedFiles, nodeLookup),
+    emitHeritageEdges: (graph, parsedFiles, nodeLookup, scopes) => emitRustTraitImplEdges(graph, parsedFiles, nodeLookup, scopes),
     populateOwners: (parsed) => populateRustOwners(parsed),
     isSuperReceiver: () => false,
     populateRangeBindings: populateRustRangeBindings,

package/dist/core/ingestion/languages/rust.d.ts

@@ -5,8 +5,6 @@
  * LanguageProvider, following the Strategy pattern used by the pipeline.
  *
  * Key Rust traits:
- *   - importSemantics: 'named' (Rust has use X::{a, b})
  *   - mroStrategy: 'qualified-syntax' (Rust uses trait qualification, not MRO)
- *   - namedBindingExtractor: present (use X::{a, b} extracts named bindings)
  */
 export declare const rustProvider: import("../language-provider.js").LanguageProvider;

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

@@ -5,9 +5,7 @@
  * LanguageProvider, following the Strategy pattern used by the pipeline.
  *
  * Key Rust traits:
- *   - importSemantics: 'named' (Rust has use X::{a, b})
  *   - mroStrategy: 'qualified-syntax' (Rust uses trait qualification, not MRO)
- *   - namedBindingExtractor: present (use X::{a, b} extracts named bindings)
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
@@ -17,7 +15,6 @@ import { typeConfig as rustConfig } from '../type-extractors/rust.js';
 import { rustExportChecker } from '../export-detection.js';
 import { createImportResolver } from '../import-resolvers/resolver-factory.js';
 import { rustImportConfig } from '../import-resolvers/configs/rust.js';
-import { extractRustNamedBindings } from '../named-bindings/rust.js';
 import { RUST_QUERIES } from '../tree-sitter-queries.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { rustConfig as rustFieldConfig } from '../field-extractors/configs/rust.js';
@@ -27,7 +24,6 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { rustVariableConfig } from '../variable-extractors/configs/rust.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { rustCallConfig } from '../call-extractors/configs/rust.js';
-import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 import { emitRustScopeCaptures, rustArityCompatibility, rustBindingScopeFor, rustImportOwningScope, rustReceiverBinding, interpretRustImport, interpretRustTypeBinding, } from './rust/index.js';
 /** Rust impl_item: find the function_item child and extract its name as a Method. */
 const rustExtractFunctionName = (node) => {
@@ -153,7 +149,6 @@ export const rustProvider = defineLanguage({
     typeConfig: rustConfig,
     exportChecker: rustExportChecker,
     importResolver: createImportResolver(rustImportConfig),
-    namedBindingExtractor: extractRustNamedBindings,
     mroStrategy: 'qualified-syntax',
     callExtractor: createCallExtractor(rustCallConfig),
     fieldExtractor: createFieldExtractor(rustFieldConfig),
@@ -163,7 +158,6 @@ export const rustProvider = defineLanguage({
     }),
     variableExtractor: createVariableExtractor(rustVariableConfig),
     classExtractor: createClassExtractor(rustClassConfig),
-    heritageExtractor: createHeritageExtractor(SupportedLanguages.Rust),
     builtInNames: BUILT_INS,
     // ── RFC #909 Ring 3: scope-based resolution hooks ──────────
     emitScopeCaptures: emitRustScopeCaptures,

package/dist/core/ingestion/languages/swift/arity-metadata.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Extract Swift arity metadata from a function-like tree-sitter node —
+ * `function_declaration`, `protocol_function_declaration`, or
+ * `init_declaration`.
+ *
+ * Reuses `swiftMethodConfig.extractParameters` so scope-extracted defs
+ * carry the same arity semantics as the legacy parse-worker path:
+ *   - Variadic params (`xs: Int...`) collapse `parameterCount` to
+ *     `undefined`, which `swiftArityCompatibility` treats as "max
+ *     unknown" — the candidate stays eligible at `argCount >= required`.
+ *   - Defaulted params (`= expr`) contribute to `optionalCount`;
+ *     `requiredParameterCount = total − optionalCount`.
+ *   - `parameterTypes` collects declared type names for narrowing; a
+ *     literal `'variadic'` marker is appended for variadic methods so
+ *     `swiftArityCompatibility` can detect them without re-reading AST.
+ */
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+interface SwiftArityMetadata {
+    readonly parameterCount: number | undefined;
+    readonly requiredParameterCount: number | undefined;
+    readonly parameterTypes: readonly string[] | undefined;
+}
+export declare function computeSwiftArityMetadata(fnNode: SyntaxNode): SwiftArityMetadata;
+export {};

package/dist/core/ingestion/languages/swift/arity-metadata.js

@@ -0,0 +1,41 @@
+/**
+ * Extract Swift arity metadata from a function-like tree-sitter node —
+ * `function_declaration`, `protocol_function_declaration`, or
+ * `init_declaration`.
+ *
+ * Reuses `swiftMethodConfig.extractParameters` so scope-extracted defs
+ * carry the same arity semantics as the legacy parse-worker path:
+ *   - Variadic params (`xs: Int...`) collapse `parameterCount` to
+ *     `undefined`, which `swiftArityCompatibility` treats as "max
+ *     unknown" — the candidate stays eligible at `argCount >= required`.
+ *   - Defaulted params (`= expr`) contribute to `optionalCount`;
+ *     `requiredParameterCount = total − optionalCount`.
+ *   - `parameterTypes` collects declared type names for narrowing; a
+ *     literal `'variadic'` marker is appended for variadic methods so
+ *     `swiftArityCompatibility` can detect them without re-reading AST.
+ */
+import { swiftMethodConfig } from '../../method-extractors/configs/swift.js';
+export function computeSwiftArityMetadata(fnNode) {
+    const params = swiftMethodConfig.extractParameters?.(fnNode) ?? [];
+    let hasVariadic = false;
+    let optionalCount = 0;
+    const types = [];
+    for (const p of params) {
+        if (p.isVariadic)
+            hasVariadic = true;
+        else if (p.isOptional)
+            optionalCount++;
+        if (p.type !== null)
+            types.push(p.type);
+    }
+    if (hasVariadic)
+        types.push('variadic');
+    const total = params.length;
+    const parameterCount = hasVariadic ? undefined : total;
+    const requiredParameterCount = hasVariadic ? undefined : total - optionalCount;
+    return {
+        parameterCount,
+        requiredParameterCount,
+        parameterTypes: types.length > 0 ? types : undefined,
+    };
+}

package/dist/core/ingestion/languages/swift/arity.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Swift arity check, accommodating variadic and default parameters.
+ *
+ * Per the migration decision (count-primary, labels soft): we narrow on
+ * arity only. Swift's argument labels are a soft signal — a label
+ * mismatch is NOT treated as incompatible here, mirroring how the other
+ * migrated languages narrow and aligning with RFC §4 soft-penalty
+ * semantics. Label-precise dispatch is left to the registry's
+ * type-binding layer.
+ *
+ * The `def` metadata we care about (synthesized by `arity-metadata.ts`):
+ *   - `parameterCount`         — total formal parameters; `undefined`
+ *                                when the method has a variadic param.
+ *   - `requiredParameterCount` — min required (excludes defaulted params
+ *                                and the variadic).
+ *   - `parameterTypes`         — declared type strings; contains the
+ *                                literal `'variadic'` when variadic.
+ *
+ * Verdicts:
+ *   - `'compatible'`   — `requiredParameterCount <= argCount <= parameterCount`,
+ *                        OR the def is variadic (then any `argCount >= required`).
+ *   - `'incompatible'` — argCount below required, OR above max with no variadic.
+ *   - `'unknown'`      — metadata absent / incomplete.
+ *
+ * `'incompatible'` is a soft signal in `Registry.lookup` (penalized but
+ * still considered when no compatible candidate exists), per RFC §4.
+ */
+import type { Callsite, SymbolDefinition } from '../../../../_shared/index.js';
+export declare function swiftArityCompatibility(def: SymbolDefinition, callsite: Callsite): 'compatible' | 'unknown' | 'incompatible';

package/dist/core/ingestion/languages/swift/arity.js

@@ -0,0 +1,42 @@
+/**
+ * Swift arity check, accommodating variadic and default parameters.
+ *
+ * Per the migration decision (count-primary, labels soft): we narrow on
+ * arity only. Swift's argument labels are a soft signal — a label
+ * mismatch is NOT treated as incompatible here, mirroring how the other
+ * migrated languages narrow and aligning with RFC §4 soft-penalty
+ * semantics. Label-precise dispatch is left to the registry's
+ * type-binding layer.
+ *
+ * The `def` metadata we care about (synthesized by `arity-metadata.ts`):
+ *   - `parameterCount`         — total formal parameters; `undefined`
+ *                                when the method has a variadic param.
+ *   - `requiredParameterCount` — min required (excludes defaulted params
+ *                                and the variadic).
+ *   - `parameterTypes`         — declared type strings; contains the
+ *                                literal `'variadic'` when variadic.
+ *
+ * Verdicts:
+ *   - `'compatible'`   — `requiredParameterCount <= argCount <= parameterCount`,
+ *                        OR the def is variadic (then any `argCount >= required`).
+ *   - `'incompatible'` — argCount below required, OR above max with no variadic.
+ *   - `'unknown'`      — metadata absent / incomplete.
+ *
+ * `'incompatible'` is a soft signal in `Registry.lookup` (penalized but
+ * still considered when no compatible candidate exists), per RFC §4.
+ */
+export function swiftArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    const argCount = callsite.arity;
+    if (!Number.isFinite(argCount) || argCount < 0)
+        return 'unknown';
+    const hasVarArgs = def.parameterTypes !== undefined && def.parameterTypes.some((t) => t === 'variadic');
+    if (min !== undefined && argCount < min)
+        return 'incompatible';
+    if (max !== undefined && argCount > max && !hasVarArgs)
+        return 'incompatible';
+    return 'compatible';
+}

package/dist/core/ingestion/languages/swift/base-type.d.ts

@@ -0,0 +1,20 @@
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+/**
+ * Trailing simple-name `type_identifier` of a Swift `user_type` base. A
+ * qualified `Outer.Inner` parses flat as
+ * `(user_type (type_identifier "Outer") (type_identifier "Inner"))`, and the
+ * actual base type is the TRAILING segment `Inner` (mirrors Java
+ * `scoped_type_identifier` → `lastNamedChild` and TS `nested_type_identifier`
+ * → tail). Generic arguments live in a sibling `type_arguments` node — never a
+ * `type_identifier` — so they are skipped: `Box<Int>` → `Box`,
+ * `Outer.Inner<T>` → `Inner`. Returns null when the `user_type` has no
+ * `type_identifier` child.
+ *
+ * Shared by `swiftBaseTypeIdentifier` (captures.ts — returns the node for an
+ * `@reference.inherits` site) and `firstInheritedType` (receiver-binding.ts —
+ * reads `.text` for `super` receiver binding). It lives in this leaf module
+ * rather than being exported from captures.ts because captures.ts already
+ * imports receiver-binding.ts, so a captures.ts export would create a
+ * bidirectional import cycle (#1956 tri-review U7).
+ */
+export declare function swiftQualifiedBaseTail(userType: SyntaxNode): SyntaxNode | null;