fix(julia): drop unused TYPE_HEAD_WRAPPERS entries, add simple-supertype test (#1128)

- Remove type_parameter_list / type_argument_list from TYPE_HEAD_WRAPPERS
  in both WASM and native engines. Julia grammar uses curly_expression
  for {T} constructs, so these were dead code. Removing them prevents
  findBaseName from ever recursing into a type-parameter list and
  returning a type variable (e.g. T) instead of the struct name.
- Add WASM test for non-parameterized struct inheritance
  (struct Point <: AbstractPoint). The native engine already covers
  this case; the WASM side now has parity.

Author: carlos-alm

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

@@ -297,9 +297,17 @@ fn handle_abstract_def(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
 ///
 /// Handles plain identifiers, `Name <: Super` binary expressions, and
 /// parameterized forms like `Name{T}` / `Name{T} <: Super{T,1}` by recursing
-/// into common wrapper kinds (binary expressions, parametrized identifiers,
-/// type-parameter lists). Returns `None` when no identifier can be located —
+/// into wrapper kinds the Julia grammar actually emits for type heads
+/// (binary expressions, parametrized type expressions, parameterized
+/// identifiers). Returns `None` when no identifier can be located —
 /// callers should skip emitting a definition in that case.
+///
+/// Note: `type_parameter_list` / `type_argument_list` are intentionally
+/// excluded — Julia's grammar uses `curly_expression` for `{T}` constructs,
+/// not those node kinds. Including them would risk recursing into a
+/// type-parameter list and returning a type variable (e.g. `T`) instead of
+/// the struct name if `find_base_name` were ever called on a node lacking a
+/// direct `identifier` child.
 fn find_base_name<'a>(node: &Node<'a>) -> Option<Node<'a>> {
     // The node itself may already be the identifier (e.g. when called on a
     // direct side of a binary_expression like `Point <: AbstractPoint`).
@@ -317,9 +325,7 @@ fn find_base_name<'a>(node: &Node<'a>) -> Option<Node<'a>> {
         match child.kind() {
             "binary_expression"
             | "parametrized_type_expression"
-            | "parameterized_identifier"
-            | "type_parameter_list"
-            | "type_argument_list" => {
+            | "parameterized_identifier" => {
                 if let Some(found) = find_base_name(&child) {
                     return Some(found);
                 }

src/extractors/julia.ts

@@ -173,17 +173,22 @@ function handleAssignment(
  *
  * Handles plain identifiers, `Name <: Super` binary expressions, and
  * parameterized forms like `Name{T}` / `Name{T} <: Super{T,1}` by recursing
- * into common wrapper kinds (binary expressions, parametrized type
- * expressions, parameterized identifiers, type-parameter / type-argument
- * lists). Returns `null` when no identifier can be located — callers should
- * skip emitting a definition in that case.
+ * into wrapper kinds the Julia grammar actually emits for type heads
+ * (binary expressions, parametrized type expressions, parameterized
+ * identifiers). Returns `null` when no identifier can be located — callers
+ * should skip emitting a definition in that case.
+ *
+ * Note: `type_parameter_list` / `type_argument_list` are intentionally
+ * excluded — Julia's grammar uses `curly_expression` for `{T}` constructs,
+ * not those node kinds. Including them would risk recursing into a
+ * type-parameter list and returning a type variable (e.g. `T`) instead of
+ * the struct name if `findBaseName` were ever called on a node lacking a
+ * direct `identifier` child.
  */
 const TYPE_HEAD_WRAPPERS: ReadonlySet<string> = new Set([
   'binary_expression',
   'parametrized_type_expression',
   'parameterized_identifier',
-  'type_parameter_list',
-  'type_argument_list',
 ]);
 
 function findBaseName(node: TreeSitterNode): TreeSitterNode | null {

tests/parsers/julia.test.ts

@@ -69,6 +69,20 @@ end`);
     expect(symbols.classes[0]).toMatchObject({ name: 'Vec', extends: 'AbstractArray' });
   });
 
+  it('extracts non-parameterized struct inheritance', () => {
+    // Simple `struct Name <: Super` must still record both the definition
+    // and the `extends` relationship — the grammar wraps it in a
+    // `binary_expression` just like the parameterized form.
+    const symbols = parseJulia(`struct Point <: AbstractPoint
+    x::Float64
+    y::Float64
+end`);
+    const names = symbols.definitions.map((d) => d.name);
+    expect(names).toContain('Point');
+    expect(symbols.classes).toHaveLength(1);
+    expect(symbols.classes[0]).toMatchObject({ name: 'Point', extends: 'AbstractPoint' });
+  });
+
   it('qualified short-form method does not double-prefix', () => {
     // `Foo.bar(x, y) = x + y` inside `module Outer` must record `Foo.bar`,
     // not `Outer.Foo.bar` — the scoped_identifier already carries the qualifier.