Support unloading projects

RikkiGibson · RikkiGibson · commit a9728385cc78 · 2025-05-06T17:06:29.000-07:00
diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/FileBasedProgramsProjectSystem.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/FileBasedProgramsProjectSystem.cs
@@ -106,7 +106,6 @@ public FileBasedProgramsProjectSystem(
         // For Razor files we need to override the language name to C# as that's what code is generated
         var isRazor = languageInformation.LanguageName == "Razor";
         var languageName = isRazor ? LanguageNames.CSharp : languageInformation.LanguageName;
-        var loadedProject = await CreateAndTrackInitialProjectAsync(documentPath, language: languageName);
         var documentFileInfo = new DocumentFileInfo(documentPath, logicalPath: documentPath, isLinked: false, isGenerated: false, folders: default);
         var projectFileInfo = new ProjectFileInfo()
         {
@@ -122,12 +121,20 @@ public FileBasedProgramsProjectSystem(
             ContentFilePaths = [],
             FileGlobs = []
         };
-        await loadedProject.UpdateWithNewProjectInfoAsync(projectFileInfo, hasAllInformation: false, _logger);
-        var workspaceProject = ProjectFactory.Workspace.CurrentSolution.GetRequiredProject(loadedProject.ProjectId);
-        var document = isRazor ? workspaceProject.AdditionalDocuments.Single() : workspaceProject.Documents.Single();
 
-        ProjectsToLoadAndReload.AddWork(new ProjectToLoad(documentPath, ProjectGuid: null, ReportTelemetry: true));
-        loadedProject.NeedsReload += (_, _) => ProjectsToLoadAndReload.AddWork(new ProjectToLoad(documentPath, ProjectGuid: null, ReportTelemetry: false));
+        var projectSet = AddLoadedProjectSet(documentPath);
+        Project workspaceProject;
+        using (await projectSet.Semaphore.DisposableWaitAsync())
+        {
+            var loadedProject = await this.CreateAndTrackInitialProjectAsync_NoLock(projectSet, documentPath, language: languageName);
+            await loadedProject.UpdateWithNewProjectInfoAsync(projectFileInfo, hasAllInformation: false, _logger);
+
+            ProjectsToLoadAndReload.AddWork(new ProjectToLoad(documentPath, ProjectGuid: null, ReportTelemetry: true));
+            loadedProject.NeedsReload += (_, _) => ProjectsToLoadAndReload.AddWork(new ProjectToLoad(documentPath, ProjectGuid: null, ReportTelemetry: false));
+            workspaceProject = ProjectFactory.Workspace.CurrentSolution.GetRequiredProject(loadedProject.ProjectId);
+        }
+
+        var document = isRazor ? workspaceProject.AdditionalDocuments.Single() : workspaceProject.Documents.Single();
 
         _ = Task.Run(async () =>
         {
@@ -139,9 +146,23 @@ public FileBasedProgramsProjectSystem(
         return document;
     }
 
-    public void TryRemoveMiscellaneousDocument(DocumentUri uri, bool removeFromMetadataWorkspace)
+    public async ValueTask TryRemoveMiscellaneousDocumentAsync(DocumentUri uri, bool removeFromMetadataWorkspace)
     {
-        // support unloading
+        var documentPath = uri.ParsedUri is { } parsedUri ? ProtocolConversions.GetDocumentFilePathFromUri(parsedUri) : uri.UriString;
+        await TryUnloadProjectSetAsync(documentPath);
+
+        // also do an unload in case this was the non-file scenario
+        if (removeFromMetadataWorkspace && uri.ParsedUri is not null && _metadataAsSourceFileService.TryRemoveDocumentFromWorkspace(ProtocolConversions.GetDocumentFilePathFromUri(uri.ParsedUri)))
+        {
+            return;
+        }
+
+        var matchingDocument = Workspace.CurrentSolution.GetDocumentIds(uri).SingleOrDefault();
+        if (matchingDocument != null)
+        {
+            var project = Workspace.CurrentSolution.GetRequiredProject(matchingDocument.ProjectId);
+            Workspace.OnProjectRemoved(project.Id);
+        }
     }
 
     protected override async Task<(RemoteProjectFile? projectFile, bool hasAllInformation, BuildHostProcessKind preferred, BuildHostProcessKind actual)> TryLoadProjectAsync(
diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/FileBasedProgramsWorkspaceProviderFactory.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/FileBasedProgramsWorkspaceProviderFactory.cs
@@ -37,7 +37,6 @@ internal sealed class FileBasedProgramsWorkspaceProviderFactory(
 {
     public ILspMiscellaneousFilesWorkspaceProvider CreateLspMiscellaneousFilesWorkspaceProvider(ILspServices lspServices, HostServices hostServices)
     {
-        // TODO(fbp): check feature flag and maybe give base misc workspace
         return new FileBasedProgramsProjectSystem(lspServices, metadataAsSourceFileService, workspaceFactory, fileChangeWatcher, globalOptionService, loggerFactory, listenerProvider, projectLoadTelemetry, serverConfigurationFactory, binlogNamer);
     }
 }
diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerProjectLoader.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerProjectLoader.cs
@@ -43,13 +43,9 @@ internal abstract class LanguageServerProjectLoader
     private readonly BinlogNamer _binlogNamer;
     protected readonly ImmutableDictionary<string, string> AdditionalProperties;
 
-    /// <summary>
-    /// The list of loaded projects in the workspace, keyed by project file path. The outer dictionary is a concurrent dictionary since we may be loading
-    /// multiple projects at once; the key is a single List we just have a single thread processing any given project file. This is only to be used
-    /// in <see cref="LoadOrReloadProjectsAsync" /> and downstream calls; any other updating of this (like unloading projects) should be achieved by adding
-    /// things to the <see cref="ProjectsToLoadAndReload" />.
-    /// </summary>
-    private readonly ConcurrentDictionary<string, ImmutableArray<LoadedProject>> _loadedProjects = [];
+    protected record LoadedProjectSet(List<LoadedProject> LoadedProjects, SemaphoreSlim Semaphore, CancellationTokenSource CancellationTokenSource);
+
+    private readonly ConcurrentDictionary<string, LoadedProjectSet> _loadedProjects = [];
 
     protected LanguageServerProjectLoader(
         ProjectSystemProjectFactory projectFactory,
@@ -157,103 +153,113 @@ private async Task<bool> LoadOrReloadProjectAsync(ProjectToLoad projectToLoad, T
 
         try
         {
-            var (loadedFile, hasAllInformation, preferredBuildHostKind, actualBuildHostKind) = await TryLoadProjectAsync(buildHostProcessManager, projectPath, cancellationToken);
-            if (preferredBuildHostKind != actualBuildHostKind)
-                preferredBuildHostKindThatWeDidNotGet = preferredBuildHostKind;
-
-            if (loadedFile is null)
-            {
-                _logger.LogWarning($"Unable to load project '{projectPath}'.");
-                return false;
-            }
-
-            var diagnosticLogItems = await loadedFile.GetDiagnosticLogItemsAsync(cancellationToken);
-            if (diagnosticLogItems.Any(item => item.Kind is DiagnosticLogItemKind.Error))
+            if (!_loadedProjects.TryGetValue(projectPath, out var loadedProjectSet) || loadedProjectSet.CancellationTokenSource.IsCancellationRequested)
             {
-                await LogDiagnosticsAsync(diagnosticLogItems);
-                // We have total failures in evaluation, no point in continuing.
+                // project was already unloaded or in process of unloading.
                 return false;
             }
 
-            var loadedProjectInfos = await loadedFile.GetProjectFileInfosAsync(cancellationToken);
-
-            // The out-of-proc build host supports more languages than we may actually have Workspace binaries for, so ensure we can actually process that
-            // language in-process.
-            var projectLanguage = loadedProjectInfos.FirstOrDefault()?.Language;
-            if (projectLanguage != null && ProjectFactory.Workspace.Services.GetLanguageService<ICommandLineParserService>(projectLanguage) == null)
+            var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(loadedProjectSet.CancellationTokenSource.Token, cancellationToken);
+            try
             {
-                return false;
-            }
+                var (loadedFile, hasAllInformation, preferredBuildHostKind, actualBuildHostKind) = await TryLoadProjectAsync(buildHostProcessManager, projectPath, cancellationToken);
+                if (preferredBuildHostKind != actualBuildHostKind)
+                    preferredBuildHostKindThatWeDidNotGet = preferredBuildHostKind;
 
-            if (!_loadedProjects.TryGetValue(projectPath, out var existingProjects))
-                existingProjects = [];
+                if (loadedFile is null)
+                {
+                    _logger.LogWarning($"Unable to load project '{projectPath}'.");
+                    return false;
+                }
 
-            Dictionary<ProjectFileInfo, ProjectLoadTelemetryReporter.TelemetryInfo> telemetryInfos = [];
-            var needsRestore = false;
+                var diagnosticLogItems = await loadedFile.GetDiagnosticLogItemsAsync(cancellationToken);
+                if (diagnosticLogItems.Any(item => item.Kind is DiagnosticLogItemKind.Error))
+                {
+                    await LogDiagnosticsAsync(diagnosticLogItems);
+                    // We have total failures in evaluation, no point in continuing.
+                    return false;
+                }
 
-            // We want to remove projects for targets that don't exist anymore; if we update projects we'll remove them from  
-            // this list -- what's left we can then remove.
-            HashSet<LoadedProject> projectsToRemove = [.. existingProjects];
-            foreach (var loadedProjectInfo in loadedProjectInfos)
-            {
-                var existingProject = existingProjects.FirstOrDefault(p => p.GetTargetFramework() == loadedProjectInfo.TargetFramework);
-                bool targetNeedsRestore;
-                ProjectLoadTelemetryReporter.TelemetryInfo targetTelemetryInfo;
+                var loadedProjectInfos = await loadedFile.GetProjectFileInfosAsync(cancellationToken);
 
-                if (existingProject != null)
+                // The out-of-proc build host supports more languages than we may actually have Workspace binaries for, so ensure we can actually process that
+                // language in-process.
+                var projectLanguage = loadedProjectInfos.FirstOrDefault()?.Language;
+                if (projectLanguage != null && ProjectFactory.Workspace.Services.GetLanguageService<ICommandLineParserService>(projectLanguage) == null)
                 {
-                    projectsToRemove.Remove(existingProject);
-                    (targetTelemetryInfo, targetNeedsRestore) = await existingProject.UpdateWithNewProjectInfoAsync(loadedProjectInfo, hasAllInformation, _logger);
+                    return false;
                 }
-                else
-                {
-                    var loadedProject = await CreateAndTrackInitialProjectAsync(
-                        projectPath,
-                        loadedProjectInfo.Language,
-                        loadedProjectInfo.TargetFramework,
-                        loadedProjectInfo.IntermediateOutputFilePath);
-                    loadedProject.NeedsReload += (_, _) => ProjectsToLoadAndReload.AddWork(projectToLoad with { ReportTelemetry = false });
 
-                    (targetTelemetryInfo, targetNeedsRestore) = await loadedProject.UpdateWithNewProjectInfoAsync(loadedProjectInfo, hasAllInformation, _logger);
+                Dictionary<ProjectFileInfo, ProjectLoadTelemetryReporter.TelemetryInfo> telemetryInfos = [];
+                var needsRestore = false;
 
-                    needsRestore |= targetNeedsRestore;
-                    telemetryInfos[loadedProjectInfo] = targetTelemetryInfo with { IsSdkStyle = preferredBuildHostKind == BuildHostProcessKind.NetCore };
+                using var _ = await loadedProjectSet.Semaphore.DisposableWaitAsync(cancellationToken);
+                // last chance for someone to cancel out from under us.
+                if (loadedProjectSet.CancellationTokenSource.IsCancellationRequested)
+                {
+                    return false;
                 }
-            }
 
-            if (projectsToRemove.Any())
-            {
-                foreach (var project in existingProjects)
+                var existingProjects = loadedProjectSet.LoadedProjects;
+
+                // We want to remove projects for targets that don't exist anymore; if we update projects we'll remove them from  
+                // this list -- what's left we can then remove.
+                HashSet<LoadedProject> projectsToRemove = [.. existingProjects];
+                foreach (var loadedProjectInfo in loadedProjectInfos)
                 {
-                    if (projectsToRemove.Contains(project))
+                    var existingProject = existingProjects.FirstOrDefault(p => p.GetTargetFramework() == loadedProjectInfo.TargetFramework);
+                    bool targetNeedsRestore;
+                    ProjectLoadTelemetryReporter.TelemetryInfo targetTelemetryInfo;
+
+                    if (existingProject != null)
+                    {
+                        projectsToRemove.Remove(existingProject);
+                        (targetTelemetryInfo, targetNeedsRestore) = await existingProject.UpdateWithNewProjectInfoAsync(loadedProjectInfo, hasAllInformation, _logger);
+                    }
+                    else
                     {
-                        project.Dispose();
+                        var loadedProject = await CreateAndTrackInitialProjectAsync_NoLock(
+                            loadedProjectSet,
+                            projectPath,
+                            loadedProjectInfo.Language,
+                            loadedProjectInfo.TargetFramework,
+                            loadedProjectInfo.IntermediateOutputFilePath);
+                        loadedProject.NeedsReload += (_, _) => ProjectsToLoadAndReload.AddWork(projectToLoad with { ReportTelemetry = false });
+
+                        (targetTelemetryInfo, targetNeedsRestore) = await loadedProject.UpdateWithNewProjectInfoAsync(loadedProjectInfo, hasAllInformation, _logger);
+
+                        needsRestore |= targetNeedsRestore;
+                        telemetryInfos[loadedProjectInfo] = targetTelemetryInfo with { IsSdkStyle = preferredBuildHostKind == BuildHostProcessKind.NetCore };
                     }
                 }
 
-                _loadedProjects.AddOrUpdate(projectPath,
-                    // We expect the key always continues to be present in the dictionary during this operation.
-                    addValueFactory: (_, _) => throw new InvalidOperationException(),
-                    updateValueFactory: static (_, existingProjects, projectsToRemove) => existingProjects.RemoveRange(projectsToRemove),
-                    factoryArgument: projectsToRemove);
-            }
+                foreach (var project in projectsToRemove)
+                {
+                    project.Dispose();
+                    existingProjects.Remove(project);
+                }
 
-            if (projectToLoad.ReportTelemetry)
-            {
-                await _projectLoadTelemetryReporter.ReportProjectLoadTelemetryAsync(telemetryInfos, projectToLoad, cancellationToken);
-            }
+                if (projectToLoad.ReportTelemetry)
+                {
+                    await _projectLoadTelemetryReporter.ReportProjectLoadTelemetryAsync(telemetryInfos, projectToLoad, cancellationToken);
+                }
 
-            diagnosticLogItems = await loadedFile.GetDiagnosticLogItemsAsync(cancellationToken);
-            if (diagnosticLogItems.Any())
-            {
-                await LogDiagnosticsAsync(diagnosticLogItems);
+                diagnosticLogItems = await loadedFile.GetDiagnosticLogItemsAsync(cancellationToken);
+                if (diagnosticLogItems.Any())
+                {
+                    await LogDiagnosticsAsync(diagnosticLogItems);
+                }
+                else
+                {
+                    _logger.LogInformation(string.Format(LanguageServerResources.Successfully_completed_load_of_0, projectPath));
+                }
+
+                return needsRestore;
             }
-            else
+            catch (OperationCanceledException e) when (e.CancellationToken == linkedTokenSource.Token)
             {
-                _logger.LogInformation(string.Format(LanguageServerResources.Successfully_completed_load_of_0, projectPath));
+                return false;
             }
-
-            return needsRestore;
         }
         catch (Exception e)
         {
@@ -291,11 +297,32 @@ async Task LogDiagnosticsAsync(ImmutableArray<DiagnosticLogItem> diagnosticLogIt
     /// <summary>
     /// Creates a <see cref="LoadedProject"/> which has bare minimum information, but, which documents can be added to and obtained from.
     /// </summary>
-    protected async Task<LoadedProject> CreateAndTrackInitialProjectAsync(
-        string projectPath,
-        string language,
-        string? targetFramework = null,
-        string? intermediateOutputFilePath = null)
+    protected LoadedProjectSet AddLoadedProjectSet(string projectPath)
+    {
+        var projectSet = new LoadedProjectSet([], new SemaphoreSlim(1), new CancellationTokenSource());
+        return _loadedProjects.GetOrAdd(projectPath, projectSet);
+    }
+
+    protected async ValueTask TryUnloadProjectSetAsync(string projectPath)
+    {
+        if (_loadedProjects.TryRemove(projectPath, out var loadedProjectSet))
+        {
+            using var _ = await loadedProjectSet.Semaphore.DisposableWaitAsync();
+            if (loadedProjectSet.CancellationTokenSource.IsCancellationRequested)
+            {
+                // don't need to cancel again.
+                return;
+            }
+
+            loadedProjectSet.CancellationTokenSource.Cancel();
+            foreach (var project in loadedProjectSet.LoadedProjects)
+            {
+                project.Dispose();
+            }
+        }
+    }
+
+    protected async Task<LoadedProject> CreateAndTrackInitialProjectAsync_NoLock(LoadedProjectSet projectSet, string projectPath, string language, string? targetFramework = null, string? intermediateOutputFilePath = null)
     {
         var projectSystemName = targetFramework is null ? projectPath : $"{projectPath} (${targetFramework})";
 
@@ -313,7 +340,7 @@ protected async Task<LoadedProject> CreateAndTrackInitialProjectAsync(
             _projectSystemHostInfo);
 
         var loadedProject = new LoadedProject(projectSystemProject, ProjectFactory.Workspace.Services.SolutionServices, _fileChangeWatcher, _targetFrameworkManager);
-        _loadedProjects.AddOrUpdate(projectPath, addValue: [loadedProject], updateValueFactory: (_, arr) => arr.Add(loadedProject));
+        projectSet.LoadedProjects.Add(loadedProject);
         return loadedProject;
     }
 }
diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerProjectSystem.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerProjectSystem.cs
@@ -74,6 +74,7 @@ public async Task OpenSolutionAsync(string solutionFilePath)
 
             foreach (var project in await buildHost.GetProjectsInSolutionAsync(solutionFilePath, CancellationToken.None))
             {
+                _ = AddLoadedProjectSet(project.ProjectPath);
                 ProjectsToLoadAndReload.AddWork(new ProjectToLoad(project.ProjectPath, project.ProjectGuid, ReportTelemetry: true));
             }
 
@@ -90,7 +91,11 @@ public async Task OpenProjectsAsync(ImmutableArray<string> projectFilePaths)
 
         using (await _gate.DisposableWaitAsync())
         {
-            ProjectsToLoadAndReload.AddWork(projectFilePaths.Select(p => new ProjectToLoad(p, ProjectGuid: null, ReportTelemetry: true)));
+            foreach (var projectPath in projectFilePaths)
+            {
+                _ = AddLoadedProjectSet(projectPath);
+                ProjectsToLoadAndReload.AddWork(new ProjectToLoad(projectPath, ProjectGuid: null, ReportTelemetry: true));
+            }
 
             // Wait for the in progress batch to complete and send a project initialized notification to the client.
             await ProjectsToLoadAndReload.WaitUntilCurrentBatchCompletesAsync();
diff --git a/src/LanguageServer/Protocol/Workspaces/ILspMiscellaneousFilesWorkspaceProvider.cs b/src/LanguageServer/Protocol/Workspaces/ILspMiscellaneousFilesWorkspaceProvider.cs
@@ -21,5 +21,5 @@ internal interface ILspMiscellaneousFilesWorkspaceProvider : ILspService
     /// async is used here to allow taking locks asynchronously and "relatively fast" stuff like that.
     /// </summary>
     Task<TextDocument?> AddMiscellaneousDocumentAsync(DocumentUri uri, SourceText documentText, string languageId, ILspLogger logger);
-    void TryRemoveMiscellaneousDocument(DocumentUri uri, bool removeFromMetadataWorkspace);
+    ValueTask TryRemoveMiscellaneousDocumentAsync(DocumentUri uri, bool removeFromMetadataWorkspace);
 }
diff --git a/src/LanguageServer/Protocol/Workspaces/LspMiscellaneousFilesWorkspaceProvider.cs b/src/LanguageServer/Protocol/Workspaces/LspMiscellaneousFilesWorkspaceProvider.cs
diff --git a/src/LanguageServer/Protocol/Workspaces/LspWorkspaceManager.cs b/src/LanguageServer/Protocol/Workspaces/LspWorkspaceManager.cs

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,6 @@ internal sealed class FileBasedProgramsWorkspaceProviderFactory(`
`37`	`37`	`{`
`38`	`38`	`public ILspMiscellaneousFilesWorkspaceProvider CreateLspMiscellaneousFilesWorkspaceProvider(ILspServices lspServices, HostServices hostServices)`
`39`	`39`	`{`
`40`		`- // TODO(fbp): check feature flag and maybe give base misc workspace`
`41`	`40`	`return new FileBasedProgramsProjectSystem(lspServices, metadataAsSourceFileService, workspaceFactory, fileChangeWatcher, globalOptionService, loggerFactory, listenerProvider, projectLoadTelemetry, serverConfigurationFactory, binlogNamer);`
`42`	`41`	`}`
`43`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -74,6 +74,7 @@ public async Task OpenSolutionAsync(string solutionFilePath)`
`74`	`74`
`75`	`75`	`foreach (var project in await buildHost.GetProjectsInSolutionAsync(solutionFilePath, CancellationToken.None))`
`76`	`76`	`{`
	`77`	`+ _ = AddLoadedProjectSet(project.ProjectPath);`
`77`	`78`	`ProjectsToLoadAndReload.AddWork(new ProjectToLoad(project.ProjectPath, project.ProjectGuid, ReportTelemetry: true));`
`78`	`79`	`}`
`79`	`80`
`@@ -90,7 +91,11 @@ public async Task OpenProjectsAsync(ImmutableArray<string> projectFilePaths)`
`90`	`91`
`91`	`92`	`using (await _gate.DisposableWaitAsync())`
`92`	`93`	`{`
`93`		`- ProjectsToLoadAndReload.AddWork(projectFilePaths.Select(p => new ProjectToLoad(p, ProjectGuid: null, ReportTelemetry: true)));`
	`94`	`+ foreach (var projectPath in projectFilePaths)`
	`95`	`+ {`
	`96`	`+ _ = AddLoadedProjectSet(projectPath);`
	`97`	`+ ProjectsToLoadAndReload.AddWork(new ProjectToLoad(projectPath, ProjectGuid: null, ReportTelemetry: true));`
	`98`	`+ }`
`94`	`99`
`95`	`100`	`// Wait for the in progress batch to complete and send a project initialized notification to the client.`
`96`	`101`	`await ProjectsToLoadAndReload.WaitUntilCurrentBatchCompletesAsync();`
Original file line number	Diff line number	Diff line change
`@@ -21,5 +21,5 @@ internal interface ILspMiscellaneousFilesWorkspaceProvider : ILspService`
`21`	`21`	`/// async is used here to allow taking locks asynchronously and "relatively fast" stuff like that.`
`22`	`22`	`/// </summary>`
`23`	`23`	`Task<TextDocument?> AddMiscellaneousDocumentAsync(DocumentUri uri, SourceText documentText, string languageId, ILspLogger logger);`
`24`		`- void TryRemoveMiscellaneousDocument(DocumentUri uri, bool removeFromMetadataWorkspace);`
	`24`	`+ ValueTask TryRemoveMiscellaneousDocumentAsync(DocumentUri uri, bool removeFromMetadataWorkspace);`
`25`	`25`	`}`