gitnexus 1.6.6-rc.99 → 1.6.6

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

@@ -1,10 +1,10 @@
-import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+import { nodeToCapture, syntheticCapture, walkNamedTree, } from '../../utils/ast-helpers.js';
 import { getGoParser, getGoScopeQuery } from './query.js';
 import { recordGoCacheHit, recordGoCacheMiss } from './cache-stats.js';
 import { computeGoCallArity, computeGoDeclarationArity } from './arity-metadata.js';
 import { splitGoImportStatement } from './import-decomposer.js';
 import { synthesizeGoReceiverBinding } from './receiver-binding.js';
-import { synthesizeGoTypeBindings } from './type-binding.js';
+import { synthesizeGoTypeBindings, extractSimpleTypeNameText } from './type-binding.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
@@ -69,12 +69,14 @@ export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
         }
         if (isRawMultiAssignTypeBinding(nodeMap))
             continue;
+        normalizeGenericConstructorCapture(nodeMap, grouped);
         const declAnchorNode = nodeMap['@declaration.function'] ?? nodeMap['@declaration.method'];
         if (declAnchorNode !== undefined) {
             // @declaration.function / @declaration.method are captured directly on
             // the function_declaration / method_declaration node.
             const fnNode = declAnchorNode.type === 'function_declaration' ||
-                declAnchorNode.type === 'method_declaration'
+                declAnchorNode.type === 'method_declaration' ||
+                declAnchorNode.type === 'method_elem'
                 ? declAnchorNode
                 : null;
             if (fnNode !== null) {
@@ -88,6 +90,9 @@ export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
                 if (arity.parameterTypes !== undefined) {
                     grouped['@declaration.parameter-types'] = syntheticCapture('@declaration.parameter-types', fnNode, JSON.stringify(arity.parameterTypes));
                 }
+                if (arity.returnType !== undefined) {
+                    grouped['@declaration.return-type'] = syntheticCapture('@declaration.return-type', fnNode, arity.returnType);
+                }
             }
             out.push(grouped);
             continue;
@@ -130,8 +135,146 @@ export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
             },
         });
     }
+    out.push(...synthesizeGoInheritanceReferences(tree.rootNode));
+    return out;
+}
+/**
+ * Synthesize `@reference.inherits` captures for Go struct embedding so the
+ * registry-primary scope-resolution path emits inheritance edges (mirrors C#
+ * `synthesizeCsharpInheritanceReferences` / C++ `emitCppInheritanceCaptures`).
+ * Without this, Go embedding 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 EXACTLY matches the legacy Go heritage query + its `shouldSkipExtends`
+ * hook (`heritage-extractors/configs/go.ts`), whose supertype alternation is
+ * `[(type_identifier) (qualified_type) (generic_type)]` (see `goHeritageShapes`)
+ * matched against BOTH struct embedding and interface-in-interface embedding:
+ *
+ *   struct:    (struct_type (field_declaration_list
+ *                (field_declaration type: <base>)))   — anonymous (no `name`) field
+ *   interface: (interface_type (type_elem <base>))    — single-element type_elem
+ *
+ * i.e. an embedded (anonymous) field inside a struct, or an embedded type inside
+ * an interface. Named struct fields (`Breed string`) are skipped because their
+ * `field_declaration` carries a `name` field; multi-operand interface type-sets
+ * (`int | float64`) are skipped because their `type_elem` has >1 named child —
+ * both matching the legacy `shouldSkipExtends` filter.
+ *
+ * The base shapes covered (issue #1951 — these were previously DROPPED by the
+ * registry-primary synth, so production silently omitted their edges even though
+ * the legacy heritage leg, config-driven since #1940, captured them):
+ *   - bare `type_identifier`  (`Base`)                       → the node itself
+ *   - `qualified_type`        (`pkg.Base`)                    → `name:` tail
+ *   - `generic_type`          (`Box[T]`)                      → `type:` base
+ *   - pointer embeds          (`*Base`, `*pkg.Base`, …)       → the `*` is an
+ *     unnamed token, so `field_declaration.type` already points at the inner
+ *     shape above; no `pointer_type` unwrap is needed in this grammar version.
+ *
+ * The captured `@reference.name` is reduced to its bare simple identifier so the
+ * V1 simple-name `findClassBindingInScope` contract keeps holding — `pkg.Base`
+ * → `Base`, `Box[T]` → `Box`. {@link goEmbedBaseNameNode} returns the node whose
+ * `.text` EQUALS `normalizeSupertypeName(base)` for every shape (verified by
+ * real-parse), so this synth stays at parity with the legacy leg's reduction.
+ * For a bare `type_identifier` it returns the same node, keeping the simple-base
+ * path byte-identical.
+ *
+ * The EXTENDS-vs-IMPLEMENTS split is decided downstream from the resolved
+ * target's symbol kind (`preEmitInheritanceEdges`): an embedded struct resolves
+ * to EXTENDS, an embedded interface to IMPLEMENTS.
+ */
+function synthesizeGoInheritanceReferences(root) {
+    const out = [];
+    walkNamedTree(root, (node) => {
+        if (node.type !== 'type_declaration')
+            return;
+        for (const spec of node.namedChildren) {
+            if (spec.type !== 'type_spec')
+                continue;
+            const typeNode = spec.childForFieldName('type');
+            if (typeNode === null)
+                continue;
+            if (typeNode.type === 'struct_type') {
+                const fieldList = findNamedChildOfType(typeNode, 'field_declaration_list');
+                if (fieldList === null)
+                    continue;
+                for (const field of fieldList.namedChildren) {
+                    if (field.type !== 'field_declaration')
+                        continue;
+                    // Embedded (anonymous) field: no `name` field. Named fields are
+                    // skipped (legacy `shouldSkipExtends`).
+                    if (field.childForFieldName('name') !== null)
+                        continue;
+                    // `field.type` is the embedded base — bare/qualified/generic, with any
+                    // `*` pointer marker as an unnamed sibling token (already unwrapped).
+                    emitGoEmbedInheritance(field.childForFieldName('type'), out);
+                }
+            }
+            else if (typeNode.type === 'interface_type') {
+                for (const elem of typeNode.namedChildren) {
+                    // Only `type_elem` (an embedded type); `method_elem` is a method, not
+                    // an embed. Multi-operand type-sets (`int | float64`) parse as a
+                    // `type_elem` with >1 named child — skip them (legacy
+                    // `shouldSkipExtends`); a single-element `type_elem` is the embed.
+                    if (elem.type !== 'type_elem' || elem.namedChildCount !== 1)
+                        continue;
+                    emitGoEmbedInheritance(elem.namedChild(0), out);
+                }
+            }
+        }
+    });
     return out;
 }
+/**
+ * Emit one `@reference.inherits` / `@reference.name` match for a Go embed base
+ * node, reducing the name to its bare simple identifier. No-ops when `baseNode`
+ * is null or not one of the embed shapes.
+ */
+function emitGoEmbedInheritance(baseNode, out) {
+    if (baseNode === null)
+        return;
+    const nameNode = goEmbedBaseNameNode(baseNode);
+    if (nameNode === null)
+        return;
+    out.push({
+        '@reference.inherits': nodeToCapture('@reference.inherits', baseNode),
+        '@reference.name': nodeToCapture('@reference.name', nameNode),
+    });
+}
+/**
+ * Reduce a Go embed base node to its trailing bare `type_identifier`, matching
+ * the node shapes the legacy heritage query accepted (`goHeritageShapes`) and
+ * the reduction `normalizeSupertypeName` performs (verified by real-parse to
+ * yield an identical `.text` for each shape):
+ *   - `type_identifier`                          → the node itself (`Base`)
+ *   - `qualified_type` name: (type_identifier)   → the trailing `name:` id
+ *                                                  (`pkg.Base` → `Base`)
+ *   - `generic_type` type: <any of the above>    → recurse into `type:`
+ *                                                  (`Box[T]` → `Box`)
+ * Any other node type returns null (no edge), keeping this emitter at parity
+ * with the legacy leg.
+ */
+function goEmbedBaseNameNode(node) {
+    if (node.type === 'type_identifier')
+        return node;
+    if (node.type === 'qualified_type') {
+        const name = node.childForFieldName('name');
+        return name !== null ? goEmbedBaseNameNode(name) : null;
+    }
+    if (node.type === 'generic_type') {
+        const inner = node.childForFieldName('type');
+        return inner !== null ? goEmbedBaseNameNode(inner) : null;
+    }
+    return null;
+}
+/** First named child of `node` matching `type`, else null. */
+function findNamedChildOfType(node, type) {
+    for (const child of node.namedChildren) {
+        if (child.type === type)
+            return child;
+    }
+    return null;
+}
 /**
  * Resolve the node passed to `splitGoImportStatement` for an @import.statement
  * match. The capture is on the `import_spec`; the original preferred an
@@ -164,6 +307,22 @@ function nodeRangeEquals(a, b) {
         a.endPosition.row === b.endPosition.row &&
         a.endPosition.column === b.endPosition.column);
 }
+function normalizeGenericConstructorCapture(nodeMap, grouped) {
+    const typeNode = grouped['@type-binding.constructor'] !== undefined ? nodeMap['@type-binding.type'] : undefined;
+    if (typeNode !== undefined && typeNode.type === 'generic_type') {
+        const base = typeNode.childForFieldName('type');
+        if (base !== null) {
+            grouped['@type-binding.type'] = syntheticCapture('@type-binding.type', base, extractSimpleTypeNameText(base));
+        }
+    }
+    const referenceNode = grouped['@reference.call.constructor'] !== undefined ? nodeMap['@reference.name'] : undefined;
+    if (referenceNode !== undefined && referenceNode.type === 'generic_type') {
+        const base = referenceNode.childForFieldName('type');
+        if (base !== null) {
+            grouped['@reference.name'] = syntheticCapture('@reference.name', base, extractSimpleTypeNameText(base));
+        }
+    }
+}
 function isRawMultiAssignTypeBinding(nodeMap) {
     const anchor = nodeMap['@type-binding.constructor'] ??
         nodeMap['@type-binding.call-return'] ??