gitnexus 1.6.6-rc.115 → 1.6.6-rc.116

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

@@ -98,6 +98,15 @@ const C_SCOPE_QUERY = `
   declarator: (init_declarator
     declarator: (identifier) @declaration.name)) @declaration.variable
 
+;; Declarations — variables (without initializer), including non-leading
+;; declarators in mixed declaration lists.
+(declaration
+  declarator: (identifier) @declaration.name) @declaration.variable
+
+(declaration
+  declarator: (pointer_declarator
+    declarator: (identifier) @declaration.name)) @declaration.variable
+
 ;; Declarations — macro definitions
 (preproc_def
   name: (identifier) @declaration.name) @declaration.macro

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

@@ -272,6 +272,15 @@ const CPP_SCOPE_QUERY = `
   declarator: (init_declarator
     declarator: (identifier) @declaration.name)) @declaration.variable
 
+;; ─── Declarations — variables (without initializer) ─────────────────
+;; Covers non-leading declarators in mixed declaration lists.
+(declaration
+  declarator: (identifier) @declaration.name) @declaration.variable
+
+(declaration
+  declarator: (pointer_declarator
+    declarator: (identifier) @declaration.name)) @declaration.variable
+
 ;; ─── Declarations — macro definitions ───────────────────────────────
 (preproc_def
   name: (identifier) @declaration.name) @declaration.macro

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

@@ -3,6 +3,7 @@ export interface GoArityMetadata {
     readonly parameterCount?: number;
     readonly requiredParameterCount?: number;
     readonly parameterTypes?: readonly string[];
+    readonly returnType?: string;
 }
 export declare function computeGoDeclarationArity(node: SyntaxNode): GoArityMetadata;
 export declare function computeGoCallArity(callNode: SyntaxNode): number;

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

@@ -1,7 +1,14 @@
 export function computeGoDeclarationArity(node) {
     const params = node.childForFieldName('parameters');
+    const returnType = extractGoReturnType(node);
     if (params === null)
-        return {};
+        return returnType === undefined ? {} : { returnType };
+    return {
+        ...computeGoParameterMetadata(params),
+        ...(returnType === undefined ? {} : { returnType }),
+    };
+}
+function computeGoParameterMetadata(params) {
     let count = 0;
     let required = 0;
     const types = [];
@@ -35,3 +42,26 @@ export function computeGoCallArity(callNode) {
         return 0;
     return args.namedChildCount;
 }
+function extractGoReturnType(node) {
+    const result = node.childForFieldName('result');
+    if (result === null)
+        return undefined;
+    if (result.type !== 'parameter_list')
+        return result.text;
+    const returnTypes = [];
+    for (const child of result.namedChildren) {
+        if (child.type !== 'parameter_declaration')
+            continue;
+        const typeNode = child.childForFieldName('type');
+        if (typeNode === null)
+            continue;
+        const names = child.namedChildren.filter((c) => c.type === 'identifier');
+        const n = Math.max(1, names.length);
+        for (let i = 0; i < n; i++) {
+            returnTypes.push(typeNode.text);
+        }
+    }
+    if (returnTypes.length === 0)
+        return undefined;
+    return returnTypes.length === 1 ? returnTypes[0] : `(${returnTypes.join(', ')})`;
+}

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

@@ -74,7 +74,8 @@ export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
             // @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 +89,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;

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

@@ -1,72 +1,467 @@
+import { simpleQualifiedName } from '../../scope-resolution/graph-bridge/ids.js';
+import { resolveInheritanceBaseInScope } from '../../scope-resolution/scope/walkers.js';
 export function detectGoInterfaceImplementations(parsedFiles, _indexes, _model) {
-    // 1. Collect interface defs → method names (from scope.ownedDefs)
-    const interfaceMethods = new Map();
-    const interfaceDefsById = new Map();
-    // 2. Collect struct defs → method names
-    const structMethods = new Map();
+    return detectGoInterfaceImplementationsFromIndexes(buildDetectionIndexes(parsedFiles, _indexes));
+}
+function buildDetectionIndexes(parsedFiles, indexes) {
+    const interfaces = [];
+    const structsById = new Map();
+    const methodsByOwner = new Map();
+    const effectiveMethodsByStructId = new Map();
+    const interfaceById = new Map();
+    const interfaceOwnMethodsById = new Map();
+    const embeddedSitesByInterfaceId = new Map();
+    const parentStructIdsByStructId = new Map();
+    const structIdsByMethodName = new Map();
+    const signatureContextByDefId = new Map();
+    const interfaceIdByScopeId = new Map();
+    const structIdByScopeId = new Map();
+    for (const parsed of parsedFiles) {
+        const signatureContext = signatureContextForFile(parsed, indexes);
+        for (const def of parsed.localDefs) {
+            signatureContextByDefId.set(def.nodeId, signatureContext);
+            if (def.type === 'Interface') {
+                interfaces.push(def);
+                interfaceById.set(def.nodeId, def);
+                continue;
+            }
+            if (def.type === 'Struct') {
+                structsById.set(def.nodeId, def);
+                continue;
+            }
+            if (def.type !== 'Method' && def.type !== 'Function')
+                continue;
+            if (def.ownerId === undefined)
+                continue;
+            if (isPointerReceiverMethod(def))
+                continue;
+            const methodName = simpleQualifiedName(def);
+            if (methodName === undefined || methodName.length === 0)
+                continue;
+            addMethod(methodsByOwner, def.ownerId, methodName, def);
+        }
+    }
+    for (const parsed of parsedFiles) {
+        for (const scope of parsed.scopes) {
+            const iface = scope.ownedDefs.find((def) => def.type === 'Interface');
+            if (iface !== undefined)
+                interfaceIdByScopeId.set(scope.id, iface.nodeId);
+            const struct = scope.ownedDefs.find((def) => def.type === 'Struct');
+            if (struct !== undefined)
+                structIdByScopeId.set(scope.id, struct.nodeId);
+        }
+    }
     for (const parsed of parsedFiles) {
-        // Collect interface defs and their owned methods
+        const childScopesByParent = new Map();
         for (const scope of parsed.scopes) {
-            if (scope.kind !== 'Class')
+            if (scope.parent === null)
                 continue;
-            // Find the type def for this scope
-            const typeDef = scope.ownedDefs.find((d) => d.type === 'Interface' || d.type === 'Struct');
-            if (typeDef === undefined)
+            const children = childScopesByParent.get(scope.parent) ?? [];
+            children.push(scope);
+            childScopesByParent.set(scope.parent, children);
+        }
+        for (const scope of parsed.scopes) {
+            const ifaceId = interfaceIdByScopeId.get(scope.id);
+            if (ifaceId === undefined)
                 continue;
-            if (typeDef.type === 'Interface') {
-                interfaceDefsById.set(typeDef.nodeId, typeDef);
-                const methodNames = new Set();
-                // Methods are in child scopes (Function kind) or ownedDefs
-                for (const childScope of parsed.scopes) {
-                    if (childScope.parent === scope.id && childScope.kind === 'Function') {
-                        for (const def of childScope.ownedDefs) {
-                            if (def.type === 'Method' || def.type === 'Function') {
-                                methodNames.add(def.qualifiedName?.split('.').pop() ?? '');
-                            }
-                        }
-                    }
-                }
-                // Also check if methods have ownerId pointing to this interface
-                for (const def of parsed.localDefs) {
-                    if (def.ownerId === typeDef.nodeId &&
-                        (def.type === 'Method' || def.type === 'Function')) {
-                        methodNames.add(def.qualifiedName?.split('.').pop() ?? '');
-                    }
+            const methods = new Map();
+            for (const childScope of childScopesByParent.get(scope.id) ?? []) {
+                for (const def of childScope.ownedDefs) {
+                    if (def.type !== 'Method' && def.type !== 'Function')
+                        continue;
+                    const methodName = simpleQualifiedName(def);
+                    if (methodName === undefined || methodName.length === 0)
+                        continue;
+                    addMethodOverload(methods, methodName, def);
                 }
-                interfaceMethods.set(typeDef.nodeId, methodNames);
             }
-            if (typeDef.type === 'Struct') {
-                const methodNames = new Set();
-                for (const def of parsed.localDefs) {
-                    if (def.ownerId === typeDef.nodeId &&
-                        (def.type === 'Method' || def.type === 'Function')) {
-                        methodNames.add(def.qualifiedName?.split('.').pop() ?? '');
-                    }
-                }
-                structMethods.set(typeDef.nodeId, methodNames);
+            interfaceOwnMethodsById.set(ifaceId, methods);
+        }
+        for (const site of parsed.referenceSites) {
+            if (site.kind !== 'inherits')
+                continue;
+            const ifaceId = interfaceIdByScopeId.get(site.inScope);
+            if (ifaceId !== undefined) {
+                const sites = embeddedSitesByInterfaceId.get(ifaceId) ?? [];
+                sites.push(site);
+                embeddedSitesByInterfaceId.set(ifaceId, sites);
+                continue;
             }
+            const structId = structIdByScopeId.get(site.inScope);
+            if (structId === undefined)
+                continue;
+            const parent = resolveInheritanceBaseInScope(site.inScope, site.name, indexes);
+            if (parent === undefined || parent.type !== 'Struct')
+                continue;
+            addParentStruct(parentStructIdsByStructId, structId, parent.nodeId);
         }
     }
-    // 3. For each interface, find structs whose method set is a superset
-    const impls = new Map();
-    for (const [ifaceId, ifaceMethods] of interfaceMethods) {
-        if (ifaceMethods.size === 0)
+    const structMethodSetCache = new Map();
+    for (const structId of structsById.keys()) {
+        const effective = collectStructMethodSet(structId, {
+            parentStructIdsByStructId,
+            methodsByOwner,
+        }, new Set(), structMethodSetCache);
+        if (effective === undefined)
+            continue;
+        effectiveMethodsByStructId.set(structId, effective);
+        for (const methodName of effective.keys()) {
+            addStructMethodCandidate(structIdsByMethodName, methodName, structId);
+        }
+    }
+    return {
+        interfaces,
+        structsById,
+        methodsByOwner,
+        effectiveMethodsByStructId,
+        interfaceById,
+        interfaceOwnMethodsById,
+        embeddedSitesByInterfaceId,
+        parentStructIdsByStructId,
+        structIdsByMethodName,
+        signatureContextByDefId,
+        scopeIndexes: indexes,
+    };
+}
+function detectGoInterfaceImplementationsFromIndexes(indexes) {
+    const implementations = new Map();
+    const methodSetCache = new Map();
+    for (const iface of indexes.interfaces) {
+        const required = collectInterfaceMethodSet(iface, indexes, new Set(), methodSetCache);
+        if (required === undefined || required.size === 0)
+            continue;
+        if (!methodSetHasVerifiableSignatures(required))
             continue;
         const implementors = [];
-        for (const [structId, methods] of structMethods) {
-            if (isSuperset(methods, ifaceMethods)) {
+        for (const structId of candidateStructIdsFor(required, indexes)) {
+            const actual = indexes.effectiveMethodsByStructId.get(structId);
+            if (actual === undefined)
+                continue;
+            if (methodSetSatisfies(actual, required, indexes.signatureContextByDefId)) {
                 implementors.push(structId);
             }
         }
         if (implementors.length > 0)
-            impls.set(ifaceId, implementors);
+            implementations.set(iface.nodeId, implementors);
+    }
+    return implementations;
+}
+function addMethod(methodsByOwner, ownerId, methodName, def) {
+    let methods = methodsByOwner.get(ownerId);
+    if (methods === undefined) {
+        methods = new Map();
+        methodsByOwner.set(ownerId, methods);
+    }
+    addMethodOverload(methods, methodName, def);
+}
+function addMethodOverload(methods, methodName, def) {
+    const overloads = methods.get(methodName) ?? [];
+    overloads.push(def);
+    methods.set(methodName, overloads);
+}
+function addStructMethodCandidate(structIdsByMethodName, methodName, structId) {
+    const structIds = structIdsByMethodName.get(methodName) ?? new Set();
+    structIds.add(structId);
+    structIdsByMethodName.set(methodName, structIds);
+}
+function addParentStruct(parentStructIdsByStructId, structId, parentStructId) {
+    const parents = parentStructIdsByStructId.get(structId) ?? [];
+    parents.push(parentStructId);
+    parentStructIdsByStructId.set(structId, parents);
+}
+function collectStructMethodSet(structId, indexes, visiting, cache) {
+    const entries = collectStructMethodEntries(structId, indexes, visiting, cache);
+    return entries === undefined ? undefined : methodEntriesToMethodSet(entries);
+}
+function collectStructMethodEntries(structId, indexes, visiting, cache) {
+    const cached = cache.get(structId);
+    if (cached !== undefined)
+        return cloneMethodEntries(cached);
+    if (visiting.has(structId))
+        return undefined;
+    visiting.add(structId);
+    const merged = directMethodEntries(indexes.methodsByOwner.get(structId));
+    for (const parentStructId of indexes.parentStructIdsByStructId.get(structId) ?? []) {
+        const parentEntries = collectStructMethodEntries(parentStructId, indexes, visiting, cache);
+        if (parentEntries === undefined) {
+            visiting.delete(structId);
+            return undefined;
+        }
+        for (const [methodName, entry] of parentEntries) {
+            if (entry.ambiguous)
+                continue;
+            mergePromotedMethodEntry(merged, methodName, {
+                overloads: entry.overloads,
+                depth: entry.depth + 1,
+                ambiguous: false,
+            });
+        }
+    }
+    visiting.delete(structId);
+    cache.set(structId, cloneMethodEntries(merged));
+    return merged;
+}
+function collectInterfaceMethodSet(iface, indexes, visiting, cache) {
+    const cached = cache.get(iface.nodeId);
+    if (cached !== undefined)
+        return cloneMethodSet(cached);
+    if (visiting.has(iface.nodeId))
+        return undefined;
+    visiting.add(iface.nodeId);
+    const ownMethods = indexes.methodsByOwner.get(iface.nodeId) ?? indexes.interfaceOwnMethodsById.get(iface.nodeId);
+    const merged = cloneMethodSet(ownMethods);
+    const embeddedInterfaces = embeddedInterfacesFor(iface, indexes);
+    if (embeddedInterfaces === undefined) {
+        visiting.delete(iface.nodeId);
+        return undefined;
+    }
+    for (const embeddedIface of embeddedInterfaces) {
+        const embeddedMethods = collectInterfaceMethodSet(embeddedIface, indexes, visiting, cache);
+        if (embeddedMethods === undefined) {
+            visiting.delete(iface.nodeId);
+            return undefined;
+        }
+        mergeMethodSet(merged, embeddedMethods);
+    }
+    visiting.delete(iface.nodeId);
+    cache.set(iface.nodeId, cloneMethodSet(merged));
+    return merged;
+}
+function embeddedInterfacesFor(iface, indexes) {
+    const embedded = [];
+    for (const site of indexes.embeddedSitesByInterfaceId.get(iface.nodeId) ?? []) {
+        const resolved = resolveEmbeddedInterface(site, indexes);
+        if (resolved === undefined)
+            return undefined;
+        embedded.push(resolved);
+    }
+    return embedded;
+}
+function candidateStructIdsFor(required, indexes) {
+    let best;
+    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;
+    }
+    return best === undefined ? [...indexes.structsById.keys()] : [...best];
+}
+function resolveEmbeddedInterface(site, indexes) {
+    const bound = resolveInheritanceBaseInScope(site.inScope, site.name, indexes.scopeIndexes);
+    if (bound !== undefined)
+        return bound.type === 'Interface' ? bound : undefined;
+    const simpleName = simpleTypeName(site.name);
+    const matches = [];
+    for (const iface of indexes.interfaceById.values()) {
+        if (iface.qualifiedName === site.name || iface.qualifiedName === simpleName) {
+            matches.push(iface);
+        }
+    }
+    return matches.length === 1 ? matches[0] : undefined;
+}
+function simpleTypeName(name) {
+    const dot = name.lastIndexOf('.');
+    return dot === -1 ? name : name.slice(dot + 1);
+}
+function cloneMethodSet(methods) {
+    const clone = new Map();
+    if (methods === undefined)
+        return clone;
+    for (const [name, overloads] of methods) {
+        clone.set(name, [...overloads]);
+    }
+    return clone;
+}
+function directMethodEntries(methods) {
+    const entries = new Map();
+    if (methods === undefined)
+        return entries;
+    for (const [name, overloads] of methods) {
+        entries.set(name, { overloads: [...overloads], depth: 0, ambiguous: false });
+    }
+    return entries;
+}
+function cloneMethodEntries(entries) {
+    const clone = new Map();
+    for (const [name, entry] of entries) {
+        clone.set(name, { ...entry, overloads: [...entry.overloads] });
+    }
+    return clone;
+}
+function methodEntriesToMethodSet(entries) {
+    const methods = new Map();
+    for (const [name, entry] of entries) {
+        if (entry.ambiguous)
+            continue;
+        methods.set(name, [...entry.overloads]);
+    }
+    return methods;
+}
+function mergePromotedMethodEntry(target, methodName, candidate) {
+    const existing = target.get(methodName);
+    if (existing === undefined || candidate.depth < existing.depth) {
+        target.set(methodName, candidate);
+        return;
+    }
+    if (candidate.depth > existing.depth)
+        return;
+    target.set(methodName, { overloads: [], depth: candidate.depth, ambiguous: true });
+}
+function mergeMethodSet(target, source) {
+    for (const [name, overloads] of source) {
+        const existing = target.get(name) ?? [];
+        existing.push(...overloads);
+        target.set(name, existing);
     }
-    return impls;
 }
-function isSuperset(superset, subset) {
-    for (const item of subset) {
-        if (!superset.has(item))
+function methodSetSatisfies(actual, required, signatureContextByDefId) {
+    for (const [name, requiredOverloads] of required) {
+        const actualOverloads = actual.get(name);
+        if (actualOverloads === undefined)
             return false;
+        for (const requiredMethod of requiredOverloads) {
+            if (!hasCompatibleMethod(actualOverloads, requiredMethod, signatureContextByDefId)) {
+                return false;
+            }
+        }
     }
     return true;
 }
+function hasCompatibleMethod(actualOverloads, requiredMethod, signatureContextByDefId) {
+    if (!hasVerifiableSignature(requiredMethod))
+        return false;
+    return actualOverloads.some((actualMethod) => signaturesCompatible(actualMethod, requiredMethod, signatureContextByDefId));
+}
+function methodSetHasVerifiableSignatures(methods) {
+    for (const overloads of methods.values()) {
+        if (!overloads.some(hasVerifiableSignature))
+            return false;
+    }
+    return true;
+}
+function isPointerReceiverMethod(def) {
+    return def.goReceiverKind === 'pointer';
+}
+function hasVerifiableSignature(def) {
+    return (def.parameterCount !== undefined ||
+        def.requiredParameterCount !== undefined ||
+        (def.parameterTypes !== undefined && def.parameterTypes.length > 0) ||
+        def.returnType !== undefined);
+}
+function signaturesCompatible(actual, required, signatureContextByDefId) {
+    const actualContext = signatureContextByDefId.get(actual.nodeId);
+    const requiredContext = signatureContextByDefId.get(required.nodeId);
+    return (countsCompatible(actual.parameterCount, required.parameterCount) &&
+        countsCompatible(actual.requiredParameterCount, required.requiredParameterCount) &&
+        parameterTypesCompatible(actual.parameterTypes, required.parameterTypes, actualContext, requiredContext) &&
+        returnTypesCompatible(actual.returnType, required.returnType, actualContext, requiredContext));
+}
+function countsCompatible(actual, required) {
+    return actual === undefined || required === undefined || actual === required;
+}
+function parameterTypesCompatible(actual, required, actualContext, requiredContext) {
+    if (actual === undefined || required === undefined)
+        return true;
+    if (actual.length !== required.length)
+        return false;
+    return actual.every((type, index) => {
+        const actualType = normalizeSignatureType(type, actualContext);
+        const requiredType = normalizeSignatureType(required[index], requiredContext);
+        return actualType !== undefined && requiredType !== undefined && actualType === requiredType;
+    });
+}
+function returnTypesCompatible(actual, required, actualContext, requiredContext) {
+    if (required === undefined)
+        return actual === undefined;
+    if (actual === undefined)
+        return false;
+    const actualType = normalizeSignatureType(actual, actualContext);
+    const requiredType = normalizeSignatureType(required, requiredContext);
+    return actualType !== undefined && requiredType !== undefined && actualType === requiredType;
+}
+function normalizeSignatureType(typeName, context) {
+    // Go type identity includes pointer/slice/map/variadic shape and package
+    // qualifiers. Only erase whitespace and qualify bare local type names; stripping
+    // `*`, `[]`, `...`, or `pkg.` would make non-identical signatures compare equal.
+    const compact = typeName.replace(/\s+/g, '');
+    if (context === undefined)
+        return compact;
+    return qualifyGoSignatureTypes(compact, context);
+}
+function qualifyGoSignatureTypes(typeName, context) {
+    let unresolvedQualifier = false;
+    const qualified = typeName.replace(/[A-Za-z_][A-Za-z0-9_]*/g, (token, offset, source) => {
+        if (GO_BUILTIN_TYPES.has(token))
+            return token;
+        if (hasPackageQualifierDot(source, offset))
+            return token;
+        if (source[offset + token.length] === '.') {
+            const qualifier = context.importQualifiers.get(token);
+            if (qualifier !== undefined)
+                return qualifier;
+            unresolvedQualifier = true;
+            return token;
+        }
+        if (context.packageQualifier === undefined)
+            return token;
+        return `${context.packageQualifier}.${token}`;
+    });
+    return unresolvedQualifier ? undefined : qualified;
+}
+function hasPackageQualifierDot(source, offset) {
+    return source[offset - 1] === '.' && source[offset - 2] !== '.';
+}
+function signatureContextForFile(parsed, indexes) {
+    const importQualifiers = new Map();
+    const importEdges = indexes.imports?.get(parsed.moduleScope) ?? [];
+    for (const edge of importEdges) {
+        if (edge.kind !== 'namespace' || edge.targetFile === null)
+            continue;
+        const qualifier = packageQualifierForFile(edge.targetFile);
+        if (qualifier !== undefined)
+            importQualifiers.set(edge.localName, qualifier);
+    }
+    return {
+        packageQualifier: packageQualifierForFile(parsed.filePath),
+        importQualifiers,
+    };
+}
+function packageQualifierForFile(filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    const slash = normalized.lastIndexOf('/');
+    if (slash === -1)
+        return undefined;
+    const packageDir = normalized.slice(0, slash);
+    return packageDir.length === 0 ? undefined : packageDir;
+}
+const GO_BUILTIN_TYPES = new Set([
+    'any',
+    'bool',
+    'byte',
+    'comparable',
+    'complex64',
+    'complex128',
+    'error',
+    'float32',
+    'float64',
+    'func',
+    'int',
+    'int8',
+    'int16',
+    'int32',
+    'int64',
+    'interface',
+    'map',
+    'rune',
+    'string',
+    'struct',
+    'uint',
+    'uint8',
+    'uint16',
+    'uint32',
+    'uint64',
+    'uintptr',
+    'chan',
+]);

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

@@ -28,7 +28,10 @@ export function interpretGoTypeBinding(captures) {
     let normalizedType;
     if (captures['@type-binding.self'] !== undefined) {
         source = 'self';
-        normalizedType = normalizeGoTypeName(type);
+        // Preserve pointer shape on receiver self-bindings (`*T` vs `T`).
+        // Method-owner enrichment consumes that raw shape to model Go value and
+        // pointer receiver method sets conservatively.
+        normalizedType = type.trim();
     }
     else if (captures['@type-binding.constructor'] !== undefined) {
         source = 'constructor-inferred';

package/dist/core/ingestion/languages/go/method-owners.js

@@ -36,12 +36,15 @@ export function populateGoWorkspaceOwners(parsedFiles, ctx) {
 function populateGoOwnersInPackage(parsedFiles) {
     // Build struct name → def map from ALL scopes' ownedDefs (struct defs
     // live in Class scopes now, not Module scope).
-    const structByQualifiedName = new Map(); // qname → nodeId
+    const structByQualifiedName = new Map();
     for (const parsed of parsedFiles) {
         for (const scope of parsed.scopes) {
             for (const def of scope.ownedDefs) {
                 if (isClassLike(def.type) && def.qualifiedName) {
-                    structByQualifiedName.set(def.qualifiedName, def.nodeId);
+                    structByQualifiedName.set(def.qualifiedName, {
+                        nodeId: def.nodeId,
+                        qualifiedName: def.qualifiedName,
+                    });
                 }
             }
         }
@@ -59,26 +62,35 @@ function populateGoOwnersInPackage(parsedFiles) {
                     continue;
                 // Find the self typeBinding in this Function scope.
                 let receiverType;
+                let receiverKind = 'value';
                 for (const [, tb] of scope.typeBindings) {
                     if (tb.source === 'self') {
                         receiverType = tb.rawName;
+                        receiverKind = tb.rawName.trim().startsWith('*') ? 'pointer' : 'value';
                         break;
                     }
                 }
                 if (receiverType === undefined)
                     continue;
-                let ownerId = structByQualifiedName.get(receiverType);
-                if (ownerId === undefined) {
-                    for (const [qname, nodeId] of structByQualifiedName) {
+                receiverType = receiverType.replace(/^\*+/, '').trim();
+                let owner = structByQualifiedName.get(receiverType);
+                if (owner === undefined) {
+                    for (const [qname, candidate] of structByQualifiedName) {
                         if (qname.endsWith('.' + receiverType)) {
-                            ownerId = nodeId;
+                            owner = candidate;
                             break;
                         }
                     }
                 }
-                if (ownerId !== undefined) {
+                if (owner !== undefined) {
                     for (const def of methodDefs) {
-                        def.ownerId = ownerId;
+                        def.ownerId = owner.nodeId;
+                        def.goReceiverKind = receiverKind;
+                        const simpleName = def.qualifiedName?.split('.').pop() ?? def.qualifiedName;
+                        if (simpleName !== undefined && !def.qualifiedName?.includes('.')) {
+                            def.qualifiedName =
+                                `${owner.qualifiedName}.${simpleName}`;
+                        }
                     }
                 }
             }

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

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

@@ -54,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);
                 }
@@ -77,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, {
@@ -111,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.js

@@ -1,6 +1,23 @@
 import { syntheticCapture } from '../../utils/ast-helpers.js';
 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)
@@ -197,6 +214,18 @@ function extractSimpleTypeNameText(node) {
     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)) ??
+            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') ??

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -106,7 +106,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
     const graphIdToClassDef = new Map();
     for (const parsed of parsedFiles) {
         for (const def of parsed.localDefs) {
-            if (def.type !== 'Class' && def.type !== 'Interface')
+            if (def.type !== 'Class' && def.type !== 'Struct' && def.type !== 'Interface')
                 continue;
             const graphId = resolveDefGraphId(parsed.filePath, def, nodeLookup);
             if (graphId !== undefined)

package/dist/core/ingestion/scope-resolution/pipeline/run.js

@@ -22,6 +22,7 @@
  *
  * Plan: `docs/plans/2026-04-20-001-refactor-emit-pipeline-generalization-plan.md`.
  */
+import { generateId } from '../../../../lib/utils.js';
 import { lookupOwnedMembersByOwner } from '../../model/owned-members-lookup.js';
 import { reconcileOwnership, validateOwnershipParity } from './reconcile-ownership.js';
 import { validateBindingsImmutability } from './validate-bindings-immutability.js';
@@ -36,7 +37,7 @@ import { emitReceiverBoundCalls } from '../passes/receiver-bound-calls.js';
 import { emitFreeCallFallback } from '../passes/free-call-fallback.js';
 import { emitReferencesViaLookup } from '../graph-bridge/references-to-edges.js';
 import { emitImportEdges } from '../graph-bridge/imports-to-edges.js';
-import { findClassBindingInScope, findEnclosingClassDef, resolveAmbiguousInheritanceBaseViaImports, } from '../scope/walkers.js';
+import { findEnclosingClassDef, resolveInheritanceBaseInScope } from '../scope/walkers.js';
 import { buildWorkspaceResolutionIndex } from '../workspace-index.js';
 import { logger } from '../../../logger.js';
 /**
@@ -108,13 +109,7 @@ function preEmitInheritanceEdges(graph, scopes, nodeLookup) {
             // suppression keeps `buildMro` and the final graph class-owned.
             handledSites.add(siteKey);
         }
-        const targetDef = findClassBindingInScope(site.inScope, site.name, scopes) ??
-            // Import-aware disambiguation fallback (#1951). Only engages when the
-            // scope-chain + single-match lookups above returned undefined because
-            // the simple name is ambiguous (multiple same-named class-like defs).
-            // Picks the candidate whose defining file is imported/included by the
-            // referencing file. Never changes behavior for single-match cases.
-            resolveAmbiguousInheritanceBaseViaImports(site.inScope, site.name, scopes);
+        const targetDef = resolveInheritanceBaseInScope(site.inScope, site.name, scopes);
         if (targetDef === undefined)
             continue;
         const callerClass = findEnclosingClassDef(site.inScope, scopes);
@@ -138,6 +133,62 @@ function preEmitInheritanceEdges(graph, scopes, nodeLookup) {
     }
     return handledSites;
 }
+/**
+ * Emit language-inferred structural interface implementations before MRO and
+ * interface dispatch are built. Languages such as Go do not declare
+ * `implements` explicitly, so their resolver can infer defId-level interface
+ * satisfaction from parsed files and this bridge converts those defIds to
+ * graph node ids.
+ *
+ * Existing explicit IMPLEMENTS edges win: the local `existing` set prevents
+ * duplicate structural edges and keeps this hook language-neutral. The reason
+ * string carries the provider language (`go-structural-implements`) so callers
+ * can distinguish inferred edges from source-declared heritage.
+ */
+function emitDetectedInterfaceImplementations(graph, parsedFiles, nodeLookup, provider, indexes, model) {
+    if (provider.detectInterfaceImplementations === undefined)
+        return 0;
+    const graphIdByDefId = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            if (def.type !== 'Class' && def.type !== 'Struct' && def.type !== 'Interface')
+                continue;
+            const graphId = resolveDefGraphId(parsed.filePath, def, nodeLookup);
+            if (graphId !== undefined)
+                graphIdByDefId.set(def.nodeId, graphId);
+        }
+    }
+    const existing = new Set();
+    for (const rel of graph.iterRelationshipsByType('IMPLEMENTS')) {
+        existing.add(`${rel.sourceId}->${rel.targetId}`);
+    }
+    let emitted = 0;
+    const detected = provider.detectInterfaceImplementations(parsedFiles, indexes, model);
+    for (const [interfaceDefId, implementorDefIds] of detected) {
+        const targetId = graphIdByDefId.get(interfaceDefId);
+        if (targetId === undefined)
+            continue;
+        for (const implementorDefId of implementorDefIds) {
+            const sourceId = graphIdByDefId.get(implementorDefId);
+            if (sourceId === undefined)
+                continue;
+            const edgeKey = `${sourceId}->${targetId}`;
+            if (existing.has(edgeKey))
+                continue;
+            existing.add(edgeKey);
+            graph.addRelationship({
+                id: generateId('IMPLEMENTS', edgeKey),
+                sourceId,
+                targetId,
+                type: 'IMPLEMENTS',
+                confidence: 0.85,
+                reason: `${provider.language}-structural-implements`,
+            });
+            emitted++;
+        }
+    }
+    return emitted;
+}
 export function runScopeResolution(input, provider) {
     const { graph, files } = input;
     const onWarn = input.onWarn ?? (() => { });
@@ -251,6 +302,7 @@ export function runScopeResolution(input, provider) {
     // `nodeLookup`). Without this rebuild, Property nodes added by the
     // heritage hook are invisible and ACCESSES edges silently fail to emit.
     const postHeritageNodeLookup = provider.emitHeritageEdges !== undefined ? buildGraphNodeLookup(graph) : nodeLookup;
+    emitDetectedInterfaceImplementations(graph, parsedFiles, postHeritageNodeLookup, provider, finalized, readonlyModel);
     const mroByClassDefId = provider.buildMro(graph, parsedFiles, postHeritageNodeLookup);
     const extendsOnlyMroByClassDefId = provider.buildExtendsOnlyMro?.(graph, parsedFiles, postHeritageNodeLookup);
     // Replace the empty MethodDispatchIndex that finalizeScopeModel

package/dist/core/ingestion/scope-resolution/scope/walkers.d.ts

@@ -114,6 +114,12 @@ export declare function moduleScopeIdOf(startScope: ScopeId, scopes: ScopeResolu
  * Without (2) we'd miss every cross-file class-receiver call.
  */
 export declare function findClassBindingInScope(startScope: ScopeId, receiverName: string, scopes: ScopeResolutionIndexes): SymbolDefinition | undefined;
+/**
+ * Resolve a class-like inheritance target using the shared inheritance
+ * resolution chain. Keeps pre-emitted heritage edges and language-specific
+ * consumers of `inherits` sites aligned.
+ */
+export declare function resolveInheritanceBaseInScope(startScope: ScopeId, baseName: string, scopes: ScopeResolutionIndexes): SymbolDefinition | undefined;
 /**
  * Import/include-aware disambiguation for an *ambiguous* class-like base
  * name. Engages ONLY as a fallback after `findClassBindingInScope` has

package/dist/core/ingestion/scope-resolution/scope/walkers.js

@@ -286,6 +286,15 @@ export function findClassBindingInScope(startScope, receiverName, scopes) {
     }
     return undefined;
 }
+/**
+ * Resolve a class-like inheritance target using the shared inheritance
+ * resolution chain. Keeps pre-emitted heritage edges and language-specific
+ * consumers of `inherits` sites aligned.
+ */
+export function resolveInheritanceBaseInScope(startScope, baseName, scopes) {
+    return (findClassBindingInScope(startScope, baseName, scopes) ??
+        resolveAmbiguousInheritanceBaseViaImports(startScope, baseName, scopes));
+}
 /**
  * Import/include-aware disambiguation for an *ambiguous* class-like base
  * name. Engages ONLY as a fallback after `findClassBindingInScope` has

package/dist/core/ingestion/tree-sitter-queries.js

@@ -891,6 +891,7 @@ export const GO_QUERIES = `
 ; Functions & Methods
 (function_declaration name: (identifier) @name) @definition.function
 (method_declaration name: (field_identifier) @name) @definition.method
+(method_elem name: (field_identifier) @name) @definition.method
 
 ; Types
 (type_declaration (type_spec name: (type_identifier) @name type: (struct_type))) @definition.struct

package/dist/core/ingestion/utils/ast-helpers.js

@@ -148,6 +148,9 @@ export const CLASS_CONTAINER_TYPES = new Set([
     // Kotlin
     'object_declaration',
     'companion_object',
+    // Go
+    'struct_type',
+    'interface_type',
 ]);
 export const CONTAINER_TYPE_TO_LABEL = {
     class_declaration: 'Class',
@@ -179,6 +182,8 @@ export const CONTAINER_TYPE_TO_LABEL = {
     singleton_class: 'Class', // Ruby: class << self inherits enclosing class name
     object_declaration: 'Class',
     companion_object: 'Class',
+    struct_type: 'Struct',
+    interface_type: 'Interface',
 };
 /**
  * Pre-order walk over a node and all its named descendants, invoking `cb` on

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.115",
+  "version": "1.6.6-rc.116",
   "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",