@optave/codegraph 3.3.1 → 3.4.1

package/src/extractors/{csharp.js → csharp.ts}

@@ -1,10 +1,18 @@
-import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
+import type {
+  Call,
+  ClassRelation,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import { extractModifierVisibility, findChild, MAX_WALK_DEPTH, nodeEndLine } from './helpers.js';
 
 /**
  * Extract symbols from C# files.
  */
-export function extractCSharpSymbols(tree, _filePath) {
-  const ctx = {
+export function extractCSharpSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
     definitions: [],
     calls: [],
     imports: [],
@@ -14,11 +22,12 @@ export function extractCSharpSymbols(tree, _filePath) {
   };
 
   walkCSharpNode(tree.rootNode, ctx);
+  reclassifyCSharpImplements(ctx);
   extractCSharpTypeMap(tree.rootNode, ctx);
   return ctx;
 }
 
-function walkCSharpNode(node, ctx) {
+function walkCSharpNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
   switch (node.type) {
     case 'class_declaration':
       handleCsClassDecl(node, ctx);
@@ -55,12 +64,15 @@ function walkCSharpNode(node, ctx) {
       break;
   }
 
-  for (let i = 0; i < node.childCount; i++) walkCSharpNode(node.child(i), ctx);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkCSharpNode(child, ctx);
+  }
 }
 
 // ── Walk-path per-node-type handlers ────────────────────────────────────────
 
-function handleCsClassDecl(node, ctx) {
+function handleCsClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const classChildren = extractCSharpClassFields(node);
@@ -74,7 +86,7 @@ function handleCsClassDecl(node, ctx) {
   extractCSharpBaseTypes(node, nameNode.text, ctx.classes);
 }
 
-function handleCsStructDecl(node, ctx) {
+function handleCsStructDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const structChildren = extractCSharpClassFields(node);
@@ -88,7 +100,7 @@ function handleCsStructDecl(node, ctx) {
   extractCSharpBaseTypes(node, nameNode.text, ctx.classes);
 }
 
-function handleCsRecordDecl(node, ctx) {
+function handleCsRecordDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   ctx.definitions.push({
@@ -100,7 +112,7 @@ function handleCsRecordDecl(node, ctx) {
   extractCSharpBaseTypes(node, nameNode.text, ctx.classes);
 }
 
-function handleCsInterfaceDecl(node, ctx) {
+function handleCsInterfaceDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   ctx.definitions.push({
@@ -128,7 +140,7 @@ function handleCsInterfaceDecl(node, ctx) {
   }
 }
 
-function handleCsEnumDecl(node, ctx) {
+function handleCsEnumDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const enumChildren = extractCSharpEnumMembers(node);
@@ -141,7 +153,7 @@ function handleCsEnumDecl(node, ctx) {
   });
 }
 
-function handleCsMethodDecl(node, ctx) {
+function handleCsMethodDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // Skip interface methods already emitted by handleCsInterfaceDecl
   if (node.parent?.parent?.type === 'interface_declaration') return;
   const nameNode = node.childForFieldName('name');
@@ -159,7 +171,7 @@ function handleCsMethodDecl(node, ctx) {
   });
 }
 
-function handleCsConstructorDecl(node, ctx) {
+function handleCsConstructorDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const parentType = findCSharpParentType(node);
@@ -175,7 +187,7 @@ function handleCsConstructorDecl(node, ctx) {
   });
 }
 
-function handleCsPropertyDecl(node, ctx) {
+function handleCsPropertyDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const parentType = findCSharpParentType(node);
@@ -189,14 +201,14 @@ function handleCsPropertyDecl(node, ctx) {
   });
 }
 
-function handleCsUsingDirective(node, ctx) {
+function handleCsUsingDirective(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode =
     node.childForFieldName('name') ||
     findChild(node, 'qualified_name') ||
     findChild(node, 'identifier');
   if (!nameNode) return;
   const fullPath = nameNode.text;
-  const lastName = fullPath.split('.').pop();
+  const lastName = fullPath.split('.').pop() ?? fullPath;
   ctx.imports.push({
     source: fullPath,
     names: [lastName],
@@ -205,7 +217,7 @@ function handleCsUsingDirective(node, ctx) {
   });
 }
 
-function handleCsInvocationExpr(node, ctx) {
+function handleCsInvocationExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const fn = node.childForFieldName('function') || node.child(0);
   if (!fn) return;
   if (fn.type === 'identifier') {
@@ -214,7 +226,7 @@ function handleCsInvocationExpr(node, ctx) {
     const name = fn.childForFieldName('name');
     if (name) {
       const expr = fn.childForFieldName('expression');
-      const call = { name: name.text, line: node.startPosition.row + 1 };
+      const call: Call = { name: name.text, line: node.startPosition.row + 1 };
       if (expr) call.receiver = expr.text;
       ctx.calls.push(call);
     }
@@ -224,7 +236,7 @@ function handleCsInvocationExpr(node, ctx) {
   }
 }
 
-function handleCsObjectCreation(node, ctx) {
+function handleCsObjectCreation(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const typeNode = node.childForFieldName('type');
   if (!typeNode) return;
   const typeName =
@@ -234,7 +246,7 @@ function handleCsObjectCreation(node, ctx) {
   if (typeName) ctx.calls.push({ name: typeName, line: node.startPosition.row + 1 });
 }
 
-function findCSharpParentType(node) {
+function findCSharpParentType(node: TreeSitterNode): string | null {
   let current = node.parent;
   while (current) {
     if (
@@ -254,8 +266,8 @@ function findCSharpParentType(node) {
 
 // ── Child extraction helpers ────────────────────────────────────────────────
 
-function extractCSharpParameters(paramListNode) {
-  const params = [];
+function extractCSharpParameters(paramListNode: TreeSitterNode | null): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
   if (!paramListNode) return params;
   for (let i = 0; i < paramListNode.childCount; i++) {
     const param = paramListNode.child(i);
@@ -268,8 +280,8 @@ function extractCSharpParameters(paramListNode) {
   return params;
 }
 
-function extractCSharpClassFields(classNode) {
-  const fields = [];
+function extractCSharpClassFields(classNode: TreeSitterNode): SubDeclaration[] {
+  const fields: SubDeclaration[] = [];
   const body = classNode.childForFieldName('body') || findChild(classNode, 'declaration_list');
   if (!body) return fields;
   for (let i = 0; i < body.childCount; i++) {
@@ -294,8 +306,8 @@ function extractCSharpClassFields(classNode) {
   return fields;
 }
 
-function extractCSharpEnumMembers(enumNode) {
-  const constants = [];
+function extractCSharpEnumMembers(enumNode: TreeSitterNode): SubDeclaration[] {
+  const constants: SubDeclaration[] = [];
   const body =
     enumNode.childForFieldName('body') || findChild(enumNode, 'enum_member_declaration_list');
   if (!body) return constants;
@@ -312,12 +324,16 @@ function extractCSharpEnumMembers(enumNode) {
 
 // ── Type map extraction ──────────────────────────────────────────────────────
 
-function extractCSharpTypeMap(node, ctx) {
+function extractCSharpTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void {
   extractCSharpTypeMapDepth(node, ctx, 0);
 }
 
-function extractCSharpTypeMapDepth(node, ctx, depth) {
-  if (depth >= 200) return;
+function extractCSharpTypeMapDepth(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  depth: number,
+): void {
+  if (depth >= MAX_WALK_DEPTH) return;
 
   // local_declaration_statement → variable_declaration → type + variable_declarator(s)
   if (node.type === 'variable_declaration') {
@@ -330,7 +346,7 @@ function extractCSharpTypeMapDepth(node, ctx, depth) {
           if (child && child.type === 'variable_declarator') {
             const nameNode = child.childForFieldName('name') || child.child(0);
             if (nameNode && nameNode.type === 'identifier') {
-              ctx.typeMap.set(nameNode.text, { type: typeName, confidence: 0.9 });
+              ctx.typeMap?.set(nameNode.text, { type: typeName, confidence: 0.9 });
             }
           }
         }
@@ -344,7 +360,7 @@ function extractCSharpTypeMapDepth(node, ctx, depth) {
     const nameNode = node.childForFieldName('name');
     if (typeNode && nameNode) {
       const typeName = extractCSharpTypeName(typeNode);
-      if (typeName) ctx.typeMap.set(nameNode.text, { type: typeName, confidence: 0.9 });
+      if (typeName) ctx.typeMap?.set(nameNode.text, { type: typeName, confidence: 0.9 });
     }
   }
 
@@ -354,7 +370,7 @@ function extractCSharpTypeMapDepth(node, ctx, depth) {
   }
 }
 
-function extractCSharpTypeName(typeNode) {
+function extractCSharpTypeName(typeNode: TreeSitterNode): string | null {
   if (!typeNode) return null;
   const t = typeNode.type;
   if (t === 'identifier' || t === 'qualified_name') return typeNode.text;
@@ -370,8 +386,32 @@ function extractCSharpTypeName(typeNode) {
   return null;
 }
 
-function extractCSharpBaseTypes(node, className, classes) {
-  const baseList = node.childForFieldName('bases');
+/**
+ * Post-walk pass: reclassify `extends` entries as `implements` when the target
+ * is a known interface in the same file. At extraction time we cannot distinguish
+ * base classes from interfaces in the base_list, so we fix it up here using the
+ * definitions collected during the walk.
+ */
+function reclassifyCSharpImplements(ctx: ExtractorOutput): void {
+  const interfaceNames = new Set<string>();
+  for (const def of ctx.definitions) {
+    if (def.kind === 'interface') interfaceNames.add(def.name);
+  }
+  for (const cls of ctx.classes) {
+    if (cls.extends && interfaceNames.has(cls.extends)) {
+      cls.implements = cls.extends;
+      delete cls.extends;
+    }
+  }
+}
+
+function extractCSharpBaseTypes(
+  node: TreeSitterNode,
+  className: string,
+  classes: ClassRelation[],
+): void {
+  // tree-sitter-c-sharp exposes base_list as a child node type, not a field
+  const baseList = node.childForFieldName('bases') || findChild(node, 'base_list');
   if (!baseList) return;
   for (let i = 0; i < baseList.childCount; i++) {
     const child = baseList.child(i);
@@ -382,17 +422,6 @@ function extractCSharpBaseTypes(node, className, classes) {
       const name = child.childForFieldName('name') || child.child(0);
       if (name)
         classes.push({ name: className, extends: name.text, line: node.startPosition.row + 1 });
-    } else if (child.type === 'base_list') {
-      for (let j = 0; j < child.childCount; j++) {
-        const base = child.child(j);
-        if (base && (base.type === 'identifier' || base.type === 'qualified_name')) {
-          classes.push({ name: className, extends: base.text, line: node.startPosition.row + 1 });
-        } else if (base && base.type === 'generic_name') {
-          const name = base.childForFieldName('name') || base.child(0);
-          if (name)
-            classes.push({ name: className, extends: name.text, line: node.startPosition.row + 1 });
-        }
-      }
     }
   }
 }

package/src/extractors/{go.js → go.ts}

@@ -1,10 +1,18 @@
-import { findChild, goVisibility, nodeEndLine } from './helpers.js';
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+  TypeMapEntry,
+} from '../types.js';
+import { findChild, goVisibility, MAX_WALK_DEPTH, nodeEndLine } from './helpers.js';
 
 /**
  * Extract symbols from Go files.
  */
-export function extractGoSymbols(tree, _filePath) {
-  const ctx = {
+export function extractGoSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
     definitions: [],
     calls: [],
     imports: [],
@@ -15,10 +23,11 @@ export function extractGoSymbols(tree, _filePath) {
 
   walkGoNode(tree.rootNode, ctx);
   extractGoTypeMap(tree.rootNode, ctx);
+  matchGoStructuralInterfaces(ctx);
   return ctx;
 }
 
-function walkGoNode(node, ctx) {
+function walkGoNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
   switch (node.type) {
     case 'function_declaration':
       handleGoFuncDecl(node, ctx);
@@ -40,12 +49,15 @@ function walkGoNode(node, ctx) {
       break;
   }
 
-  for (let i = 0; i < node.childCount; i++) walkGoNode(node.child(i), ctx);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkGoNode(child, ctx);
+  }
 }
 
 // ── Walk-path per-node-type handlers ────────────────────────────────────────
 
-function handleGoFuncDecl(node, ctx) {
+function handleGoFuncDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const params = extractGoParameters(node.childForFieldName('parameters'));
@@ -59,11 +71,11 @@ function handleGoFuncDecl(node, ctx) {
   });
 }
 
-function handleGoMethodDecl(node, ctx) {
+function handleGoMethodDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   const receiver = node.childForFieldName('receiver');
   if (!nameNode) return;
-  let receiverType = null;
+  let receiverType: string | null = null;
   if (receiver) {
     for (let i = 0; i < receiver.childCount; i++) {
       const param = receiver.child(i);
@@ -88,7 +100,7 @@ function handleGoMethodDecl(node, ctx) {
   });
 }
 
-function handleGoTypeDecl(node, ctx) {
+function handleGoTypeDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   for (let i = 0; i < node.childCount; i++) {
     const spec = node.child(i);
     if (!spec || spec.type !== 'type_spec') continue;
@@ -137,7 +149,7 @@ function handleGoTypeDecl(node, ctx) {
   }
 }
 
-function handleGoImportDecl(node, ctx) {
+function handleGoImportDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
@@ -155,12 +167,12 @@ function handleGoImportDecl(node, ctx) {
   }
 }
 
-function extractGoImportSpec(spec, ctx) {
+function extractGoImportSpec(spec: TreeSitterNode, ctx: ExtractorOutput): void {
   const pathNode = spec.childForFieldName('path');
   if (pathNode) {
     const importPath = pathNode.text.replace(/"/g, '');
     const nameNode = spec.childForFieldName('name');
-    const alias = nameNode ? nameNode.text : importPath.split('/').pop();
+    const alias = nameNode ? nameNode.text : (importPath.split('/').pop() ?? importPath);
     ctx.imports.push({
       source: importPath,
       names: [alias],
@@ -170,7 +182,7 @@ function extractGoImportSpec(spec, ctx) {
   }
 }
 
-function handleGoConstDecl(node, ctx) {
+function handleGoConstDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   for (let i = 0; i < node.childCount; i++) {
     const spec = node.child(i);
     if (!spec || spec.type !== 'const_spec') continue;
@@ -186,7 +198,7 @@ function handleGoConstDecl(node, ctx) {
   }
 }
 
-function handleGoCallExpr(node, ctx) {
+function handleGoCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const fn = node.childForFieldName('function');
   if (!fn) return;
   if (fn.type === 'identifier') {
@@ -195,7 +207,7 @@ function handleGoCallExpr(node, ctx) {
     const field = fn.childForFieldName('field');
     if (field) {
       const operand = fn.childForFieldName('operand');
-      const call = { name: field.text, line: node.startPosition.row + 1 };
+      const call: Call = { name: field.text, line: node.startPosition.row + 1 };
       if (operand) call.receiver = operand.text;
       ctx.calls.push(call);
     }
@@ -204,19 +216,24 @@ function handleGoCallExpr(node, ctx) {
 
 // ── Type map extraction ─────────────────────────────────────────────────────
 
-function extractGoTypeMap(node, ctx) {
+function extractGoTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void {
   extractGoTypeMapDepth(node, ctx, 0);
 }
 
-function setIfHigher(typeMap, name, type, confidence) {
+function setIfHigher(
+  typeMap: Map<string, TypeMapEntry>,
+  name: string,
+  type: string,
+  confidence: number,
+): void {
   const existing = typeMap.get(name);
   if (!existing || confidence > existing.confidence) {
     typeMap.set(name, { type, confidence });
   }
 }
 
-function extractGoTypeMapDepth(node, ctx, depth) {
-  if (depth >= 200) return;
+function extractGoTypeMapDepth(node: TreeSitterNode, ctx: ExtractorOutput, depth: number): void {
+  if (depth >= MAX_WALK_DEPTH) return;
 
   // var x MyType = ... or var x, y MyType → var_declaration > var_spec (confidence 0.9)
   if (node.type === 'var_spec') {
@@ -227,7 +244,7 @@ function extractGoTypeMapDepth(node, ctx, depth) {
         for (let i = 0; i < node.childCount; i++) {
           const child = node.child(i);
           if (child && child.type === 'identifier') {
-            setIfHigher(ctx.typeMap, child.text, typeName, 0.9);
+            if (ctx.typeMap) setIfHigher(ctx.typeMap, child.text, typeName, 0.9);
           }
         }
       }
@@ -243,7 +260,7 @@ function extractGoTypeMapDepth(node, ctx, depth) {
         for (let i = 0; i < node.childCount; i++) {
           const child = node.child(i);
           if (child && child.type === 'identifier') {
-            setIfHigher(ctx.typeMap, child.text, typeName, 0.9);
+            if (ctx.typeMap) setIfHigher(ctx.typeMap, child.text, typeName, 0.9);
           }
         }
       }
@@ -259,7 +276,7 @@ function extractGoTypeMapDepth(node, ctx, depth) {
       const lefts =
         left.type === 'expression_list'
           ? Array.from({ length: left.childCount }, (_, i) => left.child(i)).filter(
-              (c) => c?.type === 'identifier',
+              (c): c is TreeSitterNode => c?.type === 'identifier',
             )
           : left.type === 'identifier'
             ? [left]
@@ -267,7 +284,7 @@ function extractGoTypeMapDepth(node, ctx, depth) {
       const rights =
         right.type === 'expression_list'
           ? Array.from({ length: right.childCount }, (_, i) => right.child(i)).filter(
-              (c) => c?.isNamed,
+              (c): c is TreeSitterNode => !!c?.type,
             )
           : [right];
 
@@ -281,7 +298,7 @@ function extractGoTypeMapDepth(node, ctx, depth) {
           const typeNode = rhs.childForFieldName('type');
           if (typeNode) {
             const typeName = extractGoTypeName(typeNode);
-            if (typeName) setIfHigher(ctx.typeMap, varNode.text, typeName, 1.0);
+            if (typeName && ctx.typeMap) setIfHigher(ctx.typeMap, varNode.text, typeName, 1.0);
           }
         }
         // x := &Struct{...} — address-of composite literal (confidence 1.0)
@@ -291,7 +308,7 @@ function extractGoTypeMapDepth(node, ctx, depth) {
             const typeNode = operand.childForFieldName('type');
             if (typeNode) {
               const typeName = extractGoTypeName(typeNode);
-              if (typeName) setIfHigher(ctx.typeMap, varNode.text, typeName, 1.0);
+              if (typeName && ctx.typeMap) setIfHigher(ctx.typeMap, varNode.text, typeName, 1.0);
             }
           }
         }
@@ -302,11 +319,11 @@ function extractGoTypeMapDepth(node, ctx, depth) {
             const field = fn.childForFieldName('field');
             if (field?.text.startsWith('New')) {
               const typeName = field.text.slice(3);
-              if (typeName) setIfHigher(ctx.typeMap, varNode.text, typeName, 0.7);
+              if (typeName && ctx.typeMap) setIfHigher(ctx.typeMap, varNode.text, typeName, 0.7);
             }
           } else if (fn && fn.type === 'identifier' && fn.text.startsWith('New')) {
             const typeName = fn.text.slice(3);
-            if (typeName) setIfHigher(ctx.typeMap, varNode.text, typeName, 0.7);
+            if (typeName && ctx.typeMap) setIfHigher(ctx.typeMap, varNode.text, typeName, 0.7);
           }
         }
       }
@@ -319,7 +336,7 @@ function extractGoTypeMapDepth(node, ctx, depth) {
   }
 }
 
-function extractGoTypeName(typeNode) {
+function extractGoTypeName(typeNode: TreeSitterNode): string | null {
   if (!typeNode) return null;
   const t = typeNode.type;
   if (t === 'type_identifier' || t === 'identifier') return typeNode.text;
@@ -343,8 +360,8 @@ function extractGoTypeName(typeNode) {
 
 // ── Child extraction helpers ────────────────────────────────────────────────
 
-function extractGoParameters(paramListNode) {
-  const params = [];
+function extractGoParameters(paramListNode: TreeSitterNode | null): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
   if (!paramListNode) return params;
   for (let i = 0; i < paramListNode.childCount; i++) {
     const param = paramListNode.child(i);
@@ -360,8 +377,66 @@ function extractGoParameters(paramListNode) {
   return params;
 }
 
-function extractStructFields(structTypeNode) {
-  const fields = [];
+// ── Go structural interface matching ─────────────────────────────────────
+
+/**
+ * Go interfaces are satisfied structurally: a struct implements an interface
+ * if it has methods matching every method declared in the interface.
+ * This performs file-local matching (cross-file matching requires build-edges).
+ */
+function matchGoStructuralInterfaces(ctx: ExtractorOutput): void {
+  const interfaceMethods = new Map<string, Set<string>>();
+  const structMethods = new Map<string, Set<string>>();
+  const structLines = new Map<string, number>();
+
+  // Collect interface and struct definitions
+  const interfaceNames = new Set<string>();
+  const structNames = new Set<string>();
+  for (const def of ctx.definitions) {
+    if (def.kind === 'interface') interfaceNames.add(def.name);
+    if (def.kind === 'struct') {
+      structNames.add(def.name);
+      structLines.set(def.name, def.line);
+    }
+  }
+
+  // Collect methods grouped by receiver type
+  for (const def of ctx.definitions) {
+    if (def.kind !== 'method' || !def.name.includes('.')) continue;
+    const dotIdx = def.name.indexOf('.');
+    const receiver = def.name.slice(0, dotIdx);
+    const method = def.name.slice(dotIdx + 1);
+
+    if (interfaceNames.has(receiver)) {
+      if (!interfaceMethods.has(receiver)) interfaceMethods.set(receiver, new Set());
+      interfaceMethods.get(receiver)?.add(method);
+    }
+    if (structNames.has(receiver)) {
+      if (!structMethods.has(receiver)) structMethods.set(receiver, new Set());
+      structMethods.get(receiver)?.add(method);
+    }
+  }
+
+  // Match: struct satisfies interface if it has all interface methods (name-only;
+  // signatures are not verified — treat as candidate match, not definitive).
+  // NOTE: embedded interfaces (type_elem nodes) are not resolved — composite
+  // interfaces like `type ReadWriter interface { Reader; Writer }` will have an
+  // empty method set and be silently excluded from matching.
+  for (const [structName, methods] of structMethods) {
+    for (const [ifaceName, ifaceMethods] of interfaceMethods) {
+      if (ifaceMethods.size > 0 && [...ifaceMethods].every((m) => methods.has(m))) {
+        ctx.classes.push({
+          name: structName,
+          implements: ifaceName,
+          line: structLines.get(structName) || 1,
+        });
+      }
+    }
+  }
+}
+
+function extractStructFields(structTypeNode: TreeSitterNode): SubDeclaration[] {
+  const fields: SubDeclaration[] = [];
   const fieldList = findChild(structTypeNode, 'field_declaration_list');
   if (!fieldList) return fields;
   for (let i = 0; i < fieldList.childCount; i++) {