gitnexus 1.6.6-rc.99 → 1.6.6

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

@@ -1,72 +1,498 @@
+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) {
-        // Collect interface defs and their owned methods
         for (const scope of parsed.scopes) {
-            if (scope.kind !== 'Class')
+            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) {
+        const childScopesByParent = new Map();
+        for (const scope of parsed.scopes) {
+            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() ?? '');
-                            }
-                        }
-                    }
+            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);
                 }
-                // 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() ?? '');
-                    }
-                }
-                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);
+        }
+    }
+    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);
         }
     }
-    // 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)
+    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);
     }
-    return impls;
+    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 isSuperset(superset, subset) {
-    for (const item of subset) {
-        if (!superset.has(item))
+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);
+    // 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 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);
+    // 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;
+}
+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 result;
+    for (const name of required.keys()) {
+        const candidates = indexes.structIdsByMethodName.get(name);
+        if (candidates === undefined)
+            return [];
+        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 result === undefined ? indexes.structsById.keys() : result;
+}
+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);
+    }
+}
+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) {
+            // 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;
+            }
+        }
+    }
+    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';
@@ -90,14 +93,11 @@ export function interpretGoTypeBinding(captures) {
 }
 export function normalizeGoTypeName(text) {
     let t = text.trim();
-    while (t.startsWith('*'))
-        t = t.slice(1).trim();
-    if (t.startsWith('[]'))
-        t = t.slice(2).trim();
+    t = stripGoOuterTypePrefixes(t);
     const mapMatch = t.match(/^map\[[^\]]+\]\s*(.+)$/);
     if (mapMatch)
         t = mapMatch[1].trim();
-    t = t.replace(/^(?:<-)?chan\s+/, '');
+    t = stripGoOuterTypePrefixes(t.replace(/^(?:<-)?chan(?:<-)?\s+/, ''));
     if (t.startsWith('func(')) {
         const retMatch = t.match(/^func\([^)]*\)\s*(.*)$/);
         if (retMatch)
@@ -125,14 +125,11 @@ export function normalizeGoReturnType(text) {
         const closeIdx = t.indexOf(',');
         t = t.slice(1, closeIdx).trim();
     }
-    while (t.startsWith('*'))
-        t = t.slice(1).trim();
-    if (t.startsWith('[]'))
-        t = t.slice(2).trim();
+    t = stripGoOuterTypePrefixes(t);
     const mapMatch = t.match(/^map\[[^\]]+\]\s*(.+)$/);
     if (mapMatch)
         t = mapMatch[1].trim();
-    t = t.replace(/^(?:<-)?chan\s+/, '');
+    t = stripGoOuterTypePrefixes(t.replace(/^(?:<-)?chan(?:<-)?\s+/, ''));
     if (t.startsWith('func(')) {
         const retMatch = t.match(/^func\([^)]*\)\s*(.*)$/);
         if (retMatch)
@@ -144,3 +141,16 @@ export function normalizeGoReturnType(text) {
         t = t.slice(0, bracket);
     return t;
 }
+function stripGoOuterTypePrefixes(text) {
+    let t = text.trim();
+    let previous;
+    do {
+        previous = t;
+        while (t.startsWith('*'))
+            t = t.slice(1).trim();
+        if (t.startsWith('[]'))
+            t = t.slice(2).trim();
+        t = t.replace(/^\[[^\]]+\]\s*/, '');
+    } while (t !== previous);
+    return t;
+}

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}`;
+                        }
                     }
                 }
             }