Decouple the F# language service from AbstractProject (#5553)

The F# language service presumed that IWorkspaceProjectContext
is implemented by an AbstractProject, which is an assumption that isn't
safe going forward. This removes that presumption, and tweaks a few
other things that should allow F# to continue to function once we
further refactor the project system work in Roslyn.

Author: jasonmalinowski

vsintegration/src/FSharp.Editor/LanguageService/LanguageService.fs

@@ -408,13 +408,13 @@ type internal FSharpLanguageService(package : FSharpPackage) =
         if String.IsNullOrWhiteSpace projectFileName then projectFileName
         else Path.GetFileNameWithoutExtension projectFileName
 
-    let singleFileProjects = ConcurrentDictionary<_, AbstractProject>()
+    let singleFileProjects = ConcurrentDictionary<_, IWorkspaceProjectContext>()
 
     let tryRemoveSingleFileProject projectId =
         match singleFileProjects.TryRemove(projectId) with
         | true, project ->
             projectInfoManager.ClearInfoForSingleFileProject(projectId)
-            project.Disconnect()
+            project.Dispose()
         | _ -> ()
 
     let invalidPathChars = set (Path.GetInvalidPathChars())
@@ -501,16 +501,18 @@ type internal FSharpLanguageService(package : FSharpPackage) =
 
     /// Sync the Roslyn information for the project held in 'projectContext' to match the information given by 'site'.
     /// Also sync the info in ProjectInfoManager if necessary.
-    member this.SyncProject(project: AbstractProject, projectContext: IWorkspaceProjectContext, site: IProjectSite, workspace, forceUpdate, userOpName) =
+    member this.SyncProject(projectContext: IWorkspaceProjectContext, site: IProjectSite, workspace: VisualStudioWorkspaceImpl, forceUpdate, userOpName) =
         let wellFormedFilePathSetIgnoreCase (paths: seq<string>) =
             HashSet(paths |> Seq.filter isPathWellFormed |> Seq.map (fun s -> try Path.GetFullPath(s) with _ -> s), StringComparer.OrdinalIgnoreCase)
 
         let mutable updated = forceUpdate
 
+        let project = workspace.CurrentSolution.Projects |> Seq.filter (fun p -> p.Name = projectContext.DisplayName) |> Seq.exactlyOne
+
         // Sync the source files in projectContext.  Note that these source files are __not__ maintained in order in projectContext
         // as edits are made. It seems this is ok because the source file list is only used to drive roslyn per-file checking.
         let updatedFiles = site.CompilationSourceFiles |> wellFormedFilePathSetIgnoreCase
-        let originalFiles = project.GetCurrentDocuments() |> Seq.map (fun file -> file.FilePath) |> wellFormedFilePathSetIgnoreCase
+        let originalFiles = project.Documents |> Seq.map (fun file -> file.FilePath) |> wellFormedFilePathSetIgnoreCase
 
         for file in updatedFiles do
             if not(originalFiles.Contains(file)) then
@@ -523,7 +525,7 @@ type internal FSharpLanguageService(package : FSharpPackage) =
                 updated <- true
 
         let updatedRefs = site.CompilationReferences |> wellFormedFilePathSetIgnoreCase
-        let originalRefs = project.GetCurrentMetadataReferences() |> Seq.map (fun ref -> ref.FilePath) |> wellFormedFilePathSetIgnoreCase
+        let originalRefs = project.MetadataReferences |> Enumerable.OfType<PortableExecutableReference> |> Seq.map (fun ref -> ref.FilePath) |> wellFormedFilePathSetIgnoreCase
 
         for ref in updatedRefs do
             if not(originalRefs.Contains(ref)) then
@@ -566,11 +568,14 @@ type internal FSharpLanguageService(package : FSharpPackage) =
             let projectFileName = site.ProjectFileName
             let projectDisplayName = projectDisplayNameOf projectFileName
 
-            let projectId = workspace.ProjectTracker.GetOrCreateProjectIdForPath(projectFileName, projectDisplayName)
+            // This projectId is not guaranteed to be the same ProjectId that will actually be created once we call CreateProjectContext
+            // in Roslyn versions once https://github.com/dotnet/roslyn/pull/26931 is merged. Roslyn will still guarantee that once
+            // there is a project in the workspace with the same path, it'll return the ID of that. So this is sufficient to use
+            // in that case as long as we only use it to call GetProject.
+            let fakeProjectId = workspace.ProjectTracker.GetOrCreateProjectIdForPath(projectFileName, projectDisplayName)
 
-            if isNull (workspace.ProjectTracker.GetProject projectId) then
+            if isNull (workspace.ProjectTracker.GetProject fakeProjectId) then
                 let projectContextFactory = package.ComponentModel.GetService<IWorkspaceProjectContextFactory>();
-                let errorReporter = ProjectExternalErrorReporter(projectId, "FS", this.SystemServiceProvider)
 
                 let hierarchy =
                     site.ProjectProvider
@@ -589,27 +594,27 @@ type internal FSharpLanguageService(package : FSharpPackage) =
                         projectFileName,
                         projectGuid,
                         hierarchy,
-                        Option.toObj site.CompilationBinOutputPath,
-                        errorReporter)
-
-                let project = projectContext :?> AbstractProject
+                        Option.toObj site.CompilationBinOutputPath)
+                
+                // The real project ID that was actually added. See comments for fakeProjectId why this one is actually good.
+                let realProjectId = workspace.ProjectTracker.GetOrCreateProjectIdForPath(projectFileName, projectDisplayName)
 
                 // Sync IProjectSite --> projectContext, and IProjectSite --> ProjectInfoManage
-                this.SyncProject(project, projectContext, site, workspace, forceUpdate=true, userOpName=userOpName)
+                this.SyncProject(projectContext, site, workspace, forceUpdate=true, userOpName=userOpName)
 
-                site.BuildErrorReporter <- Some (errorReporter :> Microsoft.VisualStudio.Shell.Interop.IVsLanguageServiceBuildErrorReporter2)
+                site.BuildErrorReporter <- Some (projectContext :?> Microsoft.VisualStudio.Shell.Interop.IVsLanguageServiceBuildErrorReporter2)
 
                 // TODO: consider forceUpdate = false here.  forceUpdate=true may be causing repeated computation?
                 site.AdviseProjectSiteChanges(FSharpConstants.FSharpLanguageServiceCallbackName, 
-                                              AdviseProjectSiteChanges(fun () -> this.SyncProject(project, projectContext, site, workspace, forceUpdate=true, userOpName="AdviseProjectSiteChanges."+userOpName)))
+                                              AdviseProjectSiteChanges(fun () -> this.SyncProject(projectContext, site, workspace, forceUpdate=true, userOpName="AdviseProjectSiteChanges."+userOpName)))
 
                 site.AdviseProjectSiteClosed(FSharpConstants.FSharpLanguageServiceCallbackName, 
                                              AdviseProjectSiteChanges(fun () -> 
-                                                projectInfoManager.ClearInfoForProject(project.Id)
+                                                projectInfoManager.ClearInfoForProject(realProjectId)
                                                 optionsAssociation.Remove(projectContext) |> ignore
-                                                project.Disconnect()))
+                                                projectContext.Dispose()))
 
-                for referencedSite in ProjectSitesAndFiles.GetReferencedProjectSites(Some projectId, site, this.SystemServiceProvider, Some (this.Workspace :>obj), Some projectInfoManager.FSharpOptions ) do
+                for referencedSite in ProjectSitesAndFiles.GetReferencedProjectSites(Some realProjectId, site, this.SystemServiceProvider, Some (this.Workspace :>obj), Some projectInfoManager.FSharpOptions ) do
                     setup referencedSite
 
         setup (siteProvider.GetProjectSite()) 
@@ -619,19 +624,21 @@ type internal FSharpLanguageService(package : FSharpPackage) =
         let projectFileName = fileName
         let projectDisplayName = projectDisplayNameOf projectFileName
 
-        let projectId = workspace.ProjectTracker.GetOrCreateProjectIdForPath(projectFileName, projectDisplayName)
-        let _referencedProjectFileNames, parsingOptions, projectOptions = projectInfoManager.ComputeSingleFileOptions (tryGetOrCreateProjectId workspace, fileName, loadTime, fileContents) |> Async.RunSynchronously
-        projectInfoManager.AddOrUpdateSingleFileProject(projectId, (loadTime, parsingOptions, projectOptions))
+        let mutable projectId = workspace.ProjectTracker.GetOrCreateProjectIdForPath(projectFileName, projectDisplayName)
 
         if isNull (workspace.ProjectTracker.GetProject projectId) then
             let projectContextFactory = package.ComponentModel.GetService<IWorkspaceProjectContextFactory>();
-            let errorReporter = ProjectExternalErrorReporter(projectId, "FS", this.SystemServiceProvider)
 
-            let projectContext = projectContextFactory.CreateProjectContext(FSharpConstants.FSharpLanguageName, projectDisplayName, projectFileName, projectId.Id, hier, null, errorReporter)
+            let projectContext = projectContextFactory.CreateProjectContext(FSharpConstants.FSharpLanguageName, projectDisplayName, projectFileName, projectId.Id, hier, null)
+            
+            projectId <- workspace.ProjectTracker.GetOrCreateProjectIdForPath(projectFileName, projectDisplayName)
+
             projectContext.AddSourceFile(fileName)
 
-            let project = projectContext :?> AbstractProject
-            singleFileProjects.[projectId] <- project
+            singleFileProjects.[projectId] <- projectContext
+
+        let _referencedProjectFileNames, parsingOptions, projectOptions = projectInfoManager.ComputeSingleFileOptions (tryGetOrCreateProjectId workspace, fileName, loadTime, fileContents) |> Async.RunSynchronously
+        projectInfoManager.AddOrUpdateSingleFileProject(projectId, (loadTime, parsingOptions, projectOptions))
 
     override this.ContentTypeName = FSharpConstants.FSharpContentTypeName
     override this.LanguageName = FSharpConstants.FSharpLanguageName