Fix alias-qualified go-to-definition in LSP

Author: pchalamet

CHANGELOG.md

@@ -4,6 +4,8 @@ All notable changes to FScript are documented in this file.
 
 ## [Unreleased]
 
+- Fixed LSP go-to-definition for alias-qualified function calls (for example `Helpers.append_part`).
+
 ## [0.35.0]
 
 - Fixed LSP completion insertion for dotted prefixes so selecting `Option.map` after `Option.` no longer duplicates the qualifier.

src/FScript.CSharpInterop/LanguageServer/LspHandlers.fs

@@ -762,18 +762,23 @@ module LspHandlers =
         | Some uri, Some (line, character) when documents.ContainsKey(uri) ->
             let doc = documents[uri]
             let targetTypeName =
-                match tryResolveSymbol doc line character with
-                | Some sym ->
-                    match sym.TypeTargetName with
-                    | Some name -> Some name
+                let fromSymbol =
+                    match tryResolveSymbol doc line character with
+                    | Some sym ->
+                        match sym.TypeTargetName with
+                        | Some name -> Some name
+                        | None ->
+                            sym.TypeText
+                            |> Option.bind (fun t ->
+                                doc.Symbols
+                                |> List.tryFind (fun s -> s.Kind = 5 && s.Name = t)
+                                |> Option.map (fun s -> s.Name))
                     | None ->
-                        sym.TypeText
-                        |> Option.bind (fun t ->
-                            doc.Symbols
-                            |> List.tryFind (fun s -> s.Kind = 5 && s.Name = t)
-                            |> Option.map (fun s -> s.Name))
-                | None ->
-                    tryResolveTypeTargetAtPosition doc line character
+                        None
+
+                match fromSymbol with
+                | Some _ -> fromSymbol
+                | None -> tryResolveTypeTargetAtPosition doc line character
 
             match targetTypeName with
             | Some typeName ->

src/FScript.CSharpInterop/LanguageServer/LspSymbols.fs

@@ -1644,8 +1644,19 @@ module LspSymbols =
         | Some word ->
             let candidates =
                 if word.Contains('.') then
-                    let segments = word.Split('.') |> Array.toList
-                    word :: segments
+                    let parts = word.Split('.') |> Array.toList
+                    let mapped =
+                        match parts with
+                        | qualifier :: memberName :: [] ->
+                            match doc.ImportAliasToInternal |> Map.tryFind qualifier with
+                            | Some internalPrefix ->
+                                [ $"{internalPrefix}.{memberName}"; internalPrefix ]
+                            | None ->
+                                []
+                        | _ ->
+                            []
+
+                    (word :: parts) @ mapped
                 else
                     [ word ]
                 |> List.distinct

tests/FScript.LanguageServer.Tests/CSharpServerCoreTests.cs

@@ -471,6 +471,72 @@ [<export>] let summary (project: Common.ProjectInfo) =
         }
     }
 
+    [Test]
+    public void CSharp_server_navigates_alias_qualified_function_calls()
+    {
+        var client = LspClient.StartCSharp();
+        var tempDir = Path.Combine(Path.GetTempPath(), $"fscript-lsp-alias-functions-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(tempDir);
+        try
+        {
+            LspTestFixture.Initialize(client);
+
+            var helpersPath = Path.Combine(tempDir, "_helpers.fss");
+            var mainPath = Path.Combine(tempDir, "main.fss");
+            File.WriteAllText(helpersPath, """
+let append_part part acc =
+    if part = "" then acc else $"{acc} {part}"
+""");
+
+            var source = """
+import "_helpers.fss" as Helpers
+
+let append_build_arg acc key value =
+    Helpers.append_part $"--build-arg {key}=\"{value}\"" acc
+""";
+            File.WriteAllText(mainPath, source);
+
+            var mainUri = new Uri(mainPath).AbsoluteUri;
+            var helpersUri = new Uri(helpersPath).AbsoluteUri;
+
+            var didOpenParams = new JsonObject
+            {
+                ["textDocument"] = new JsonObject
+                {
+                    ["uri"] = mainUri,
+                    ["languageId"] = "fscript",
+                    ["version"] = 1,
+                    ["text"] = source
+                }
+            };
+            LspClient.SendNotification(client, "textDocument/didOpen", didOpenParams);
+            _ = LspClient.ReadUntil(client, 10_000, msg => msg["method"]?.GetValue<string>() == "textDocument/publishDiagnostics");
+
+            var definitionParams = new JsonObject
+            {
+                ["textDocument"] = new JsonObject { ["uri"] = mainUri },
+                ["position"] = new JsonObject { ["line"] = 3, ["character"] = 17 }
+            };
+            LspClient.SendRequest(client, 84, "textDocument/definition", definitionParams);
+            var definitionResponse = LspClient.ReadUntil(client, 10_000, msg => msg["id"] is JsonValue idv && idv.TryGetValue<int>(out var id) && id == 84);
+
+            var result = definitionResponse["result"] as JsonObject ?? throw new Exception("Expected definition location.");
+            Assert.That(result["uri"]?.GetValue<string>(), Is.EqualTo(helpersUri));
+            var range = result["range"] as JsonObject ?? throw new Exception("Expected range.");
+            var start = range["start"] as JsonObject ?? throw new Exception("Expected start range.");
+            Assert.That(start["line"]?.GetValue<int>(), Is.EqualTo(0));
+        }
+        finally
+        {
+            try { LspTestFixture.Shutdown(client); } catch { }
+            LspClient.Stop(client);
+            if (Directory.Exists(tempDir))
+            {
+                Directory.Delete(tempDir, true);
+            }
+        }
+    }
+
     private static string FindRepoRoot()
     {
         var current = new DirectoryInfo(AppContext.BaseDirectory);