fix(gleam): extract parameters for external functions (#1127)

* fix(gleam): extract parameters for external functions

Mirror regular `function` behavior so `external_function` definitions
expose their parameter list as children in both native and WASM engines.
Previously external functions silently dropped parameter children even
though the grammar exposes them via the same `parameters` field.

Closes #1110

* test(gleam): exercise type-only external params with named-less args (#1127)

Replace random() (zero parameters) with random(Int, String) (type-only
parameters) so the test actually covers the documented edge case:
parameter nodes that exist in the tree but lack a name field. The old
case asserted the same observable outcome (no children) but exercised
the empty-parameter-list path, not the type-only path.

Applies to both Rust and JS engines.

Author: carlos-alm

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

@@ -61,6 +61,8 @@ fn handle_external_function(node: &Node, source: &[u8], symbols: &mut FileSymbol
         None => return,
     };
 
+    let params = extract_params(node, source);
+
     symbols.definitions.push(Definition {
         name: node_text(&name_node, source).to_string(),
         kind: "function".to_string(),
@@ -69,7 +71,7 @@ fn handle_external_function(node: &Node, source: &[u8], symbols: &mut FileSymbol
         decorators: None,
         complexity: None,
         cfg: None,
-        children: None,
+        children: opt_children(params),
     });
 }
 
@@ -443,4 +445,39 @@ mod tests {
             .expect("expected constant");
         assert_eq!(c.kind, "variable");
     }
+
+    #[test]
+    fn extracts_external_function_with_named_parameters() {
+        let code = "pub external fn parse(input: String, base: Int) -> Int = \"erlang_mod\" \"parse\"\n";
+        let s = parse_gleam(code);
+        let parse_fn = s
+            .definitions
+            .iter()
+            .find(|d| d.name == "parse")
+            .expect("expected external function `parse`");
+        assert_eq!(parse_fn.kind, "function");
+        let children = parse_fn
+            .children
+            .as_ref()
+            .expect("expected external function parameters as children");
+        let names: Vec<&str> = children.iter().map(|c| c.name.as_str()).collect();
+        assert!(names.contains(&"input"), "missing `input` param, got {names:?}");
+        assert!(names.contains(&"base"), "missing `base` param, got {names:?}");
+        assert!(children.iter().all(|c| c.kind == "parameter"));
+    }
+
+    #[test]
+    fn external_function_without_param_names_has_no_children() {
+        // External function with type-only parameters (no names) — the tree-sitter
+        // grammar still produces parameter nodes, but they lack a `name` field, so
+        // `extract_params` returns an empty Vec and `children` is None.
+        let code = "pub external fn random(Int, String) -> Int = \"rand\" \"uniform\"\n";
+        let s = parse_gleam(code);
+        let random_fn = s
+            .definitions
+            .iter()
+            .find(|d| d.name == "random")
+            .expect("expected external function `random`");
+        assert!(random_fn.children.is_none());
+    }
 }

src/extractors/gleam.ts

@@ -85,12 +85,15 @@ function handleExternalFunction(node: TreeSitterNode, ctx: ExtractorOutput): voi
   const nameNode = node.childForFieldName('name') || findChild(node, 'identifier');
   if (!nameNode) return;
 
+  const params = extractParams(node);
+
   ctx.definitions.push({
     name: nameNode.text,
     kind: 'function',
     line: node.startPosition.row + 1,
     endLine: nodeEndLine(node),
     visibility: isPublic(node) ? 'public' : 'private',
+    children: params.length > 0 ? params : undefined,
   });
 }
 

tests/parsers/gleam.test.ts

@@ -45,4 +45,27 @@ import gleam/string`);
 }`);
     expect(symbols.calls.length).toBeGreaterThanOrEqual(1);
   });
+
+  it('extracts external function parameters as children', () => {
+    const symbols = parseGleam(
+      `pub external fn parse(input: String, base: Int) -> Int = "erlang_mod" "parse"`,
+    );
+    const parseFn = symbols.definitions.find((d) => d.name === 'parse');
+    expect(parseFn).toBeDefined();
+    expect(parseFn?.kind).toBe('function');
+    expect(parseFn?.children).toBeDefined();
+    const names = parseFn?.children?.map((c) => c.name) ?? [];
+    expect(names).toContain('input');
+    expect(names).toContain('base');
+    expect(parseFn?.children?.every((c) => c.kind === 'parameter')).toBe(true);
+  });
+
+  it('omits children for external functions with type-only parameters', () => {
+    // Type-only params: parameter nodes exist in the tree but lack a `name` field,
+    // so extractParams returns an empty list and `children` is omitted.
+    const symbols = parseGleam(`pub external fn random(Int, String) -> Int = "rand" "uniform"`);
+    const randomFn = symbols.definitions.find((d) => d.name === 'random');
+    expect(randomFn).toBeDefined();
+    expect(randomFn?.children).toBeUndefined();
+  });
 });