chore(fsharp): align npm grammar with cargo at v0.3.0

The WASM engine pulled tree-sitter-fsharp 0.1.0 from npm while the native
engine used 0.3.0 from crates.io. The two versions diverged in how they
parse type signatures in .fsi files: 0.1.0 emits `function_type` nodes
for `a -> b` types, while 0.3.0 wraps every signature in `curried_spec`
with `arguments_spec` children for function shapes.

The F# extractor was forced to detect both shapes simultaneously, which
is fragile — future grammar churn could silently desync further.

* package.json now installs tree-sitter-fsharp from the ionide v0.3.0
  GitHub tarball (npm has no 0.3.0 release; ionide is the upstream the
  cargo crate also tracks). Lockfile pins via SRI hash.
* Both extractors now check only `curried_spec` → `arguments_spec`,
  removing the dead `function_type` branch from each.

docs check acknowledged: README's F# row already covers .fs/.fsx/.fsi and
the user-facing language count is unchanged; the grammar version is an
internal implementation detail.

Closes #1161

Author: carlos-alm

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

@@ -355,31 +355,15 @@ fn extract_value_name(decl_left: &Node, source: &[u8]) -> Option<String> {
 }
 
 fn has_function_type(node: &Node) -> bool {
-    // The two grammar versions use different node shapes for type signatures:
-    //
-    //   • WASM (tree-sitter-fsharp npm 0.1.0): `function_type` is the explicit
-    //     function-type kind, only present for `a -> b` types.
-    //   • Native (tree-sitter-fsharp 0.3.0): every type signature is wrapped
-    //     in `curried_spec`. For a function it contains `arguments_spec`
-    //     children; for a plain value (e.g. `val pi : float`) it wraps a
-    //     single `simple_type`.
-    //
-    // Treat both engines consistently by classifying as a function whenever
-    // a function_type node appears OR a curried_spec contains `arguments_spec`.
-    for i in 0..node.child_count() {
-        let Some(child) = node.child(i) else { continue };
-        match child.kind() {
-            "function_type" => return true,
-            "curried_spec" => {
-                for j in 0..child.child_count() {
-                    if let Some(g) = child.child(j) {
-                        if g.kind() == "arguments_spec" {
-                            return true;
-                        }
-                    }
-                }
+    // 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`.
+    let Some(curried) = find_child(node, "curried_spec") else { return false };
+    for i in 0..curried.child_count() {
+        if let Some(child) = curried.child(i) {
+            if child.kind() == "arguments_spec" {
+                return true;
             }
-            _ => {}
         }
     }
     false

package-lock.json

@@ -162,7 +162,7 @@
     "tree-sitter-dart": "^1.0.0",
     "tree-sitter-elixir": "^0.3.5",
     "tree-sitter-erlang": "github:WhatsApp/tree-sitter-erlang#semver:*",
-    "tree-sitter-fsharp": "^0.1.0",
+    "tree-sitter-fsharp": "https://github.com/ionide/tree-sitter-fsharp/archive/refs/tags/0.3.0.tar.gz",
     "tree-sitter-gleam": "github:gleam-lang/tree-sitter-gleam",
     "tree-sitter-go": "^0.25.0",
     "tree-sitter-groovy": "^0.1.2",

package.json

@@ -280,31 +280,17 @@ function handleValueDefinition(
     findChild(pattern, 'identifier');
   if (!ident) return;
 
-  // The two grammar versions use different shapes for type signatures:
-  //   • WASM (npm tree-sitter-fsharp 0.1.0): `function_type` is the explicit
-  //     function-type kind, only present for `a -> b` types.
-  //   • Native (cargo tree-sitter-fsharp 0.3.0): every type signature is
-  //     wrapped in `curried_spec`. For a function it contains `arguments_spec`
-  //     children; for a plain value (e.g. `val pi : float`) it wraps a single
-  //     `simple_type`.
-  // Treat both engines consistently by classifying as a function whenever
-  // function_type appears OR a curried_spec contains an arguments_spec child.
+  // 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');
   let hasFunctionType = false;
-  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 (curriedSpec) {
+    for (let i = 0; i < curriedSpec.childCount; i++) {
+      if (curriedSpec.child(i)?.type === 'arguments_spec') {
+        hasFunctionType = true;
+        break;
       }
-      if (hasFunctionType) break;
     }
   }