Make f(await(completedFuture)) execute f synchronously

A worthy optimization, suggested by @danarmak.

Closes scala#73

src/main/scala/scala/async/internal/FutureSystem.scala

@@ -100,7 +100,12 @@ object ScalaConcurrentFutureSystem extends FutureSystem {
 
     def onComplete[A, U](future: Expr[Fut[A]], fun: Expr[scala.util.Try[A] => U],
                          execContext: Expr[ExecContext]): Expr[Unit] = reify {
-      future.splice.onComplete(fun.splice)(execContext.splice)
+      val future1 = future.splice
+      val fun1 = fun.splice
+      if (future1.isCompleted)
+        fun1(future1.value.get) // Optimization for completed futures, see https://github.com/scala/async/issues/73
+      else
+        future1.onComplete(fun1)(execContext.splice)
     }
 
     def completeProm[A](prom: Expr[Prom[A]], value: Expr[scala.util.Try[A]]): Expr[Unit] = reify {

src/test/scala/scala/async/run/SyncOptimizationSpec.scala

@@ -0,0 +1,21 @@
+package scala.async.run
+
+import org.junit.Test
+import scala.async.Async._
+import scala.concurrent._
+import scala.concurrent.duration._
+import ExecutionContext.Implicits._
+
+class SyncOptimizationSpec {
+
+  @Test
+  def awaitOnCompletedFutureRunsOnSameThread: Unit = {
+    val future = async {
+      val thread1 = Thread.currentThread
+      val f = await(Future.successful(1))
+      val thread2 = Thread.currentThread
+      assert(thread1 == thread2)
+    }
+    Await.result(future, 10.seconds)
+  }
+}

src/test/scala/scala/async/run/futures/FutureSpec.scala

@@ -538,7 +538,6 @@ class FutureSpec {
       val f = async { await(future(5)) / 0 }
       Await.ready(f, defaultTimeout).value.get.toString mustBe expected.toString
     }
-
 }