gitnexus 1.6.6-rc.99 → 1.6.6

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

@@ -38,6 +38,10 @@ const GO_SCOPE_QUERY = `
 (method_declaration
   name: (field_identifier) @declaration.name) @declaration.method
 
+;; Declarations — interface methods
+(method_elem
+  name: (field_identifier) @declaration.name) @declaration.method
+
 ;; Declarations — struct fields
 (struct_type
   (field_declaration_list
@@ -48,11 +52,15 @@ const GO_SCOPE_QUERY = `
 ;; Declarations — variables
 (var_declaration
   (var_spec
-    name: (identifier) @declaration.name)) @declaration.variable
+    (identifier) @declaration.name)) @declaration.variable
+(var_declaration
+  (var_spec_list
+    (var_spec
+      (identifier) @declaration.name))) @declaration.variable
 
 (const_declaration
   (const_spec
-    name: (identifier) @declaration.name)) @declaration.const
+    (identifier) @declaration.name)) @declaration.const
 
 (short_var_declaration
   left: (expression_list (identifier) @declaration.name)) @declaration.variable
@@ -66,21 +74,21 @@ const GO_SCOPE_QUERY = `
   parameters: (parameter_list
     (parameter_declaration
       name: (identifier) @type-binding.name
-      type: [(type_identifier) (qualified_type) (pointer_type) (slice_type) (map_type)] @type-binding.type))) @type-binding.parameter
+      type: [(type_identifier) (qualified_type) (pointer_type) (slice_type) (map_type) (channel_type) (array_type) (function_type) (interface_type) (generic_type)] @type-binding.type))) @type-binding.parameter
 
 (method_declaration
   name: (field_identifier) @_fn_name
   parameters: (parameter_list
     (parameter_declaration
       name: (identifier) @type-binding.name
-      type: [(type_identifier) (qualified_type) (pointer_type) (slice_type) (map_type)] @type-binding.type))) @type-binding.parameter
+      type: [(type_identifier) (qualified_type) (pointer_type) (slice_type) (map_type) (channel_type) (array_type) (function_type) (interface_type) (generic_type)] @type-binding.type))) @type-binding.parameter
 
 ;; Type bindings — constructor-inferred (:= T{})
 (short_var_declaration
   left: (expression_list (identifier) @type-binding.name)
   right: (expression_list
     (composite_literal
-      type: [(type_identifier) (qualified_type)] @type-binding.type))) @type-binding.constructor
+      type: [(type_identifier) (qualified_type) (generic_type)] @type-binding.type))) @type-binding.constructor
 
 ;; Type bindings — pointer constructor (:= &T{})
 (short_var_declaration
@@ -89,7 +97,7 @@ const GO_SCOPE_QUERY = `
     (unary_expression
       "&"
       operand: (composite_literal
-        type: [(type_identifier) (qualified_type)] @type-binding.type)))) @type-binding.constructor
+        type: [(type_identifier) (qualified_type) (generic_type)] @type-binding.type)))) @type-binding.constructor
 
 ;; Type bindings — type assertion (:= s.(T))
 (short_var_declaration
@@ -164,7 +172,7 @@ const GO_SCOPE_QUERY = `
 
 ;; References — constructor calls (T{})
 (composite_literal
-  type: [(type_identifier) (qualified_type)] @reference.name) @reference.call.constructor
+  type: [(type_identifier) (qualified_type) (generic_type)] @reference.name) @reference.call.constructor
 
 ;; References — field reads
 (selector_expression

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

@@ -1,6 +1,7 @@
 import { getGoParser } 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';
 export function populateGoRangeBindings(parsedFiles, _indexes, ctx) {
     const parser = getGoParser();
     for (const parsed of parsedFiles) {
@@ -8,10 +9,24 @@ export function populateGoRangeBindings(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 }, 'go range-binding: parse timed out, skipping file');
+                    continue;
+                }
+                throw err;
+            }
+        }
         const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
         if (moduleScope === undefined)
             continue;
@@ -39,9 +54,10 @@ export function populateGoRangeBindings(parsedFiles, _indexes, ctx) {
                 continue;
             // Resolve range expression type
             let elementType = null;
+            const functionScope = findEnclosingFunctionScope(rangeNode, scopeMap);
             if (rangeExpr.type === 'identifier') {
-                // Look up the identifier's type in scope typeBindings (V1: module scope only)
-                const binding = moduleScope.typeBindings.get(rangeExpr.text);
+                const binding = functionScope?.typeBindings.get(rangeExpr.text) ??
+                    moduleScope.typeBindings.get(rangeExpr.text);
                 if (binding !== null && binding !== undefined) {
                     elementType = extractElementType(binding);
                 }
@@ -62,7 +78,6 @@ export function populateGoRangeBindings(parsedFiles, _indexes, ctx) {
             }
             if (elementType !== null && valueVar !== null) {
                 // Inject type binding for the range variable onto the enclosing function scope
-                const functionScope = findEnclosingFunctionScope(rangeNode, scopeMap);
                 const targetScope = functionScope ?? moduleScope;
                 const mutable = targetScope.typeBindings;
                 mutable.set(valueVar, {
@@ -96,7 +111,7 @@ function findEnclosingFunctionScope(node, scopeMap) {
             // same line/column as the tree-sitter node.
             for (const scope of scopeMap.values()) {
                 if (scope.kind === 'Function' &&
-                    scope.range.startLine === current.startPosition.row &&
+                    scope.range.startLine === current.startPosition.row + 1 &&
                     scope.range.startCol === current.startPosition.column) {
                     return scope;
                 }

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

@@ -12,7 +12,7 @@ export function synthesizeGoReceiverBinding(fnNode) {
     const typeNode = param.childForFieldName('type');
     if (nameNode === null || typeNode === null)
         return null;
-    const typeName = typeNode.text.replace(/^\*/, '');
+    const typeName = typeNode.text;
     return {
         '@type-binding.self': syntheticCapture('@type-binding.self', fnNode, nameNode.text),
         '@type-binding.name': syntheticCapture('@type-binding.name', nameNode, nameNode.text),

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

@@ -26,8 +26,8 @@ export const goScopeResolver = {
     allowGlobalFreeCallFallback: true,
     populateNamespaceSiblings: populateGoPackageSiblings,
     mirrorNamespaceTypeBindings: mirrorGoNamespaceTypeBindings,
-    // Staged/V2: registered but not yet wired in run.ts — method-name-only
-    // matching produces false IMPLEMENTS edges; awaits signature-level comparison.
+    // Go has structural interfaces: implementations are inferred by signature,
+    // then fed into generic MRO/interface-dispatch.
     detectInterfaceImplementations: detectGoInterfaceImplementations,
     populateRangeBindings: populateGoRangeBindings,
 };

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

@@ -1,8 +1,9 @@
 export function goBindingScopeFor(decl, innermost, _tree) {
-    // Keep self typeBindings in the method's Function scope (prevent
-    // auto-hoist to Module) so populateGoOwners can match Method defs
-    // to their receiver types by inspecting each Function scope.
-    if (decl['@type-binding.self'] !== undefined) {
+    // Keep receiver and parameter typeBindings in the function scope
+    // (prevent auto-hoist to Module). Parameters are local variables:
+    // hoisting `repo Repository` from one function to module scope can
+    // pollute another function's local receiver resolution.
+    if (decl['@type-binding.self'] !== undefined || decl['@type-binding.parameter'] !== undefined) {
         return innermost.id;
     }
     return null; // default auto-hoist for other bindings
@@ -15,7 +16,11 @@ export function goReceiverBinding(functionScope) {
         return null;
     for (const binding of functionScope.typeBindings.values()) {
         if (binding.source === 'self')
-            return binding;
+            return normalizeGoSelfTypeRef(binding);
     }
     return null;
 }
+function normalizeGoSelfTypeRef(binding) {
+    const rawName = binding.rawName.replace(/^\*+/, '').trim();
+    return rawName === binding.rawName ? binding : { ...binding, rawName };
+}

package/dist/core/ingestion/languages/go/type-binding.d.ts

@@ -1,3 +1,4 @@
 import type { CaptureMatch } from '../../../../_shared/index.js';
 import { type SyntaxNode } from '../../utils/ast-helpers.js';
 export declare function synthesizeGoTypeBindings(rootNode: SyntaxNode): CaptureMatch[];
+export declare function extractSimpleTypeNameText(node: SyntaxNode): string;

package/dist/core/ingestion/languages/go/type-binding.js

@@ -1,6 +1,28 @@
 import { syntheticCapture } from '../../utils/ast-helpers.js';
+const COMPOSITE_LITERAL_TYPE_NODE_TYPES = new Set([
+    'type_identifier',
+    'qualified_type',
+    'generic_type',
+]);
 export function synthesizeGoTypeBindings(rootNode) {
     const out = [];
+    for (const node of rootNode.descendantsOfType('var_spec')) {
+        const name = node.childForFieldName('name');
+        const value = node.childForFieldName('value');
+        if (name?.type !== 'identifier' || value === null)
+            continue;
+        const rhsExpr = value.namedChildren[0];
+        if (rhsExpr === undefined)
+            continue;
+        const typeNode = extractCompositeLiteralTypeNode(rhsExpr);
+        if (typeNode === null)
+            continue;
+        out.push({
+            '@type-binding.constructor': syntheticCapture('@type-binding.constructor', node, node.text),
+            '@type-binding.name': syntheticCapture('@type-binding.name', name, name.text),
+            '@type-binding.type': syntheticCapture('@type-binding.type', typeNode, extractSimpleTypeNameText(typeNode)),
+        });
+    }
     for (const node of rootNode.descendantsOfType('short_var_declaration')) {
         const right = node.childForFieldName('right');
         if (right === null)
@@ -189,18 +211,34 @@ function synthesizeElementAccessBindings(rootNode, out) {
         }
     }
 }
-function extractSimpleTypeNameText(node) {
+export function extractSimpleTypeNameText(node) {
     if (node.type === 'qualified_type') {
         const parts = node.text.split('.');
         return parts[parts.length - 1] ?? node.text;
     }
+    if (node.type === 'generic_type') {
+        const base = node.childForFieldName('type');
+        return base === null ? node.text : extractSimpleTypeNameText(base);
+    }
     return node.text;
 }
 /** Extract the type/signature node from a RHS expression. */
+function extractCompositeLiteralTypeNode(expr) {
+    if (expr.type === 'composite_literal') {
+        return (expr.childForFieldName('type') ??
+            expr.namedChildren.find((c) => COMPOSITE_LITERAL_TYPE_NODE_TYPES.has(c.type)) ??
+            null);
+    }
+    if (expr.type === 'unary_expression') {
+        const operand = expr.childForFieldName('operand');
+        return operand === null ? null : extractCompositeLiteralTypeNode(operand);
+    }
+    return null;
+}
 function extractTypeNode(expr) {
     if (expr.type === 'composite_literal') {
         return (expr.childForFieldName('type') ??
-            expr.namedChildren.find((c) => ['type_identifier', 'qualified_type'].includes(c.type)) ??
+            expr.namedChildren.find((c) => COMPOSITE_LITERAL_TYPE_NODE_TYPES.has(c.type)) ??
             null);
     }
     if (expr.type === 'unary_expression') {

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

@@ -5,7 +5,6 @@
  * LanguageProvider, following the Strategy pattern used by the pipeline.
  *
  * Key Go traits:
- *   - importSemantics: 'wildcard-leaf' (Go imports entire packages)
  *   - callRouter: present (Go method calls may need routing)
  */
 export declare const goProvider: import("../language-provider.js").LanguageProvider;

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

@@ -5,7 +5,6 @@
  * LanguageProvider, following the Strategy pattern used by the pipeline.
  *
  * Key Go traits:
- *   - importSemantics: 'wildcard-leaf' (Go imports entire packages)
  *   - callRouter: present (Go method calls may need routing)
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
@@ -25,8 +24,6 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { goVariableConfig } from '../variable-extractors/configs/go.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { goCallConfig } from '../call-extractors/configs/go.js';
-import { createHeritageExtractor } from '../heritage-extractors/generic.js';
-import { goHeritageConfig } from '../heritage-extractors/configs/go.js';
 import { emitGoScopeCaptures, goArityCompatibility, goBindingScopeFor, goImportOwningScope, goReceiverBinding, interpretGoImport, interpretGoTypeBinding, } from './go/index.js';
 const GO_BUILT_INS = new Set([
     // built-in functions
@@ -123,13 +120,11 @@ export const goProvider = defineLanguage({
     typeConfig: goConfig,
     exportChecker: goExportChecker,
     importResolver: createImportResolver(goImportConfig),
-    importSemantics: 'wildcard-leaf',
     callExtractor: createCallExtractor(goCallConfig),
     fieldExtractor: createFieldExtractor(goFieldConfig),
     methodExtractor: createMethodExtractor(goMethodConfig),
     variableExtractor: createVariableExtractor(goVariableConfig),
     classExtractor: createClassExtractor(goClassConfig),
-    heritageExtractor: createHeritageExtractor(goHeritageConfig),
     builtInNames: GO_BUILT_INS,
     // ── RFC #909 Ring 3: scope-based resolution hooks ──────────
     emitScopeCaptures: emitGoScopeCaptures,

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

@@ -32,8 +32,3 @@ export declare function getProvider(language: SupportedLanguages): LanguageProvi
 /** Look up a language provider from a file path by extension.
  *  Returns null if the file extension is not recognized. */
 export declare function getProviderForFile(filePath: string): LanguageProvider | null;
-/** Pre-computed list of providers that have implicit import wiring (e.g., Swift).
- *  Built once at module load — avoids iterating all 13 providers per call. */
-export declare const providersWithImplicitWiring: (LanguageProvider & {
-    implicitImportWirer: NonNullable<LanguageProvider["implicitImportWirer"]>;
-})[];

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

@@ -61,6 +61,3 @@ export function getProviderForFile(filePath) {
     const basename = filePath.slice(filePath.lastIndexOf('/') + 1);
     return extensionMap.get(ext) ?? extensionMap.get(basename) ?? null;
 }
-/** Pre-computed list of providers that have implicit import wiring (e.g., Swift).
- *  Built once at module load — avoids iterating all 13 providers per call. */
-export const providersWithImplicitWiring = Object.values(providers).filter((p) => p.implicitImportWirer != null);

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

@@ -13,7 +13,7 @@
  *
  * Pure given the input source text. No I/O, no globals consulted.
  */
-import { findNodeAtRange, nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+import { nodeIfType, nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
 import { splitImportDeclaration } from './import-decomposer.js';
 import { computeJavaArityMetadata } from './arity-metadata.js';
 import { synthesizeJavaReceiverBinding } from './receiver-binding.js';
@@ -54,16 +54,26 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
     const out = [];
     for (const m of rawMatches) {
         const grouped = {};
+        // Parallel tag -> captured SyntaxNode map. The tree-sitter query already
+        // 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 × rootChildren) root-walk fixed for go #1848 / python #1918 /
+        // rust/csharp #1915, mirrored here for java (#1951). Every Java scope-query
+        // anchor below captures directly ON the node the old root-walk re-derived
+        // (verified against JAVA_SCOPE_QUERY in query.ts), so the type check is exact.
+        const nodeMap = {};
         for (const c of m.captures) {
             const tag = '@' + c.name;
             grouped[tag] = nodeToCapture(tag, c.node);
+            nodeMap[tag] = c.node;
         }
         if (Object.keys(grouped).length === 0)
             continue;
-        // Decompose each `import_declaration`.
+        // Decompose each `import_declaration`. `@import.statement` is captured
+        // directly on the `import_declaration` node.
         if (grouped['@import.statement'] !== undefined) {
-            const stmtCapture = grouped['@import.statement'];
-            const stmtNode = findNodeAtRange(tree.rootNode, stmtCapture.range, 'import_declaration');
+            const stmtNode = nodeIfType(nodeMap['@import.statement'], 'import_declaration');
             if (stmtNode !== null) {
                 const decomposed = splitImportDeclaration(stmtNode);
                 if (decomposed !== null) {
@@ -86,9 +96,9 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
             continue;
         }
         // Filter read.member when it's a child of method_invocation or assignment.
+        // `@reference.read.member` is captured directly on the `field_access` node.
         if (grouped['@reference.read.member'] !== undefined) {
-            const anchor = grouped['@reference.read.member'];
-            const memberNode = findNodeAtRange(tree.rootNode, anchor.range, 'field_access');
+            const memberNode = nodeIfType(nodeMap['@reference.read.member'], 'field_access');
             if (memberNode === null || !shouldEmitReadMember(memberNode)) {
                 continue;
             }
@@ -97,8 +107,8 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
         // instance method-like.
         if (grouped['@scope.function'] !== undefined) {
             out.push(grouped);
-            const anchor = grouped['@scope.function'];
-            const fnNode = findFunctionNode(tree.rootNode, anchor.range);
+            // `@scope.function` is captured directly on the method/constructor node.
+            const fnNode = findFunctionNode(nodeMap['@scope.function']);
             if (fnNode !== null) {
                 for (const synth of synthesizeJavaReceiverBinding(fnNode)) {
                     out.push(synth);
@@ -109,8 +119,9 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
         // Synthesize arity metadata on function-like declarations.
         const declTag = FUNCTION_DECL_TAGS.find((t) => grouped[t] !== undefined);
         if (declTag !== undefined) {
-            const anchor = grouped[declTag];
-            const fnNode = findFunctionNode(tree.rootNode, anchor.range);
+            // FUNCTION_DECL_TAGS (@declaration.method/.constructor) are captured
+            // directly on the method/constructor node.
+            const fnNode = findFunctionNode(nodeMap[declTag]);
             if (fnNode !== null) {
                 const arity = computeJavaArityMetadata(fnNode);
                 if (arity.parameterCount !== undefined) {
@@ -127,14 +138,18 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
         // Synthesize `@reference.arity` on every callsite.
         const callTag = ['@reference.call.free', '@reference.call.member', '@reference.call.constructor'].find((t) => grouped[t] !== undefined);
         if (callTag !== undefined && grouped['@reference.arity'] === undefined) {
-            const anchor = grouped[callTag];
-            const callNode = findNodeAtRange(tree.rootNode, anchor.range, 'method_invocation') ??
-                findNodeAtRange(tree.rootNode, anchor.range, 'object_creation_expression');
+            // @reference.call.free/.member are captured on the `method_invocation`;
+            // @reference.call.constructor on the `object_creation_expression`. The
+            // captured node IS the call node the old findNodeAtRange re-derived.
+            const callNode = nodeIfType(nodeMap[callTag], 'method_invocation', 'object_creation_expression');
             if (callNode !== null) {
                 const argList = callNode.childForFieldName('arguments');
+                // Exclude interleaved comments — tree-sitter-java emits `block_comment` /
+                // `line_comment` as named children of argument_list, which would inflate
+                // arity (and arity feeds call-processor symbol-ID generation). #1920
                 const args = argList === null
                     ? []
-                    : argList.namedChildren.filter((c) => c !== null && c.type !== 'comment');
+                    : argList.namedChildren.filter((c) => c !== null && c.type !== 'block_comment' && c.type !== 'line_comment');
                 grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(args.length));
                 const argTypes = args.map((arg) => inferArgType(arg));
                 grouped['@reference.parameter-types'] = syntheticCapture('@reference.parameter-types', callNode, JSON.stringify(argTypes));
@@ -146,7 +161,217 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
         }
         out.push(grouped);
     }
-    return resolveVarTypeBindings(out);
+    return [
+        ...resolveVarTypeBindings(out),
+        ...synthesizeJavaInheritanceReferences(tree.rootNode),
+        ...synthesizeJavaExplicitConstructorReferences(tree.rootNode),
+    ];
+}
+/**
+ * Synthesize `@reference.call.constructor` captures for explicit constructor
+ * invocations — `super(...)` and `this(...)` (F38 #1928). tree-sitter-java
+ * models these as `explicit_constructor_invocation` nodes, which the scope
+ * query does not match, so the chained-constructor CALLS edges (subclass ctor →
+ * superclass ctor; ctor → sibling overload) were silently dropped.
+ *
+ * The grammar gives no constructor *name* at the call site (the child is a bare
+ * `(super)` / `(this)` token), so the target name is resolved structurally:
+ *   - `this(...)`  → the enclosing type's own simple name (constructor symbols
+ *                    are keyed by the declaring class name).
+ *   - `super(...)` → the enclosing class's superclass simple-name tail (reusing
+ *                    `javaBaseLookupNameNode` so qualified/generic supers reduce
+ *                    to the bare class name, matching the EXTENDS synth). An
+ *                    implicit `Object` super (no `superclass` field) has no
+ *                    in-graph symbol, so it is skipped rather than emitting a
+ *                    dangling reference.
+ * Arity is attached so overloaded constructors disambiguate downstream, mirroring
+ * the call-site arity synthesized for `new X(...)`.
+ */
+function synthesizeJavaExplicitConstructorReferences(root) {
+    const out = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === 'explicit_constructor_invocation') {
+            emitJavaExplicitConstructorRef(out, node);
+        }
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child !== null)
+                stack.push(child);
+        }
+    }
+    return out;
+}
+const TYPE_DECL_NODE_TYPES = new Set([
+    'class_declaration',
+    'enum_declaration',
+    'record_declaration',
+]);
+function emitJavaExplicitConstructorRef(out, node) {
+    const ctor = node.childForFieldName('constructor');
+    if (ctor === null)
+        return;
+    const enclosingType = findEnclosingTypeDeclaration(node);
+    if (enclosingType === null)
+        return;
+    let targetNameNode = null;
+    if (ctor.type === 'this') {
+        targetNameNode = enclosingType.childForFieldName('name');
+    }
+    else if (ctor.type === 'super') {
+        // Only class_declaration carries a `superclass` field; enum/record cannot
+        // declare an explicit superclass, so `super(...)` there has no resolvable
+        // target symbol.
+        const superclass = enclosingType.childForFieldName('superclass');
+        if (superclass === null)
+            return;
+        for (const base of superclass.namedChildren) {
+            if (base === null)
+                continue;
+            const nameNode = javaBaseLookupNameNode(base);
+            if (nameNode !== null) {
+                targetNameNode = nameNode;
+                break;
+            }
+        }
+    }
+    if (targetNameNode === null)
+        return;
+    const argList = node.childForFieldName('arguments');
+    const args = argList === null
+        ? []
+        : argList.namedChildren.filter((c) => c !== null && c.type !== 'block_comment' && c.type !== 'line_comment');
+    out.push({
+        '@reference.call.constructor': nodeToCapture('@reference.call.constructor', node),
+        '@reference.name': nodeToCapture('@reference.name', targetNameNode),
+        '@reference.arity': syntheticCapture('@reference.arity', node, String(args.length)),
+    });
+}
+function findEnclosingTypeDeclaration(node) {
+    let cur = node.parent;
+    while (cur !== null) {
+        if (TYPE_DECL_NODE_TYPES.has(cur.type))
+            return cur;
+        cur = cur.parent;
+    }
+    return null;
+}
+/**
+ * Synthesize `@reference.inherits` captures from Java class heritage so the
+ * registry-primary scope-resolution path emits EXTENDS / IMPLEMENTS edges
+ * (mirrors C++ `emitCppInheritanceCaptures`). Without this, Java inheritance
+ * edges came only from the legacy heritage-capture leg (removed in #942), which
+ * is dropped for registry-primary languages in the worker pipeline (issue #1951).
+ *
+ * Scope covers `class_declaration` (`superclass` extends + `interfaces`
+ * implements clauses) AND `interface_declaration` (`extends_interfaces` →
+ * interface-to-interface EXTENDS), matching the legacy Java heritage query
+ * (tree-sitter-queries.ts), which has a dedicated `interface_declaration
+ * (extends_interfaces (type_list …))` arm. Without the interface arm the
+ * registry-primary synth silently dropped every `interface IA extends IB`
+ * edge while the legacy leg emitted it — the exact =0/=N parity break #1951
+ * targets. Enum/record heritage stays unemitted (no legacy arm). Generic
+ * bases (`extends Box<T>`, `implements IFoo<T>`) ARE emitted here: the legacy
+ * heritage query was widened to capture the inner `type_identifier` of a
+ * `generic_type` (tree-sitter-queries.ts), so both paths now agree on SIMPLE
+ * (unqualified) generic bases — the more-correct behavior, consistent with
+ * C#/Rust (#1951). Qualified bases (`a.b.Base`, `a.b.Box<T>`, `a.b.IFoo<T>`) are
+ * ALSO now at parity (#1956 tri-review U2): the synth resolves them by their
+ * `scoped_type_identifier` tail, and the legacy heritage query was widened
+ * with matching `scoped_type_identifier` arms (plain + generic-wrapped). The
+ * EXTENDS-vs-IMPLEMENTS split is decided downstream from the resolved target's
+ * symbol kind (`preEmitInheritanceEdges`): a superclass resolves to a class
+ * (EXTENDS), an implemented interface resolves to an interface (IMPLEMENTS).
+ * An `interface IA extends IB` base resolves to an Interface too, so it is
+ * emitted as IMPLEMENTS — matching the legacy `interface_declaration` arm,
+ * which tagged the bases as implements (`kind: 'implements'`) and likewise
+ * resolves them as interfaces. The synth therefore does not need to know the
+ * declaration's own kind; it only emits inherits sites and lets the resolved
+ * target decide the edge type.
+ * Base names are normalized to their bare simple identifier (`Box<T>` → `Box`,
+ * `java.io.Serializable` → `Serializable`) to match the V1 simple-name
+ * `findClassBindingInScope` contract.
+ */
+function synthesizeJavaInheritanceReferences(root) {
+    const out = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === 'class_declaration') {
+            const superclass = node.childForFieldName('superclass');
+            if (superclass !== null) {
+                for (const base of superclass.namedChildren)
+                    emitJavaInheritanceBase(out, base);
+            }
+            const interfaces = node.childForFieldName('interfaces');
+            if (interfaces !== null) {
+                for (const typeList of interfaces.namedChildren) {
+                    if (typeList === null || typeList.type !== 'type_list')
+                        continue;
+                    for (const base of typeList.namedChildren)
+                        emitJavaInheritanceBase(out, base);
+                }
+            }
+        }
+        else if (node.type === 'interface_declaration') {
+            // `interface IA extends IB, IC<T>` — the `extends_interfaces` clause is
+            // NOT exposed via a tree-sitter field (unlike a class's `superclass` /
+            // `interfaces`), so scan named children for it. It wraps a `type_list`
+            // whose bases reuse `javaBaseLookupNameNode` (handles type_identifier /
+            // generic_type / scoped_type_identifier). These resolve to Interface
+            // targets, so `preEmitInheritanceEdges` emits them as IMPLEMENTS, at
+            // parity with the legacy `interface_declaration` implements arm.
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const extendsInterfaces = node.namedChild(i);
+                if (extendsInterfaces === null || extendsInterfaces.type !== 'extends_interfaces')
+                    continue;
+                for (const typeList of extendsInterfaces.namedChildren) {
+                    if (typeList === null || typeList.type !== 'type_list')
+                        continue;
+                    for (const base of typeList.namedChildren)
+                        emitJavaInheritanceBase(out, base);
+                }
+            }
+        }
+        // Named children only: every type/heritage node we care about is named,
+        // so skipping unnamed punctuation tokens keeps the walk single-pass and
+        // lighter on large files.
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child !== null)
+                stack.push(child);
+        }
+    }
+    return out;
+}
+function emitJavaInheritanceBase(out, base) {
+    if (base === null)
+        return;
+    const nameNode = javaBaseLookupNameNode(base);
+    if (nameNode === null)
+        return;
+    out.push({
+        '@reference.inherits': nodeToCapture('@reference.inherits', base),
+        '@reference.name': nodeToCapture('@reference.name', nameNode),
+    });
+}
+/** Resolve a Java base-type node to its bare simple-name identifier node. */
+function javaBaseLookupNameNode(node) {
+    switch (node.type) {
+        case 'type_identifier':
+            return node;
+        case 'scoped_type_identifier':
+            // `java.io.Serializable` → trailing `type_identifier` (`Serializable`).
+            return node.lastNamedChild;
+        case 'generic_type': {
+            // `Box<String>` → recurse into the base type (`Box`).
+            const first = node.firstNamedChild;
+            return first === null ? null : javaBaseLookupNameNode(first);
+        }
+        default:
+            return null;
+    }
 }
 function resolveVarTypeBindings(matches) {
     const returnTypes = new Map();
@@ -286,12 +511,16 @@ function inferArgType(argNode) {
             return '';
     }
 }
-/** Find the first Java function-like node at the given range. */
-function findFunctionNode(rootNode, range) {
-    for (const nodeType of FUNCTION_NODE_TYPES) {
-        const n = findNodeAtRange(rootNode, range, nodeType);
-        if (n !== null)
-            return n;
-    }
-    return null;
+/**
+ * Resolve a Java function-like node from a query-captured node.
+ *
+ * The `@scope.function` / `@declaration.method` / `@declaration.constructor`
+ * anchors all capture directly on the `method_declaration` /
+ * `constructor_declaration` node (per JAVA_SCOPE_QUERY), so this is a type
+ * guard against `FUNCTION_NODE_TYPES` — the threaded-node equivalent of the
+ * old `findNodeAtRange(tree.rootNode, range, type)` root-walk, minus the
+ * O(matches × rootChildren) traversal.
+ */
+function findFunctionNode(node) {
+    return nodeIfType(node, ...FUNCTION_NODE_TYPES);
 }