gitnexus 1.6.6-rc.120 → 1.6.6-rc.121

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

@@ -4,7 +4,7 @@ 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,6 +69,7 @@ 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
@@ -306,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'] ??

package/dist/core/ingestion/languages/go/interface-impls.js

@@ -203,8 +203,13 @@ function collectStructMethodEntries(structId, indexes, visiting, cache) {
 }
 function collectInterfaceMethodSet(iface, indexes, visiting, cache) {
     const cached = cache.get(iface.nodeId);
+    // NOTE: Returns a direct reference to the cached map. Callers (the detection
+    // loop in detectGoInterfaceImplementationsFromIndexes) only READ the result
+    // (keys/values passed to candidateStructIdsFor and methodSetSatisfies). If a
+    // future caller needs to mutate the returned map, it must clone first — the
+    // cache entry is shared and must remain immutable after this function returns.
     if (cached !== undefined)
-        return cloneMethodSet(cached);
+        return cached;
     if (visiting.has(iface.nodeId))
         return undefined;
     visiting.add(iface.nodeId);
@@ -224,6 +229,8 @@ function collectInterfaceMethodSet(iface, indexes, visiting, cache) {
         mergeMethodSet(merged, embeddedMethods);
     }
     visiting.delete(iface.nodeId);
+    // Store a clone in the cache so the returned `merged` reference is independent.
+    // This protects the cache from mutation if a caller modifies the return value.
     cache.set(iface.nodeId, cloneMethodSet(merged));
     return merged;
 }
@@ -238,15 +245,31 @@ function embeddedInterfacesFor(iface, indexes) {
     return embedded;
 }
 function candidateStructIdsFor(required, indexes) {
-    let best;
+    let result;
     for (const name of required.keys()) {
         const candidates = indexes.structIdsByMethodName.get(name);
         if (candidates === undefined)
             return [];
-        if (best === undefined || candidates.size < best.size)
-            best = candidates;
+        if (result === undefined) {
+            // First method name: start with its full candidate set (copy to avoid
+            // corrupting the shared index).
+            result = new Set(candidates);
+        }
+        else {
+            // Intersect: keep only struct IDs present in this method's candidate set.
+            // Iterate a snapshot to avoid mutating while iterating.
+            const toDelete = [];
+            for (const id of result) {
+                if (!candidates.has(id))
+                    toDelete.push(id);
+            }
+            for (const id of toDelete)
+                result.delete(id);
+        }
+        if (result.size === 0)
+            return []; // Early exit: no struct has all required methods
     }
-    return best === undefined ? [...indexes.structsById.keys()] : [...best];
+    return result === undefined ? indexes.structsById.keys() : result;
 }
 function resolveEmbeddedInterface(site, indexes) {
     const bound = resolveInheritanceBaseInScope(site.inScope, site.name, indexes.scopeIndexes);
@@ -322,6 +345,14 @@ function methodSetSatisfies(actual, required, signatureContextByDefId) {
         if (actualOverloads === undefined)
             return false;
         for (const requiredMethod of requiredOverloads) {
+            // Fast arity pre-filter: if the required method has a known parameter
+            // count, reject immediately when no actual overload matches it. This
+            // avoids the expensive signature normalization loop for obvious mismatches.
+            if (requiredMethod.parameterCount !== undefined) {
+                if (!actualOverloads.some((a) => a.parameterCount === requiredMethod.parameterCount)) {
+                    return false;
+                }
+            }
             if (!hasCompatibleMethod(actualOverloads, requiredMethod, signatureContextByDefId)) {
                 return false;
             }

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

@@ -84,7 +84,7 @@ const GO_SCOPE_QUERY = `
   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
@@ -93,7 +93,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
@@ -168,7 +168,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/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,4 +1,9 @@
 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')) {
@@ -206,18 +211,22 @@ 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) => ['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') {
@@ -229,7 +238,7 @@ function extractCompositeLiteralTypeNode(expr) {
 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.120",
+  "version": "1.6.6-rc.121",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",