Improve Await.result/ready performance for completed futures

Avoid evaluating `value0` twice on completed Futures for performance.

Author: He-Pin

library/src/scala/concurrent/Future.scala

@@ -574,6 +574,12 @@ object Future {
   private[this] final val _addToBuilderFun: (Builder[Any, Nothing], Any) => Builder[Any, Nothing] = (b: Builder[Any, Nothing], e: Any) => b += e
   private[concurrent] final def addToBuilderFun[A, M] =  _addToBuilderFun.asInstanceOf[Function2[Builder[A, M], A, Builder[A, M]]]
 
+  private[concurrent] def waitUndefinedError(): Nothing =
+    throw new IllegalArgumentException("Cannot wait for Undefined duration of time")
+
+  private[concurrent] def timeoutError(delay: Duration): Nothing =
+    throw new TimeoutException(s"Future timed out after [$delay]")
+
   /** A Future which is never completed.
    */
   object never extends Future[Nothing] {
@@ -583,7 +589,7 @@ object Future {
     override final def ready(atMost: Duration)(implicit permit: CanAwait): this.type = {
       import Duration.{Undefined, Inf, MinusInf}
       atMost match {
-        case u if u eq Undefined => throw new IllegalArgumentException("cannot wait for Undefined period")
+        case u if u eq Undefined => waitUndefinedError()
         case `Inf`               =>
           while(!Thread.interrupted()) {
             LockSupport.park(this)
@@ -603,14 +609,14 @@ object Future {
         case _: FiniteDuration    => // Drop out if 0 or less
         case x: Duration.Infinite => throw new MatchError(x)
       }
-      throw new TimeoutException(s"Future timed out after [$atMost]")
+      timeoutError(atMost)
     }
 
     @throws[TimeoutException]
     @throws[InterruptedException]
     override final def result(atMost: Duration)(implicit permit: CanAwait): Nothing = {
       ready(atMost)
-      throw new TimeoutException(s"Future timed out after [$atMost]")
+      timeoutError(atMost)
     }
 
     override final def onComplete[U](f: Try[Nothing] => U)(implicit executor: ExecutionContext): Unit = ()

library/src/scala/concurrent/impl/Promise.scala

@@ -255,9 +255,9 @@ private[concurrent] object Promise {
               l.result
             }
           if (r ne null) r
-          else throw new TimeoutException("Future timed out after [" + atMost + "]")
+          else Future.timeoutError(atMost)
         }
-      } else throw new IllegalArgumentException("Cannot wait for Undefined duration of time")
+      } else Future.waitUndefinedError()
 
     @throws(classOf[TimeoutException])
     @throws(classOf[InterruptedException])

library/src/scala/concurrent/package.scala

@@ -12,8 +12,9 @@
 
 package scala
 
-import scala.concurrent.duration.Duration
 import scala.annotation.implicitNotFound
+import scala.concurrent.duration.Duration
+import scala.util.Try
 
 /** This package object contains primitives for concurrent and parallel programming.
  *
@@ -170,8 +171,11 @@ package concurrent {
     @throws(classOf[TimeoutException])
     @throws(classOf[InterruptedException])
     final def ready[T](awaitable: Awaitable[T], atMost: Duration): awaitable.type = awaitable match {
-      case f: Future[T] if f.isCompleted => awaitable.ready(atMost)(AwaitPermission)
-      case _ => blocking(awaitable.ready(atMost)(AwaitPermission))
+      case f: Future[T] if f.isCompleted =>
+        if (atMost eq Duration.Undefined) Future.waitUndefinedError() // preserve semantics, see scala/scala#10972
+        else awaitable
+      case _ =>
+        blocking(awaitable.ready(atMost)(AwaitPermission))
     }
 
     /**
@@ -197,8 +201,18 @@ package concurrent {
     @throws(classOf[TimeoutException])
     @throws(classOf[InterruptedException])
     final def result[T](awaitable: Awaitable[T], atMost: Duration): T = awaitable match {
-      case f: Future[T] if f.isCompleted => f.result(atMost)(AwaitPermission)
-      case _ => blocking(awaitable.result(atMost)(AwaitPermission))
+      case FutureValue(v) =>
+        if (atMost eq Duration.Undefined) Future.waitUndefinedError() // preserve semantics, see scala/scala#10972
+        else v.get
+      case _ =>
+        blocking(awaitable.result(atMost)(AwaitPermission))
+    }
+
+    private object FutureValue {
+      def unapply[T](a: Awaitable[T]): Option[Try[T]] = a match {
+        case f: Future[T] => f.value
+        case _ => None
+      }
     }
   }
 }