FSharpWorkspace prototype

src/Compiler/Facilities/AsyncMemoize.fs

@@ -89,6 +89,7 @@ type internal JobEvent =
     | Cleared
 
 type internal ICacheKey<'TKey, 'TVersion> =
+    // TODO Key should probably be renamed to Identifier
     abstract member GetKey: unit -> 'TKey
     abstract member GetVersion: unit -> 'TVersion
     abstract member GetLabel: unit -> string

src/Compiler/Service/TransparentCompiler.fs

@@ -298,7 +298,7 @@ type internal CompilerCaches(sizeFactor: int) =
 
     member val ScriptClosure = AsyncMemoize(sf, 2 * sf, name = "ScriptClosure")
 
-    member this.Clear(projects: Set<ProjectIdentifier>) =
+    member this.Clear(projects: Set<FSharpProjectIdentifier>) =
         let shouldClear project = projects |> Set.contains project
 
         this.ParseFile.Clear(fst >> shouldClear)
@@ -422,11 +422,11 @@ type internal TransparentCompiler
         (useFsiAuxLib: bool)
         (useSdkRefs: bool)
         (assumeDotNetFramework: bool)
-        (projectIdentifier: ProjectIdentifier)
+        (projectIdentifier: FSharpProjectIdentifier)
         (otherOptions: string list)
         (stamp: int64 option)
         =
-        { new ICacheKey<string * ProjectIdentifier, string> with
+        { new ICacheKey<string * FSharpProjectIdentifier, string> with
             member _.GetKey() = fileName, projectIdentifier
             member _.GetLabel() = $"ScriptClosure for %s{fileName}"
 
@@ -456,15 +456,15 @@ type internal TransparentCompiler
         (useSdkRefs: bool option)
         (sdkDirOverride: string option)
         (assumeDotNetFramework: bool option)
-        (projectIdentifier: ProjectIdentifier)
+        (projectIdentifier: FSharpProjectIdentifier)
         (otherOptions: string list)
         (stamp: int64 option)
         =
         let useFsiAuxLib = defaultArg useFsiAuxLib true
         let useSdkRefs = defaultArg useSdkRefs true
         let assumeDotNetFramework = defaultArg assumeDotNetFramework false
 
-        let key: ICacheKey<string * ProjectIdentifier, string> =
+        let key =
             mkScriptClosureCacheKey
                 fileName
                 source
@@ -826,8 +826,8 @@ type internal TransparentCompiler
     let mutable BootstrapInfoIdCounter = 0
 
     /// Bootstrap info that does not depend source files
-    let ComputeBootstrapInfoStatic (projectSnapshot: ProjectCore, tcConfig: TcConfig, assemblyName: string, loadClosureOpt) =
-        let cacheKey = projectSnapshot.CacheKeyWith("BootstrapInfoStatic", assemblyName)
+    let ComputeBootstrapInfoStatic (projectSnapshot: ProjectSnapshotBase<_>, tcConfig: TcConfig, assemblyName: string, loadClosureOpt) =
+        let cacheKey = projectSnapshot.BaseCacheKeyWith("BootstrapInfoStatic", assemblyName)
 
         caches.BootstrapInfoStatic.Get(
             cacheKey,
@@ -957,7 +957,7 @@ type internal TransparentCompiler
             let outFile, _, assemblyName = tcConfigB.DecideNames sourceFiles
 
             let! bootstrapId, tcImports, tcGlobals, initialTcInfo, importsInvalidatedByTypeProvider =
-                ComputeBootstrapInfoStatic(projectSnapshot.ProjectCore, tcConfig, assemblyName, loadClosureOpt)
+                ComputeBootstrapInfoStatic(projectSnapshot, tcConfig, assemblyName, loadClosureOpt)
 
             // Check for the existence of loaded sources and prepend them to the sources list if present.
             let loadedSources =
@@ -1056,7 +1056,7 @@ type internal TransparentCompiler
                 |> Seq.map (fun f -> LoadSource f isExe (f.FileName = bootstrapInfo.LastFileName))
                 |> MultipleDiagnosticsLoggers.Parallel
 
-            return ProjectSnapshotWithSources(projectSnapshot.ProjectCore, sources |> Array.toList)
+            return ProjectSnapshotWithSources(projectSnapshot.ProjectConfig, projectSnapshot.ReferencedProjects, sources |> Array.toList)
 
         }
 
@@ -1067,7 +1067,7 @@ type internal TransparentCompiler
                 member _.GetLabel() = file.FileName |> shortPath
 
                 member _.GetKey() =
-                    projectSnapshot.ProjectCore.Identifier, file.FileName
+                    projectSnapshot.ProjectConfig.Identifier, file.FileName
 
                 member _.GetVersion() =
                     projectSnapshot.ParsingVersion,
@@ -1467,7 +1467,7 @@ type internal TransparentCompiler
                 |> Seq.map (ComputeParseFile projectSnapshot tcConfig)
                 |> MultipleDiagnosticsLoggers.Parallel
 
-            return ProjectSnapshotBase<_>(projectSnapshot.ProjectCore, parsedInputs |> Array.toList)
+            return ProjectSnapshotBase<_>(projectSnapshot.ProjectConfig, projectSnapshot.ReferencedProjects, parsedInputs |> Array.toList)
         }
 
     // Type check file and all its dependencies
@@ -2137,19 +2137,19 @@ type internal TransparentCompiler
             use _ =
                 Activity.start "TransparentCompiler.ClearCache" [| Activity.Tags.userOpName, userOpName |]
 
-            this.Caches.Clear(
-                projects
-                |> Seq.map (function
-                    | FSharpProjectIdentifier(x, y) -> (x, y))
-                |> Set
-            )
+            this.Caches.Clear(Set projects)
 
         member this.ClearCache(options: seq<FSharpProjectOptions>, userOpName: string) : unit =
             use _ =
                 Activity.start "TransparentCompiler.ClearCache" [| Activity.Tags.userOpName, userOpName |]
 
             backgroundCompiler.ClearCache(options, userOpName)
-            this.Caches.Clear(options |> Seq.map (fun o -> o.GetProjectIdentifier()) |> Set)
+
+            this.Caches.Clear(
+                options
+                |> Seq.map (fun o -> o.GetProjectIdentifier() |> FSharpProjectIdentifier)
+                |> Set
+            )
 
         member _.ClearCaches() : unit =
             backgroundCompiler.ClearCaches()
@@ -2365,7 +2365,7 @@ type internal TransparentCompiler
                         useFsiAuxLib
                         useSdkRefs
                         assumeDotNetFramework
-                        (projectFileName, "")
+                        (FSharpProjectIdentifier(projectFileName, ""))
                         otherFlags
                         optionsStamp
 
@@ -2394,6 +2394,7 @@ type internal TransparentCompiler
                     FSharpProjectSnapshot.Create(
                         fileName + ".fsproj",
                         None,
+                        None,
                         sourceFiles,
                         references,
                         otherFlags,
@@ -2445,10 +2446,7 @@ type internal TransparentCompiler
             backgroundCompiler.InvalidateConfiguration(options, userOpName)
 
         member this.InvalidateConfiguration(projectSnapshot: FSharpProjectSnapshot, _userOpName: string) : unit =
-            let (FSharpProjectIdentifier(projectFileName, outputFileName)) =
-                projectSnapshot.Identifier
-
-            this.Caches.Clear(Set.singleton (ProjectIdentifier(projectFileName, outputFileName)))
+            this.Caches.Clear(Set.singleton projectSnapshot.Identifier)
 
         member this.NotifyFileChanged(fileName: string, options: FSharpProjectOptions, userOpName: string) : Async<unit> =
             backgroundCompiler.NotifyFileChanged(fileName, options, userOpName)

src/Compiler/Service/TransparentCompiler.fsi

@@ -21,6 +21,7 @@ open FSharp.Compiler.NameResolution
 open FSharp.Compiler.TypedTree
 open FSharp.Compiler.CheckDeclarations
 open FSharp.Compiler.EditorServices
+open FSharp.Compiler.CodeAnalysis.ProjectSnapshot
 
 /// Accumulated results of type checking. The minimum amount of state in order to continue type-checking following files.
 [<NoEquality; NoComparison>]
@@ -101,41 +102,43 @@ type internal CompilerCaches =
 
     new: sizeFactor: int -> CompilerCaches
 
-    member AssemblyData: AsyncMemoize<(string * string), (string * string), ProjectAssemblyDataResult>
+    member AssemblyData: AsyncMemoize<FSharpProjectIdentifier, (string * string), ProjectAssemblyDataResult>
 
-    member BootstrapInfo: AsyncMemoize<(string * string), string, (BootstrapInfo option * FSharpDiagnostic array)>
+    member BootstrapInfo: AsyncMemoize<FSharpProjectIdentifier, string, (BootstrapInfo option * FSharpDiagnostic array)>
 
     member BootstrapInfoStatic:
-        AsyncMemoize<(string * string), (string * string), (int * TcImports * TcGlobals * TcInfo * Event<unit>)>
+        AsyncMemoize<FSharpProjectIdentifier, (string * string), (int * TcImports * TcGlobals * TcInfo * Event<unit>)>
 
     member DependencyGraph:
         AsyncMemoize<(DependencyGraphType option * byte array), string, (Graph<NodeToTypeCheck> * Graph<FileIndex>)>
 
     member FrameworkImports: AsyncMemoize<string, FrameworkImportsCacheKey, (TcGlobals * TcImports)>
 
-    member ItemKeyStore: AsyncMemoize<(string * (string * string)), string, ItemKeyStore option>
+    member ItemKeyStore: AsyncMemoize<(string * FSharpProjectIdentifier), string, ItemKeyStore option>
 
     member ParseAndCheckAllFilesInProject: AsyncMemoizeDisabled<obj, obj, obj>
 
     member ParseAndCheckFileInProject:
-        AsyncMemoize<(string * (string * string)), string * string, (FSharpParseFileResults * FSharpCheckFileAnswer)>
+        AsyncMemoize<(string * FSharpProjectIdentifier), string * string, (FSharpParseFileResults *
+        FSharpCheckFileAnswer)>
 
-    member ParseAndCheckProject: AsyncMemoize<(string * string), string, FSharpCheckProjectResults>
+    member ParseAndCheckProject: AsyncMemoize<FSharpProjectIdentifier, string, FSharpCheckProjectResults>
 
     member ParseFile:
-        AsyncMemoize<((string * string) * string), (string * string * bool), ProjectSnapshot.FSharpParsedFile>
+        AsyncMemoize<(FSharpProjectIdentifier * string), (string * string * bool), ProjectSnapshot.FSharpParsedFile>
 
     member ParseFileWithoutProject: AsyncMemoize<string, string, FSharpParseFileResults>
 
     member ProjectExtras: AsyncMemoizeDisabled<obj, obj, obj>
 
-    member SemanticClassification: AsyncMemoize<(string * (string * string)), string, SemanticClassificationView option>
+    member SemanticClassification:
+        AsyncMemoize<(string * FSharpProjectIdentifier), string, SemanticClassificationView option>
 
     member SizeFactor: int
 
-    member TcIntermediate: AsyncMemoize<(string * (string * string)), (string * int), TcIntermediate>
+    member TcIntermediate: AsyncMemoize<(string * FSharpProjectIdentifier), (string * int), TcIntermediate>
 
-    member ScriptClosure: AsyncMemoize<(string * (string * string)), string, LoadClosure>
+    member ScriptClosure: AsyncMemoize<(string * FSharpProjectIdentifier), string, LoadClosure>
 
     member TcLastFile: AsyncMemoizeDisabled<obj, obj, obj>
 

src/FSharp.Compiler.LanguageServer/Common/CapabilitiesManager.fs

@@ -15,8 +15,7 @@ type CapabilitiesManager(scOverrides: IServerCapabilitiesOverride seq) =
             TextDocumentSync = TextDocumentSyncOptions(OpenClose = true, Change = TextDocumentSyncKind.Full),
             DiagnosticOptions =
                 DiagnosticOptions(WorkDoneProgress = true, InterFileDependencies = true, Identifier = "potato", WorkspaceDiagnostics = true),
-            CompletionProvider =
-                CompletionOptions(TriggerCharacters=[|"."; " "|], ResolveProvider=true, WorkDoneProgress=true),
+            CompletionProvider = CompletionOptions(TriggerCharacters = [| "."; " " |], ResolveProvider = true, WorkDoneProgress = true),
             HoverProvider = SumType<bool, HoverOptions>(HoverOptions(WorkDoneProgress = true))
         )
 
@@ -33,4 +32,4 @@ type CapabilitiesManager(scOverrides: IServerCapabilitiesOverride seq) =
         member this.GetInitializeParams() =
             match initializeParams with
             | Some params' -> params'
-            | None -> failwith "InitializeParams is null"
+            | None -> failwith "InitializeParams is null"