WIP workspace state management, diagnostics

0101 · 0101 · commit d557b62f766f · 2024-02-22T19:23:29.000+01:00
diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj
@@ -77,8 +77,9 @@
     <InternalsVisibleTo Include="LanguageServiceProfiling" />
     <InternalsVisibleTo Include="FSharp.Compiler.Benchmarks" />
     <InternalsVisibleTo Include="HistoricalBenchmark" />
-	<InternalsVisibleTo Include="FSharp.Test.Utilities" />
-	<InternalsVisibleTo Include="FSharp.Editor" />
+    <InternalsVisibleTo Include="FSharp.Test.Utilities" />
+    <InternalsVisibleTo Include="FSharp.Editor" />
+    <InternalsVisibleTo Include="FSharp.Compiler.LanguageServer" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/Compiler/Facilities/Hashing.fs b/src/Compiler/Facilities/Hashing.fs
@@ -46,7 +46,11 @@ module internal Md5Hasher =
     let private md5 =
         new ThreadLocal<_>(fun () -> System.Security.Cryptography.MD5.Create())
 
-    let computeHash (bytes: byte array) = md5.Value.ComputeHash(bytes)
+    let computeHash (bytes: byte array) =
+        // md5.Value.ComputeHash(bytes) TODO: the threadlocal is not working in new VS extension
+        ignore md5
+        let md5 = System.Security.Cryptography.MD5.Create()
+        md5.ComputeHash(bytes)
 
     let empty = Array.empty
 
diff --git a/src/FSharp.Compiler.LanguageServer/FSharpLanguageServer.fs b/src/FSharp.Compiler.LanguageServer/FSharpLanguageServer.fs
@@ -1,5 +1,9 @@
 namespace FSharp.Compiler.LanguageServer
 
+open System.Runtime.CompilerServices
+
+#nowarn "57"
+
 open System
 open System.Threading.Tasks
 open System.Threading
@@ -20,29 +24,53 @@ module Stuff =
     [<Literal>]
     let FSharpLanguageName = "F#"
 
-type FSharpRequestContext(lspServices: ILspServices, logger: ILspLogger, workspace: FSharpWorkspace, checker) =
+[<Extension>]
+type Extensions =
+
+    [<Extension>]
+    static member Please(this: Async<'t>, ct) =
+        Async.StartAsTask(this, cancellationToken = ct)
+
+type FSharpRequestContext(lspServices: ILspServices, logger: ILspLogger, workspace: FSharpWorkspace, checker: FSharpChecker) =
     member _.LspServices = lspServices
     member _.Logger = logger
     member _.Workspace = workspace
     member _.Checker = checker
 
+    // TODO: split to parse and check diagnostics
+    member _.GetDiagnosticsForFile(file: Uri) =
+
+        workspace.GetSnapshotForFile file
+        |> Option.map (fun snapshot ->
+            async {
+                let! parseResult, checkFileAnswer = checker.ParseAndCheckFileInProject(file.LocalPath, snapshot, "LSP Get diagnostics")
+
+                return
+                    match checkFileAnswer with
+                    | FSharpCheckFileAnswer.Succeeded result -> result.Diagnostics
+                    | FSharpCheckFileAnswer.Aborted -> parseResult.Diagnostics
+            })
+        |> Option.defaultValue (async.Return [||])
+
 type ContextHolder(intialWorkspace, lspServices: ILspServices) =
 
     let logger = lspServices.GetRequiredService<ILspLogger>()
 
     // TODO: We need to get configuration for this somehow. Also make it replaceable when configuration changes.
     let checker =
         FSharpChecker.Create(
-            keepAllBackgroundResolutions=true,
-            keepAllBackgroundSymbolUses=true,
-            enableBackgroundItemKeyStoreAndSemanticClassification=true,
-            enablePartialTypeChecking=true,
-            parallelReferenceResolution=true,
-            captureIdentifiersWhenParsing=true,
-            useSyntaxTreeCache=true,
-            useTransparentCompiler=true)
+            keepAllBackgroundResolutions = true,
+            keepAllBackgroundSymbolUses = true,
+            enableBackgroundItemKeyStoreAndSemanticClassification = true,
+            enablePartialTypeChecking = true,
+            parallelReferenceResolution = true,
+            captureIdentifiersWhenParsing = true,
+            useSyntaxTreeCache = true,
+            useTransparentCompiler = true
+        )
 
-    let mutable context = FSharpRequestContext(lspServices, logger, intialWorkspace, checker)
+    let mutable context =
+        FSharpRequestContext(lspServices, logger, intialWorkspace, checker)
 
     member _.GetContext() = context
 
@@ -77,10 +105,7 @@ type DocumentStateHandler() =
             ) =
             let contextHolder = context.LspServices.GetRequiredService<ContextHolder>()
 
-            contextHolder.UpdateWorkspace(fun w ->
-                { w with
-                    OpenFiles = Map.add request.TextDocument.Uri.AbsolutePath request.TextDocument.Text w.OpenFiles
-                })
+            contextHolder.UpdateWorkspace _.OpenFile(request.TextDocument.Uri, request.TextDocument.Text)
 
             Task.FromResult(SemanticTokensDeltaPartialResult())
 
@@ -94,10 +119,7 @@ type DocumentStateHandler() =
             ) =
             let contextHolder = context.LspServices.GetRequiredService<ContextHolder>()
 
-            contextHolder.UpdateWorkspace(fun w ->
-                { w with
-                    OpenFiles = Map.add request.TextDocument.Uri.AbsolutePath request.ContentChanges.[0].Text w.OpenFiles
-                })
+            contextHolder.UpdateWorkspace _.ChangeFile(request.TextDocument.Uri, request.ContentChanges.[0].Text)
 
             Task.FromResult(SemanticTokensDeltaPartialResult())
 
@@ -111,10 +133,7 @@ type DocumentStateHandler() =
             ) =
             let contextHolder = context.LspServices.GetRequiredService<ContextHolder>()
 
-            contextHolder.UpdateWorkspace(fun w ->
-                { w with
-                    OpenFiles = Map.remove request.TextDocument.Uri.AbsolutePath w.OpenFiles
-                })
+            contextHolder.UpdateWorkspace _.CloseFile(request.TextDocument.Uri)
 
             Task.CompletedTask
 
diff --git a/src/FSharp.Compiler.LanguageServer/FSharpWorkspace.fs b/src/FSharp.Compiler.LanguageServer/FSharpWorkspace.fs
@@ -1,18 +1,134 @@
 module FSharp.Compiler.LanguageServer.Workspace
 
+open FSharp.Compiler.Text
+
 #nowarn "57"
 
 open System
+open System.Threading.Tasks
 open FSharp.Compiler.CodeAnalysis.ProjectSnapshot
 
-type FSharpWorkspace =
-    {
-        Projects: Map<FSharpProjectIdentifier, FSharpProjectSnapshot>
-        OpenFiles: Map<string, string>
-    }
+/// Holds a project snapshot and a queue of changes that will be applied to it when it's requested
+///
+/// The assumption is that this is faster than actually applying the changes to the snapshot immediately and that
+/// we will be doing this on potentially every keystroke. But this should probably be measured at some point.
+type SnapshotHolder(snapshot: FSharpProjectSnapshot, changedFiles: Set<string>, openFiles: Map<string, string>) =
+
+    let applyFileChangesToSnapshot () =
+        let files =
+            changedFiles
+            |> Seq.map (fun filePath ->
+                match openFiles.TryFind filePath with
+                | Some content ->
+                    FSharpFileSnapshot.Create(
+                        filePath,
+                        DateTime.Now.Ticks.ToString(),
+                        fun () -> content |> SourceTextNew.ofString |> Task.FromResult
+                    )
+                | None -> FSharpFileSnapshot.CreateFromFileSystem(filePath))
+            |> Seq.toList
+
+        snapshot.Replace files
+
+    // We don't want to mutate the workspace by applying the changes when snapshot is requested because that would force the language
+    // requests to be processed sequentially. So instead we keep the change application under lazy so it's still only computed if needed
+    // and only once and workspace doesn't change.
+    let appliedChanges =
+        lazy SnapshotHolder(applyFileChangesToSnapshot (), Set.empty, openFiles)
+
+    member private _.snapshot = snapshot
+    member private _.changedFiles = changedFiles
+
+    member private this.GetMostUpToDateInstance() =
+        if appliedChanges.IsValueCreated then
+            appliedChanges.Value
+        else
+            this
+
+    member this.WithFileChanged(file, openFiles) =
+        let previous = this.GetMostUpToDateInstance()
+        SnapshotHolder(previous.snapshot, previous.changedFiles.Add file, openFiles)
+
+    member this.WithoutFileChanged(file, openFiles) =
+        let previous = this.GetMostUpToDateInstance()
+        SnapshotHolder(previous.snapshot, previous.changedFiles.Remove file, openFiles)
+
+    member _.GetSnapshot() = appliedChanges.Value.snapshot
+
+    static member Of(snapshot: FSharpProjectSnapshot) =
+        SnapshotHolder(snapshot, Set.empty, Map.empty)
+
+type FSharpWorkspace
+    private
+    (
+        projects: Map<FSharpProjectIdentifier, SnapshotHolder>,
+        openFiles: Map<string, string>,
+        fileMap: Map<string, Set<FSharpProjectIdentifier>>
+    ) =
+
+    let updateProjectsWithFile (file: Uri) f (projects: Map<FSharpProjectIdentifier, SnapshotHolder>) =
+        fileMap
+        |> Map.tryFind file.LocalPath
+        |> Option.map (fun identifier ->
+            (projects, identifier)
+            ||> Seq.fold (fun projects identifier ->
+                let snapshotHolder = projects[identifier]
+                projects.Add(identifier, f snapshotHolder)))
+        |> Option.defaultValue projects
+
+    member _.Projects = projects
+    member _.OpenFiles = openFiles
+    member _.FileMap = fileMap
+
+    member this.OpenFile(file: Uri, content: string) = this.ChangeFile(file, content)
+
+    member _.CloseFile(file: Uri) =
+        let openFiles = openFiles.Remove(file.LocalPath)
+
+        FSharpWorkspace(
+            projects =
+                (projects
+                 |> updateProjectsWithFile file _.WithoutFileChanged(file.LocalPath, openFiles)),
+            openFiles = openFiles,
+            fileMap = fileMap
+        )
+
+    member _.ChangeFile(file: Uri, content: string) =
+
+        // TODO: should we assert that the file is open?
+
+        let openFiles = openFiles.Add(file.LocalPath, content)
+
+        FSharpWorkspace(
+            projects =
+                (projects
+                 |> updateProjectsWithFile file _.WithFileChanged(file.LocalPath, openFiles)),
+            openFiles = openFiles,
+            fileMap = fileMap
+        )
+
+    member _.GetSnapshotForFile(file: Uri) =
+        fileMap
+        |> Map.tryFind file.LocalPath
+
+        // TODO: eventually we need to deal with choosing the appropriate project here
+        // Hopefully we will be able to do it through receiving project context from LSP
+        // Otherwise we have to keep track of which project/configuration is active
+        |> Option.bind Seq.tryHead
+
+        |> Option.bind projects.TryFind
+        |> Option.map _.GetSnapshot()
 
     static member Create(projects: FSharpProjectSnapshot seq) =
-        {
-            Projects = Map.ofSeq (projects |> Seq.map (fun p -> p.Identifier, p))
-            OpenFiles = Map.empty
-        }
+        FSharpWorkspace(
+            projects = Map.ofSeq (projects |> Seq.map (fun p -> p.Identifier, SnapshotHolder.Of p)),
+            openFiles = Map.empty,
+            fileMap =
+                (projects
+                 |> Seq.collect (fun p ->
+                     p.ProjectSnapshot.SourceFileNames
+                     |> Seq.map (fun f -> Uri(f).LocalPath, p.Identifier))
+                 |> Seq.groupBy fst
+                 |> Seq.map (fun (f, ps) -> f, Set.ofSeq (ps |> Seq.map snd))
+                 |> Map.ofSeq)
+        )
diff --git a/src/FSharp.VisualStudio.Extension/FSharpLanguageServerProvider.cs b/src/FSharp.VisualStudio.Extension/FSharpLanguageServerProvider.cs
@@ -73,37 +73,41 @@ public ServerCapabilities OverrideServerCapabilities(ServerCapabilities value)
 }
 
 
-internal class VsDiagnosticsHandler 
+internal class VsDiagnosticsHandler
     : IRequestHandler<VSInternalDocumentDiagnosticsParams, VSInternalDiagnosticReport[], FSharpRequestContext>,
       IRequestHandler<VSGetProjectContextsParams, VSProjectContextList, FSharpRequestContext>
 {
     public bool MutatesSolutionState => false;
 
     [LanguageServerEndpoint(VSInternalMethods.DocumentPullDiagnosticName)]
-    public Task<VSInternalDiagnosticReport[]> HandleRequestAsync(VSInternalDocumentDiagnosticsParams request, FSharpRequestContext context, CancellationToken cancellationToken)
+    public async Task<VSInternalDiagnosticReport[]> HandleRequestAsync(VSInternalDocumentDiagnosticsParams request, FSharpRequestContext context, CancellationToken cancellationToken)
     {
-       var rep = new VSInternalDiagnosticReport
+        var result = await context.GetDiagnosticsForFile(request!.TextDocument!.Uri).Please(cancellationToken);
+
+        var rep = new VSInternalDiagnosticReport
         {
             ResultId = "potato1", // Has to be present for diagnostic to show up
             //Identifier = 69,
             //Version = 1,
             Diagnostics =
-            [
-                new Diagnostic
-                {
-                    Range = new Microsoft.VisualStudio.LanguageServer.Protocol.Range
-                    {
-                        Start = new Position { Line = 0, Character = 0 },
-                        End = new Position { Line = 0, Character = 1 }
-                    },
-                    Severity = DiagnosticSeverity.Error,
-                    Message = "This is a test diagnostic",
-                    //Source = "Intellisense",
-                    Code = "1234"
-                }
-            ]
+                 result.Select(d =>
+
+                 new Diagnostic
+                 {
+                     Range = new Microsoft.VisualStudio.LanguageServer.Protocol.Range
+                     {
+                         Start = new Position { Line = d.StartLine, Character = d.StartColumn },
+                         End = new Position { Line = d.EndLine, Character = d.EndColumn }
+                     },
+                     Severity = DiagnosticSeverity.Error,
+                     Message = $"LSP: {d.Message}",
+                     //Source = "Intellisense",
+                     Code = d.ErrorNumberText
+                 }
+             ).ToArray()
         };
-        return Task.FromResult(new[] { rep });
+
+        return [rep];
     }
 
     [LanguageServerEndpoint("textDocument/_vs_getProjectContexts")]
@@ -116,6 +120,7 @@ public Task<VSProjectContextList> HandleRequestAsync(VSGetProjectContextsParams
                 new() {
                     Id = "potato",
                     Label = "Potato",
+                    // PR for F# project kind: https://devdiv.visualstudio.com/DevDiv/_git/VSLanguageServerClient/pullrequest/529882
                     Kind = VSProjectKind.VisualBasic
                 },
                 new () {
@@ -174,7 +179,7 @@ internal class FSharpLanguageServerProvider : LanguageServerProvider
         try
         {
             // Some hardcoded projects before we create them from the ProjectQuery
-            var projectsRoot = @"D:\code\FS";
+            var projectsRoot = @"D:\code";
             var giraffe = FSharpProjectSnapshot.FromResponseFile(
                 new FileInfo(Path.Combine(projectsRoot, @"Giraffe\src\Giraffe\Giraffe.rsp")),
                 Path.Combine(projectsRoot, @"Giraffe\src\Giraffe\Giraffe.fsproj"));
