fix(fsharp): restore dual function_type/curried_spec detection for val (#1162)

The npm and cargo tree-sitter-fsharp 0.3.0 grammars — though sharing a
version tag — still emit type signatures with different node shapes:
WASM 0.3.0 produces `function_type` directly under `value_definition`,
while cargo 0.3.0 wraps every signature in `curried_spec` with
`arguments_spec` children for function types.

#1165 removed the `function_type` branch on the assumption that both
grammars had converged at v0.3.0, which broke WASM extraction: every
`val name : a -> b` declaration was being indexed as a `variable`
instead of a `function`. Restore the dual-shape detection in the
TypeScript extractor and update the documentation accordingly.

Also clarifies the nested-module test comment in fsharp-signature.test
to reflect that the WASM signature grammar is now at v0.3.0 but still
emits ERROR nodes for `module Foo = ...` (the fix is still pending,
tracked under #1161).

Author: carlos-alm

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

@@ -36,9 +36,9 @@ fn match_fsharp_node(node: &Node, source: &[u8], symbols: &mut FileSymbols, _dep
 ///
 /// Source files use `named_module` for the top-level `module M = …` and
 /// the signature grammar (cargo 0.3.0) wraps nested signature modules in
-/// `module_defn` nodes. WASM signature grammar (npm 0.1.0) currently
-/// produces ERROR nodes for nested signature modules so we cannot recover
-/// qualification there — tracked under #1161.
+/// `module_defn` nodes. The WASM signature grammar currently emits ERROR
+/// nodes for nested signature modules so we cannot recover qualification
+/// there — tracked under #1161.
 fn enclosing_module_name(node: &Node, source: &[u8]) -> Option<String> {
     let mut parts: Vec<String> = Vec::new();
     let mut current = node.parent();

src/extractors/fsharp.ts

@@ -317,17 +317,34 @@ function handleValueDefinition(
     findChild(pattern, 'identifier');
   if (!ident) return;
 
-  // The grammar wraps every type signature in `curried_spec`. A function type
-  // (e.g. `val add : int -> int -> int`) contains one or more `arguments_spec`
-  // children; a plain value (e.g. `val pi : float`) wraps a single `simple_type`.
-  const curriedSpec = findChild(node, 'curried_spec');
+  // The npm and cargo tree-sitter-fsharp 0.3.0 grammars — though sharing a
+  // version tag — emit type signatures with different node shapes:
+  //   • WASM (npm 0.3.0 ionide tarball): `function_type` is the explicit
+  //     function-type kind, present as a direct child of `value_definition`
+  //     for `a -> b` types; plain values (e.g. `val pi : float`) appear as
+  //     `simple_type`.
+  //   • Native (cargo 0.3.0): every type signature is wrapped in
+  //     `curried_spec`. A function type contains one or more `arguments_spec`
+  //     children; a plain value wraps a single `simple_type`.
+  // Classify as a function whenever `function_type` appears OR a
+  // `curried_spec` contains an `arguments_spec` child, so both engines stay
+  // in parity until the grammars converge.
   let hasFunctionType = false;
-  if (curriedSpec) {
-    for (let i = 0; i < curriedSpec.childCount; i++) {
-      if (curriedSpec.child(i)?.type === 'arguments_spec') {
-        hasFunctionType = true;
-        break;
+  for (let i = 0; i < node.childCount; i++) {
+    const c = node.child(i);
+    if (!c) continue;
+    if (c.type === 'function_type') {
+      hasFunctionType = true;
+      break;
+    }
+    if (c.type === 'curried_spec') {
+      for (let j = 0; j < c.childCount; j++) {
+        if (c.child(j)?.type === 'arguments_spec') {
+          hasFunctionType = true;
+          break;
+        }
       }
+      if (hasFunctionType) break;
     }
   }
 

tests/parsers/fsharp-signature.test.ts

@@ -42,13 +42,14 @@ describe('F# signature (.fsi) parser', () => {
   });
 
   it('extracts val declarations nested inside a module signature', () => {
-    // The WASM tree-sitter-fsharp 0.1.0 signature grammar does NOT produce a
-    // `module_defn` for `module Foo = ...` — it emits ERROR nodes and the
-    // `val` declarations float to the top level (so they're indexed as
-    // `add`, not `Foo.add`). The cargo 0.3.0 grammar parses it correctly
-    // and the Rust extractor qualifies as `Foo.add`. Grammar version skew
-    // is tracked under #1161; once npm bumps to 0.3.0+ this test should
-    // assert `Foo.add` to match the native engine.
+    // The WASM tree-sitter-fsharp signature grammar (currently v0.3.0) does
+    // NOT yet produce a `module_defn` for `module Foo = ...` — it emits
+    // ERROR nodes and the `val` declarations float to the top level (so
+    // they're indexed as `add`, not `Foo.add`). The cargo 0.3.0 grammar
+    // parses it correctly and the Rust extractor qualifies as `Foo.add`.
+    // The WASM grammar fix is tracked under #1161; once the signature
+    // grammar emits `module_defn` for nested modules, this assertion
+    // should be updated to expect `Foo.add` to match the native engine.
     const { symbols } = parseFSi(`module Foo =\n  val add : int -> int\n`);
     expect(symbols.definitions).toContainEqual(
       expect.objectContaining({ name: 'add', kind: 'function' }),