fix(groovy): use current node's start line in WASM interface helper (#1158)

Align the TypeScript collectGroovyParentInterfaces helper with the Rust
collect_interfaces helper, which re-evaluates start_line(interfaces) at
each recursive invocation. Previously the WASM extractor forwarded the
interface declaration's start line through every recursion level, so a
multi-line interface (e.g. interface X\n  extends Y, Z {}) produced
line=1 in WASM but line=2 in native — the two engines must produce
identical results.

Add a multi-line line-parity test in both engines to guard against
future regressions.

Author: carlos-alm

crates/codegraph-core/src/extractors/groovy.rs

@@ -555,4 +555,18 @@ mod tests {
             rels
         );
     }
+
+    #[test]
+    fn interface_inheritance_line_tracks_extends_clause() {
+        // Engine-parity guard: the relation line should match the
+        // `extends_interfaces` node's start line, not the `interface_declaration`'s
+        // — `collect_interfaces` re-evaluates `start_line(interfaces)` on every
+        // recursive call, and the WASM extractor must match.
+        let s = parse_groovy("interface Serializable\n  extends Comparable, Cloneable {}");
+        let rels: Vec<_> = s.classes.iter().filter(|c| c.name == "Serializable").collect();
+        assert!(!rels.is_empty(), "expected at least one ClassRelation");
+        for rel in &rels {
+            assert_eq!(rel.line, 2, "line should track the extends clause, got: {:?}", rel);
+        }
+    }
 }

src/extractors/groovy.ts

@@ -157,7 +157,7 @@ function handleGroovyInterfaceDecl(node: TreeSitterNode, ctx: ExtractorOutput):
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (child && child.type === 'extends_interfaces') {
-      collectGroovyParentInterfaces(child, ifaceName, node.startPosition.row + 1, ctx);
+      collectGroovyParentInterfaces(child, ifaceName, ctx);
       break;
     }
   }
@@ -166,9 +166,12 @@ function handleGroovyInterfaceDecl(node: TreeSitterNode, ctx: ExtractorOutput):
 function collectGroovyParentInterfaces(
   parent: TreeSitterNode,
   name: string,
-  line: number,
   ctx: ExtractorOutput,
 ): void {
+  // Use the current node's start line at each recursion level — matches the
+  // Rust `collect_interfaces` helper, which re-evaluates `start_line(interfaces)`
+  // for whatever node (`extends_interfaces` → `type_list`) is being processed.
+  const line = parent.startPosition.row + 1;
   for (let i = 0; i < parent.childCount; i++) {
     const child = parent.child(i);
     if (!child) continue;
@@ -185,7 +188,7 @@ function collectGroovyParentInterfaces(
         break;
       }
       case 'type_list':
-        collectGroovyParentInterfaces(child, name, line, ctx);
+        collectGroovyParentInterfaces(child, name, ctx);
         break;
     }
   }

tests/parsers/groovy.test.ts

@@ -64,6 +64,20 @@ describe('Groovy parser', () => {
     );
   });
 
+  it('reports line of extends_interfaces clause for multi-line declarations', () => {
+    // Engine-parity guard: the line should match the `extends_interfaces`
+    // node's start line, not the `interface_declaration`'s start line, so the
+    // WASM extractor stays consistent with the Rust `collect_interfaces`
+    // helper which re-evaluates the current node's `start_line` at each
+    // recursion level.
+    const symbols = parseGroovy(`interface Serializable\n  extends Comparable, Cloneable {}`);
+    const rels = symbols.classes.filter((c) => c.name === 'Serializable');
+    expect(rels.length).toBeGreaterThan(0);
+    for (const rel of rels) {
+      expect(rel.line).toBe(2);
+    }
+  });
+
   it('extracts enum declarations', () => {
     const symbols = parseGroovy(`enum Color {
     RED, GREEN, BLUE