Expose Task.IsCompletedSuccessfully

Author: stephentoub

src/mscorlib/shared/System/Threading/Tasks/TaskExtensions.cs

@@ -21,7 +21,7 @@ public static Task Unwrap(this Task<Task> task)
             // it completed successfully.  Return its inner task to avoid unnecessary wrapping, or if the inner
             // task is null, return a canceled task to match the same semantics as CreateUnwrapPromise.
             return
-                !task.IsRanToCompletion ? Task.CreateUnwrapPromise<VoidTaskResult>(task, lookForOce: false) :
+                !task.IsCompletedSuccessfully ? Task.CreateUnwrapPromise<VoidTaskResult>(task, lookForOce: false) :
                 task.Result ??
                 Task.FromCanceled(new CancellationToken(true));
         }
@@ -40,7 +40,7 @@ public static Task<TResult> Unwrap<TResult>(this Task<Task<TResult>> task)
             // it completed successfully.  Return its inner task to avoid unnecessary wrapping, or if the inner
             // task is null, return a canceled task to match the same semantics as CreateUnwrapPromise.
             return
-                !task.IsRanToCompletion ? Task.CreateUnwrapPromise<TResult>(task, lookForOce: false) :
+                !task.IsCompletedSuccessfully ? Task.CreateUnwrapPromise<TResult>(task, lookForOce: false) :
                 task.Result ??
                 Task.FromCanceled<TResult>(new CancellationToken(true));
         }

src/mscorlib/src/System/IO/Stream.cs

@@ -522,14 +522,14 @@ private void RunReadWriteTaskWhenReady(Task asyncWaiter, ReadWriteTask readWrite
             // If the wait has already completed, run the task.
             if (asyncWaiter.IsCompleted)
             {
-                Debug.Assert(asyncWaiter.IsRanToCompletion, "The semaphore wait should always complete successfully.");
+                Debug.Assert(asyncWaiter.IsCompletedSuccessfully, "The semaphore wait should always complete successfully.");
                 RunReadWriteTask(readWriteTask);
             }
             else  // Otherwise, wait for our turn, and then run the task.
             {
                 asyncWaiter.ContinueWith((t, state) =>
                 {
-                    Debug.Assert(t.IsRanToCompletion, "The semaphore wait should always complete successfully.");
+                    Debug.Assert(t.IsCompletedSuccessfully, "The semaphore wait should always complete successfully.");
                     var rwt = (ReadWriteTask)state;
                     rwt._stream.RunReadWriteTask(rwt); // RunReadWriteTask(readWriteTask);
                 }, readWriteTask, default(CancellationToken), TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);

src/mscorlib/src/System/Runtime/CompilerServices/TaskAwaiter.cs

@@ -146,7 +146,7 @@ private static void HandleNonSuccessAndDebuggerNotification(Task task)
             task.NotifyDebuggerOfWaitCompletionIfNecessary();
 
             // And throw an exception if the task is faulted or canceled.
-            if (!task.IsRanToCompletion) ThrowForNonSuccess(task);
+            if (!task.IsCompletedSuccessfully) ThrowForNonSuccess(task);
         }
 
         /// <summary>Throws an exception to handle a task that completed in a state other than RanToCompletion.</summary>

src/mscorlib/src/System/Threading/Tasks/Task.cs

@@ -1467,8 +1467,7 @@ private static bool IsCompletedMethod(int flags)
             return (flags & TASK_STATE_COMPLETED_MASK) != 0;
         }
 
-        // For use in InternalWait -- marginally faster than (Task.Status == TaskStatus.RanToCompletion)
-        internal bool IsRanToCompletion
+        public bool IsCompletedSuccessfully
         {
             get { return (m_stateFlags & TASK_STATE_COMPLETED_MASK) == TASK_STATE_RAN_TO_COMPLETION; }
         }

src/mscorlib/src/System/Threading/Tasks/TaskContinuation.cs

@@ -320,7 +320,7 @@ internal override void Run(Task completedTask, bool bCanInlineContinuationTask)
             // activation criteria of the TaskContinuationOptions.
             TaskContinuationOptions options = m_options;
             bool isRightKind =
-                completedTask.IsRanToCompletion ?
+                completedTask.IsCompletedSuccessfully ?
                     (options & TaskContinuationOptions.NotOnRanToCompletion) == 0 :
                     (completedTask.IsCanceled ?
                         (options & TaskContinuationOptions.NotOnCanceled) == 0 :

src/mscorlib/src/System/Threading/Tasks/future.cs

@@ -374,7 +374,7 @@ private string DebuggerDisplayResultDescription
         {
             get
             {
-                return IsRanToCompletion ? "" + m_result : SR.TaskT_DebuggerNoResult;
+                return IsCompletedSuccessfully ? "" + m_result : SR.TaskT_DebuggerNoResult;
             }
         }
 
@@ -491,10 +491,10 @@ internal TResult GetResultCore(bool waitCompletionNotification)
             if (waitCompletionNotification) NotifyDebuggerOfWaitCompletionIfNecessary();
 
             // Throw an exception if appropriate.
-            if (!IsRanToCompletion) ThrowIfExceptional(includeTaskCanceledExceptions: true);
+            if (!IsCompletedSuccessfully) ThrowIfExceptional(includeTaskCanceledExceptions: true);
 
             // We shouldn't be here if the result has not been set.
-            Debug.Assert(IsRanToCompletion, "Task<T>.Result getter: Expected result to have been set.");
+            Debug.Assert(IsCompletedSuccessfully, "Task<T>.Result getter: Expected result to have been set.");
 
             return m_result;
         }