fixed a bug where we were leaking exception through task (changeset 1341224)

Src/Workspaces/Core/Utilities/TaskFactoryExtensions.cs

@@ -3,6 +3,7 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
 
 namespace Roslyn.Utilities
 {
@@ -76,5 +77,63 @@ public static Task<TResult> SafeStartNew<TResult>(this TaskFactory factory, Func
             // The one and only place we can call StartNew<>().
             return factory.StartNew(wrapped, cancellationToken, creationOptions, scheduler);
         }
+
+        public static Task SafeStartNewFromAsync(this TaskFactory factory, Func<Task> actionAsync, TaskScheduler scheduler)
+        {
+            return factory.SafeStartNewFromAsync(actionAsync, CancellationToken.None, scheduler);
+        }
+
+        public static Task SafeStartNewFromAsync(this TaskFactory factory, Func<Task> actionAsync, CancellationToken cancellationToken, TaskScheduler scheduler)
+        {
+            return factory.SafeStartNewFromAsync(actionAsync, cancellationToken, TaskCreationOptions.None, scheduler);
+        }
+
+        public static Task SafeStartNewFromAsync(
+            this TaskFactory factory,
+            Func<Task> actionAsync,
+            CancellationToken cancellationToken,
+            TaskCreationOptions creationOptions,
+            TaskScheduler scheduler)
+        {
+            // The one and only place we can call StartNew<>().
+            var task = factory.StartNew(actionAsync, cancellationToken, creationOptions, scheduler).Unwrap();
+
+            // make it crash if exception has thrown
+            task.SafeContinueWith(t => FailFast.OnFatalException(t.Exception),
+                CancellationToken.None,
+                TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously,
+                TaskScheduler.Default);
+
+            return task;
+        }
+
+        public static Task<TResult> SafeStartNewFromAsync<TResult>(this TaskFactory factory, Func<Task<TResult>> funcAsync, TaskScheduler scheduler)
+        {
+            return factory.SafeStartNewFromAsync(funcAsync, CancellationToken.None, scheduler);
+        }
+
+        public static Task<TResult> SafeStartNewFromAsync<TResult>(this TaskFactory factory, Func<Task<TResult>> funcAsync, CancellationToken cancellationToken, TaskScheduler scheduler)
+        {
+            return factory.SafeStartNewFromAsync(funcAsync, cancellationToken, TaskCreationOptions.None, scheduler);
+        }
+
+        public static Task<TResult> SafeStartNewFromAsync<TResult>(
+            this TaskFactory factory,
+            Func<Task<TResult>> funcAsync,
+            CancellationToken cancellationToken,
+            TaskCreationOptions creationOptions,
+            TaskScheduler scheduler)
+        {
+            // The one and only place we can call StartNew<>().
+            var task = factory.StartNew(funcAsync, cancellationToken, creationOptions, scheduler).Unwrap();
+
+            // make it crash if exception has thrown
+            task.SafeContinueWith(t => FailFast.OnFatalException(t.Exception),
+                CancellationToken.None,
+                TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously,
+                TaskScheduler.Default);
+
+            return task;
+        }
     }
 }

Src/Workspaces/Core/Workspace/Host/TaskScheduler/WorkspaceTaskSchedulerFactory.cs

@@ -88,16 +88,16 @@ public Task ScheduleTask(Func<Task> taskFunc, string taskName, CancellationToken
             {
                 return ScheduleTaskWorker<Task>(
                     taskName, cancellationToken,
-                    () => Task.Factory.SafeStartNew(
-                        taskFunc, cancellationToken, this.taskScheduler).Unwrap());
+                    () => Task.Factory.SafeStartNewFromAsync(
+                        taskFunc, cancellationToken, this.taskScheduler));
             }
 
             public Task<T> ScheduleTask<T>(Func<Task<T>> taskFunc, string taskName, CancellationToken cancellationToken = default(CancellationToken))
             {
                 return ScheduleTaskWorker<Task<T>>(
                     taskName, cancellationToken,
-                    () => Task.Factory.SafeStartNew(
-                        taskFunc, cancellationToken, this.taskScheduler).Unwrap());
+                    () => Task.Factory.SafeStartNewFromAsync(
+                        taskFunc, cancellationToken, this.taskScheduler));
             }
         }
     }