Add local-variable hover types and 0.28.0 changelog

Author: pchalamet

.gitignore

@@ -14,6 +14,7 @@ obj/
 .vs/
 .vscode/*
 !.vscode/launch.json
+!.vscode/tasks.json
 vscode-fscript/node_modules/
 
 # Rider

.vscode/launch.json

@@ -11,7 +11,8 @@
       ],
       "outFiles": [
         "${workspaceFolder}/vscode-fscript/**/*.js"
-      ]
+      ],
+      "preLaunchTask": "fscript: compile extension"
     }
   ]
 }

.vscode/tasks.json

@@ -0,0 +1,14 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "fscript: compile extension",
+      "type": "shell",
+      "command": "npm run compile",
+      "options": {
+        "cwd": "${workspaceFolder}/vscode-fscript"
+      },
+      "problemMatcher": []
+    }
+  ]
+}

CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to FScript are documented in this file.
 
+## [0.28.0]
+
+- Added local variable type hover in LSP.
+- Added local variable type capture in type inference.
+- Added VS Code extension auto-compile for development startup.
+
 ## [0.27.0]
 
 - Added structural update syntax support with `with` inside structural literals: `{| base with Field = value |}`.

src/FScript.Language/TypeInfer.fs

@@ -355,24 +355,33 @@ module LspHandlers =
                 result["contents"] <- contents
                 LspProtocol.sendResponse idNode (Some result)
             | None ->
-                match tryResolveSymbol doc line character with
-                | Some sym ->
-                    let signature =
-                        match sym.TypeText with
-                        | Some t -> $"{sym.Name} : {t}"
-                        | None -> sym.Name
-
+                match tryGetLocalVariableHoverInfo doc line character with
+                | Some (name, typeText) ->
                     let contents = JsonObject()
                     contents["kind"] <- JsonValue.Create("markdown")
-                    let kindLine = symbolKindLabel sym.Kind
-                    let locationLine = $"defined at L{sym.Span.Start.Line}:C{sym.Span.Start.Column}"
-                    contents["value"] <- JsonValue.Create($"```fscript\n{signature}\n```\n{kindLine}\n\n{locationLine}")
-
+                    contents["value"] <- JsonValue.Create($"```fscript\n{name} : {typeText}\n```\nlocal-variable")
                     let result = JsonObject()
                     result["contents"] <- contents
                     LspProtocol.sendResponse idNode (Some result)
                 | None ->
-                    LspProtocol.sendResponse idNode None
+                    match tryResolveSymbol doc line character with
+                    | Some sym ->
+                        let signature =
+                            match sym.TypeText with
+                            | Some t -> $"{sym.Name} : {t}"
+                            | None -> sym.Name
+
+                        let contents = JsonObject()
+                        contents["kind"] <- JsonValue.Create("markdown")
+                        let kindLine = symbolKindLabel sym.Kind
+                        let locationLine = $"defined at L{sym.Span.Start.Line}:C{sym.Span.Start.Column}"
+                        contents["value"] <- JsonValue.Create($"```fscript\n{signature}\n```\n{kindLine}\n\n{locationLine}")
+
+                        let result = JsonObject()
+                        result["contents"] <- contents
+                        LspProtocol.sendResponse idNode (Some result)
+                    | None ->
+                        LspProtocol.sendResponse idNode None
         | _ -> LspProtocol.sendResponse idNode None
 
 

src/FScript.LanguageServer/LspHandlers.fs

@@ -57,6 +57,7 @@ module LspModel =
           ParameterTypeTargets: Map<string, string>
           FunctionParameters: Map<string, string list>
           ParameterTypeHints: (Span * string) list
+          LocalVariableTypeHints: (Span * string * string) list
           // Variable occurrences keyed by identifier, sourced from AST spans.
           // This avoids text-based false positives (for example record field labels).
           VariableOccurrences: Map<string, Span list> }

src/FScript.LanguageServer/LspModel.fs

@@ -459,6 +459,7 @@ module LspSymbols =
         let mutable parameterTypeTargets : Map<string, string> = Map.empty
         let mutable functionParameters : Map<string, string list> = Map.empty
         let mutable parameterTypeHints : (Span * string) list = []
+        let mutable localVariableTypeHints : (Span * string * string) list = []
 
         let mutable parsedProgram : Program option = None
 
@@ -474,9 +475,16 @@ module LspSymbols =
                 parameterTypeHints <- buildParameterTypeHints program None
             else
                 try
-                    let typed = TypeInfer.inferProgram program
+                    let typed, localTypes = TypeInfer.inferProgramWithLocalVariableTypes program
                     symbols <- buildSymbolsFromProgram program (Some typed)
                     parameterTypeHints <- buildParameterTypeHints program (Some typed)
+                    localVariableTypeHints <-
+                        localTypes
+                        |> List.filter (fun entry ->
+                            match entry.Span.Start.File with
+                            | Some file -> String.Equals(file, sourceName, StringComparison.OrdinalIgnoreCase)
+                            | None -> true)
+                        |> List.map (fun entry -> entry.Span, entry.Name, Types.typeToString entry.Type)
                 with
                 | TypeException err ->
                     diagnostics.Add(diagnostic 1 "type" err.Span err.Message)
@@ -504,7 +512,7 @@ module LspSymbols =
                         diagnostics.Add(diagnostic 2 "unused" span $"Unused top-level binding '{name}'")
         | None -> ()
 
-        documents[uri] <- { Text = text; Symbols = symbols; RecordParameterFields = recordParamFields; ParameterTypeTargets = parameterTypeTargets; FunctionParameters = functionParameters; ParameterTypeHints = parameterTypeHints; VariableOccurrences = occurrences }
+        documents[uri] <- { Text = text; Symbols = symbols; RecordParameterFields = recordParamFields; ParameterTypeTargets = parameterTypeTargets; FunctionParameters = functionParameters; ParameterTypeHints = parameterTypeHints; LocalVariableTypeHints = localVariableTypeHints; VariableOccurrences = occurrences }
         publishDiagnostics uri (diagnostics |> Seq.toList)
 
     let tryResolveSymbol (doc: DocumentState) (line: int) (character: int) : TopLevelSymbol option =
@@ -821,6 +829,22 @@ module LspSymbols =
         | _ ->
             None
 
+    let private spanContainsPosition (span: Span) (line: int) (character: int) =
+        let line1 = line + 1
+        let col1 = character + 1
+        let startsBefore =
+            line1 > span.Start.Line
+            || (line1 = span.Start.Line && col1 >= span.Start.Column)
+        let endsAfter =
+            line1 < span.End.Line
+            || (line1 = span.End.Line && col1 <= span.End.Column)
+        startsBefore && endsAfter
+
+    let tryGetLocalVariableHoverInfo (doc: DocumentState) (line: int) (character: int) : (string * string) option =
+        doc.LocalVariableTypeHints
+        |> List.tryFind (fun (span, _, _) -> spanContainsPosition span line character)
+        |> Option.map (fun (_, name, typeText) -> name, typeText)
+
     let private tryMemberCompletionItems (doc: DocumentState) (prefix: string option) =
         match prefix with
         | Some p when p.Contains('.') ->

src/FScript.LanguageServer/LspSymbols.fs

@@ -2616,6 +2616,80 @@ type LspServerTests () =
             try shutdown client with _ -> ()
             LspClient.stop client
 
+    [<Test>]
+    member _.``Hover returns inferred type for local lambda variables`` () =
+        let client = LspClient.start ()
+        try
+            initialize client
+
+            let uri = "file:///tmp/hover-local-variables-test.fss"
+            let source =
+                "let rec fib n = if n < 2 then n else fib (n - 1) + fib (n - 2)\n"
+                + "let values =\n"
+                + "    [0..9]\n"
+                + "    |> List.map (fun i ->\n"
+                + "        i |> fib |> fun x ->\n"
+                + "            $\"{x}\")\n"
+
+            let td = JsonObject()
+            td["uri"] <- JsonValue.Create(uri)
+            td["languageId"] <- JsonValue.Create("fscript")
+            td["version"] <- JsonValue.Create(1)
+            td["text"] <- JsonValue.Create(source)
+
+            let didOpenParams = JsonObject()
+            didOpenParams["textDocument"] <- td
+            LspClient.sendNotification client "textDocument/didOpen" (Some didOpenParams)
+
+            LspClient.readUntil client 10000 (fun msg ->
+                match msg["method"] with
+                | :? JsonValue as mv ->
+                    try mv.GetValue<string>() = "textDocument/publishDiagnostics" with _ -> false
+                | _ -> false)
+            |> ignore
+
+            let requestHover (requestId: int) (line: int) (character: int) =
+                let hoverParams = JsonObject()
+                let textDocument = JsonObject()
+                textDocument["uri"] <- JsonValue.Create(uri)
+                let position = JsonObject()
+                position["line"] <- JsonValue.Create(line)
+                position["character"] <- JsonValue.Create(character)
+                hoverParams["textDocument"] <- textDocument
+                hoverParams["position"] <- position
+                LspClient.sendRequest client requestId "textDocument/hover" (Some hoverParams)
+                LspClient.readUntil client 10000 (fun msg ->
+                    match msg["id"] with
+                    | :? JsonValue as idv ->
+                        try idv.GetValue<int>() = requestId with _ -> false
+                    | _ -> false)
+
+            let hoverText (resp: JsonNode) =
+                match resp["result"] with
+                | :? JsonObject as result ->
+                    match result["contents"] with
+                    | :? JsonObject as contents ->
+                        match contents["value"] with
+                        | :? JsonValue as value -> value.GetValue<string>()
+                        | _ -> ""
+                    | _ -> ""
+                | _ -> ""
+
+            let hasLocalHoverType (text: string) (name: string) (typeText: string) =
+                text.Contains($"{name} : {typeText}", StringComparison.Ordinal)
+                && text.Contains("local-variable", StringComparison.Ordinal)
+
+            let hoverI = requestHover 41 3 21
+            let hoverX = requestHover 42 4 24
+            let hoverIText = hoverText hoverI
+            let hoverXText = hoverText hoverX
+
+            Assert.That(hasLocalHoverType hoverIText "i" "int", Is.True, $"Unexpected hover for i: {hoverIText}")
+            Assert.That(hasLocalHoverType hoverXText "x" "int", Is.True, $"Unexpected hover for x: {hoverXText}")
+        finally
+            try shutdown client with _ -> ()
+            LspClient.stop client
+
     [<Test>]
     member _.``Rename returns workspace edit for all symbol occurrences`` () =
         let client = LspClient.start ()

tests/FScript.LanguageServer.Tests/LspServerTests.fs

@@ -92,7 +92,8 @@
     "lint": "echo \"No lint configured\"",
     "compile": "esbuild extension.js --bundle --platform=node --format=cjs --target=node20 --outfile=dist/extension.js --external:vscode",
     "vscode:prepublish": "npm run compile",
-    "package": "vsce package"
+    "package": "vsce package",
+    "postinstall": "npm run compile"
   },
   "dependencies": {
     "vscode-languageclient": "^9.0.1"