Delete task extension used only by the interactive window.

src/EditorFeatures/Core.Wpf/Interactive/ResetInteractive.cs

@@ -41,36 +41,35 @@ internal ResetInteractive(EditorOptionsService editorOptionsService, Func<string
             _createImport = createImport;
         }
 
-        internal Task ExecuteAsync(IInteractiveWindow interactiveWindow, string title)
+        internal async Task ExecuteAsync(IInteractiveWindow interactiveWindow, string title)
         {
             if (GetProjectProperties(out var references, out var referenceSearchPaths, out var sourceSearchPaths, out var projectNamespaces, out var projectDirectory, out var platform))
             {
-                // Now, we're going to do a bunch of async operations.  So create a wait
-                // indicator so the user knows something is happening, and also so they cancel.
-                var uiThreadOperationExecutor = GetUIThreadOperationExecutor();
-                var context = uiThreadOperationExecutor.BeginExecute(title, EditorFeaturesWpfResources.Building_Project, allowCancellation: true, showProgress: false);
-
-                var resetInteractiveTask = ResetInteractiveAsync(
-                    interactiveWindow,
-                    references,
-                    referenceSearchPaths,
-                    sourceSearchPaths,
-                    projectNamespaces,
-                    projectDirectory,
-                    platform,
-                    context);
-
-                // Once we're done resetting, dismiss the wait indicator and focus the REPL window.
-                return resetInteractiveTask.SafeContinueWith(
-                    _ =>
-                    {
-                        context.Dispose();
-                        ExecutionCompleted?.Invoke(this, new EventArgs());
-                    },
-                    TaskScheduler.FromCurrentSynchronizationContext());
+                try
+                {
+                    // Now, we're going to do a bunch of async operations.  So create a wait
+                    // indicator so the user knows something is happening, and also so they cancel.
+                    var uiThreadOperationExecutor = GetUIThreadOperationExecutor();
+                    using var context = uiThreadOperationExecutor.BeginExecute(title, EditorFeaturesWpfResources.Building_Project, allowCancellation: true, showProgress: false);
+
+                    // We want to come back onto the calling context to dismiss the wait indicator and to notify about
+                    // execution completion.
+                    await ResetInteractiveAsync(
+                        interactiveWindow,
+                        references,
+                        referenceSearchPaths,
+                        sourceSearchPaths,
+                        projectNamespaces,
+                        projectDirectory,
+                        platform,
+                        context).ConfigureAwait(true);
+                }
+                finally
+                {
+                    // Once we're done resetting focus the REPL window.
+                    ExecutionCompleted?.Invoke(this, new EventArgs());
+                }
             }
-
-            return Task.CompletedTask;
         }
 
         private async Task ResetInteractiveAsync(

src/EditorFeatures/Core/RenameTracking/RenameTrackingTaggerProvider.TrackingSession.cs

@@ -18,6 +18,7 @@
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Threading;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.RenameTracking;
@@ -69,10 +70,8 @@ public TrackingSession(
                 // tagging.
 
                 OriginalName = snapshotSpan.GetText();
-                _isRenamableIdentifierTask = Task.Factory.SafeStartNewFromAsync(
-                    () => DetermineIfRenamableIdentifierAsync(snapshotSpan, initialCheck: true),
-                    _cancellationToken,
-                    TaskScheduler.Default);
+                _isRenamableIdentifierTask = DetermineIfRenamableIdentifierAsync(snapshotSpan, initialCheck: true);
+                _isRenamableIdentifierTask.ReportNonFatalErrorAsync();
 
                 var asyncToken = _asyncListener.BeginAsyncOperation(GetType().Name + ".UpdateTrackingSessionAfterIsRenamableIdentifierTask");
 
@@ -157,7 +156,9 @@ public void Cancel()
 
         private async Task<TriggerIdentifierKind> DetermineIfRenamableIdentifierAsync(SnapshotSpan snapshotSpan, bool initialCheck)
         {
-            _threadingContext.ThrowIfNotOnBackgroundThread();
+            // Ensure we do this work on the background.
+            await TaskScheduler.Default;
+
             var document = snapshotSpan.Snapshot.GetOpenDocumentInCurrentContextWithChanges();
             if (document != null)
             {

src/Features/Core/Portable/ExternalAccess/UnitTesting/SolutionCrawler/UnitTestingIdleProcessor.cs

@@ -47,7 +47,8 @@ internal abstract class UnitTestingIdleProcessor(
     protected void Start()
     {
         Contract.ThrowIfFalse(_processorTask == null);
-        _processorTask = Task.Factory.SafeStartNewFromAsync(ProcessAsync, CancellationToken, TaskScheduler.Default);
+        _processorTask = ProcessAsync();
+        _processorTask.ReportNonFatalErrorAsync();
     }
 
     protected void UpdateLastAccessTime()
@@ -117,6 +118,9 @@ protected async Task<bool> WaitForIdleAsync(IExpeditableDelaySource expeditableD
 
     private async Task ProcessAsync()
     {
+        // Ensure we do this processing on the background.
+        await Task.Yield().ConfigureAwait(false);
+
         while (!CancellationToken.IsCancellationRequested)
         {
             try

src/VisualStudio/Core/Def/Implementation/GCManager.cs

@@ -85,14 +85,26 @@ internal static void UseLowLatencyModeForProcessingUserInput()
         {
             GCSettings.LatencyMode = GCLatencyMode.SustainedLowLatency;
 
-            // Restore the LatencyMode a short duration after the
-            // last request to UseLowLatencyModeForProcessingUserInput.
+            // Restore the LatencyMode a short duration after the last UseLowLatencyModeForProcessingUserInput.
             currentDelay = new ResettableDelay(s_delayMilliseconds, AsynchronousOperationListenerProvider.NullListener);
-            currentDelay.Task.SafeContinueWith(_ => RestoreGCLatencyMode(currentMode), TaskScheduler.Default);
+            RestoreGCLatencyModeWhenCompleteAsync(currentDelay.Task, currentMode).ReportNonFatalErrorAsync();
             s_delay = currentDelay;
         }
 
         currentDelay?.Reset();
+        return;
+
+        async Task RestoreGCLatencyModeWhenCompleteAsync(Task task, GCLatencyMode latencyMode)
+        {
+            try
+            {
+                await task.ConfigureAwait(false);
+            }
+            finally
+            {
+                RestoreGCLatencyMode(latencyMode);
+            }
+        }
     }
 
     private static void RestoreGCLatencyMode(GCLatencyMode originalMode)

src/Workspaces/Core/Portable/Shared/TestHooks/TaskExtensions.cs

@@ -36,13 +36,16 @@ public static Task CompletesTrackingOperation(this Task task, IDisposable token)
 
         return CompletesTrackingOperationSlow(task, token);
 
-        static Task CompletesTrackingOperationSlow(Task task, IDisposable token)
+        static async Task CompletesTrackingOperationSlow(Task task, IDisposable token)
         {
-            return task.SafeContinueWith(
-                t => token.Dispose(),
-                CancellationToken.None,
-                TaskContinuationOptions.ExecuteSynchronously,
-                TaskScheduler.Default);
+            try
+            {
+                await task.NoThrowAwaitableInternal(captureContext: false);
+            }
+            finally
+            {
+                token.Dispose();
+            }
         }
     }
 }

src/Workspaces/Core/Portable/Workspace/Workspace.cs

@@ -584,13 +584,6 @@ internal void UpdateCurrentSolutionOnOptionsChanged()
     protected internal Task ScheduleTask(Action action, string? taskName = "Workspace.Task")
         => _taskQueue.ScheduleTask(taskName ?? "Workspace.Task", action, CancellationToken.None);
 
-    /// <summary>
-    /// Execute a function as a background task, as part of a sequential queue of tasks.
-    /// </summary>
-    [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
-    protected internal Task<T> ScheduleTask<T>(Func<T> func, string? taskName = "Workspace.Task")
-        => _taskQueue.ScheduleTask(taskName ?? "Workspace.Task", func, CancellationToken.None);
-
     /// <summary>
     /// Override this method to act immediately when the text of a document has changed, as opposed
     /// to waiting for the corresponding workspace changed event to fire asynchronously.

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems

@@ -582,7 +582,6 @@
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\StringEscapeEncoder.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\SyntaxPath.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\TaskExtensions.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Utilities\TaskFactoryExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\TopologicalSorter.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\EventHandlerFactory.cs" />
   </ItemGroup>

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/TaskExtensions.cs

@@ -142,15 +142,6 @@ static TResult outerFunction(Task t, object? state)
         return task.ContinueWith(outerFunction, continuationFunction, cancellationToken, continuationOptions | TaskContinuationOptions.LazyCancellation, scheduler);
     }
 
-    [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
-    public static Task SafeContinueWith(
-        this Task task,
-        Action<Task> continuationAction,
-        TaskScheduler scheduler)
-    {
-        return task.SafeContinueWith(continuationAction, CancellationToken.None, TaskContinuationOptions.None, scheduler);
-    }
-
     public static Task<TResult> SafeContinueWithFromAsync<TInput, TResult>(
         this Task<TInput> task,
         Func<Task<TInput>, Task<TResult>> continuationFunction,