Language service tidyup

src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/LanguageServices/LanguageServiceHostEnvironment.cs

@@ -19,8 +19,6 @@ public LanguageServiceHostEnvironment(IVsShellServices vsShell, JoinableTaskCont
         _isEnabled = new(
             async () =>
             {
-                await joinableTaskContext.Factory.SwitchToMainThreadAsync();
-
                 // If VS is running in command line mode (e.g. "devenv.exe /build my.sln"),
                 // the language service host is not enabled. The one exception to this is
                 // when we're populating a solution cache via "/populateSolutionCache".

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/LanguageServices/LanguageServiceHost.cs

@@ -132,7 +132,8 @@ protected override async Task InitializeCoreAsync(CancellationToken cancellation
                 target: DataflowBlockFactory.CreateActionBlock<IProjectVersionedValue<(ConfiguredProject ActiveConfiguredProject, ConfigurationSubscriptionSources Sources)>>(
                     async update => await ExecuteUnderLockAsync(cancellationToken => OnSlicesChanged(update, cancellationToken)),
                     _unconfiguredProject,
-                    ProjectFaultSeverity.LimitedFunctionality),
+                    ProjectFaultSeverity.LimitedFunctionality,
+                    "LanguageServiceHostSlices {0}"),
                 linkOptions: DataflowOption.PropagateCompletion,
                 cancellationToken: cancellationToken),
 
@@ -265,10 +266,10 @@ public Task<bool> IsEnabledAsync(CancellationToken cancellationToken)
 
     public async Task WhenInitialized(CancellationToken token)
     {
-        await ValidateEnabledAsync(token);
-
         using (_joinableTaskCollection.Join())
         {
+            await ValidateEnabledAsync(token);
+
             await _firstPrimaryWorkspaceSet.Task.WithCancellation(token);
         }
     }
@@ -277,8 +278,6 @@ public async Task WriteAsync(Func<IWorkspace, Task> action, CancellationToken to
     {
         token = _tasksService.LinkUnload(token);
 
-        await ValidateEnabledAsync(token);
-
         Workspace workspace = await GetPrimaryWorkspaceAsync(token);
 
         await workspace.WriteAsync(action, token);
@@ -288,32 +287,33 @@ public async Task<T> WriteAsync<T>(Func<IWorkspace, Task<T>> action, Cancellatio
     {
         token = _tasksService.LinkUnload(token);
 
-        await ValidateEnabledAsync(token);
-
         Workspace workspace = await GetPrimaryWorkspaceAsync(token);
 
         return await workspace.WriteAsync(action, token);
     }
 
     private async Task<Workspace> GetPrimaryWorkspaceAsync(CancellationToken cancellationToken)
     {
-        await ValidateEnabledAsync(cancellationToken);
+        using (_joinableTaskCollection.Join())
+        {
+            await ValidateEnabledAsync(cancellationToken);
 
-        await WhenProjectLoaded(cancellationToken);
+            await WhenProjectLoaded();
+        }
 
         return _primaryWorkspace ?? throw Assumes.Fail("Primary workspace unknown.");
-    }
 
-    private async Task WhenProjectLoaded(CancellationToken cancellationToken)
-    {
-        // The active configuration can change multiple times during initialization in cases where we've incorrectly
-        // guessed the configuration via our IProjectConfigurationDimensionsProvider3 implementation.
-        // Wait until that has been determined before we publish the wrong configuration.
-        await _tasksService.PrioritizedProjectLoadedInHost.WithCancellation(cancellationToken);
-
-        // We block project load on initialization of the primary workspace.
-        // Therefore by this point we must have set the primary workspace.
-        System.Diagnostics.Debug.Assert(_firstPrimaryWorkspaceSet.Task is { IsCompleted: true, IsFaulted: false });
+        async Task WhenProjectLoaded()
+        {
+            // The active configuration can change multiple times during initialization in cases where we've incorrectly
+            // guessed the configuration via our IProjectConfigurationDimensionsProvider3 implementation.
+            // Wait until that has been determined before we publish the wrong configuration.
+            await _tasksService.PrioritizedProjectLoadedInHost.WithCancellation(cancellationToken);
+
+            // We block project load on initialization of the primary workspace.
+            // Therefore by this point we must have set the primary workspace.
+            System.Diagnostics.Debug.Assert(_firstPrimaryWorkspaceSet.Task is { IsCompleted: true, IsFaulted: false });
+        }
     }
 
     #endregion
@@ -333,10 +333,7 @@ public async Task AfterLoadInitialConfigurationAsync()
         // Ensure the project is not considered loaded until our first publication.
         Task result = _tasksService.PrioritizedProjectLoadedInHostAsync(async () =>
         {
-            using (_joinableTaskCollection.Join())
-            {
-                await WhenInitialized(_tasksService.UnloadCancellationToken);
-            }
+            await WhenInitialized(_tasksService.UnloadCancellationToken);
         });
 
         // While we want make sure it's loaded before PrioritizedProjectLoadedInHost,

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/LanguageServices/Workspace.cs

@@ -134,13 +134,34 @@ protected override Task DisposeCoreUnderLockAsync(bool initialized)
         return Task.CompletedTask;
     }
 
+    /// <summary>
+    /// Adds an object that will be disposed along with this <see cref="Workspace"/> instance.
+    /// </summary>
+    /// <param name="disposable">The object to dispose when this object is disposed.</param>
     public void ChainDisposal(IDisposable disposable)
     {
         Verify.NotDisposed(this);
 
         _disposableBag.Add(disposable);
     }
 
+    /// <summary>
+    /// Integrates project updates into the workspace.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This method must always receive an evaluation update first. After that point,
+    /// both evaluation and build updates may arrive in any order, so long as values
+    /// of each type are ordered correctly.
+    /// </para>
+    /// <para>
+    /// Calls must not overlap. This method is not thread-safe. This method is designed
+    /// to be called from a dataflow ActionBlock, which will serialize calls, so we
+    /// needn't perform any locking or protection here.
+    /// </para>
+    /// </remarks>
+    /// <param name="update">The project update to integrate.</param>
+    /// <returns>A task that completes when the update has been integrated.</returns>
     internal async Task OnWorkspaceUpdateAsync(IProjectVersionedValue<WorkspaceUpdate> update)
     {
         Verify.NotDisposed(this);