Simplify Future handling

Author: odersky

compiler/src/dotty/tools/dotc/util/concurrent.scala

@@ -1,6 +1,5 @@
 package dotty.tools.dotc.util
 import scala.util.{Try, Failure, Success}
-import scala.annotation.tailrec
 import scala.collection.mutable.ArrayBuffer
 
 object concurrent:
@@ -10,15 +9,8 @@ object concurrent:
   class Future[T](exec: Executor[T]):
     private var result: Option[Try[T]] = None
     def force: Try[T] = synchronized {
-      @tailrec def recur(): Try[T] = result match
-        case Some(r) => r
-        case None =>
-          if exec.isRunning then
-            wait(1000 /*ms*/)
-            recur()
-          else
-            Failure(NoCompletion())
-      recur()
+      while result.isEmpty && exec.isAlive do wait(1000 /*ms*/)
+      result.getOrElse(Failure(NoCompletion()))
     }
     def complete(r: Try[T]): Unit = synchronized {
       result = Some(r)
@@ -29,13 +21,11 @@ object concurrent:
   class Executor[T] extends Thread:
     private type WorkItem = (Future[T], () => T)
 
-    @volatile private var terminated = false
     private var allScheduled = false
     private val pending = new ArrayBuffer[WorkItem]
 
-    def isRunning: Boolean = !terminated
-
     def schedule(op: () => T): Future[T] = synchronized {
+      assert(!allScheduled)
       val f = Future[T](this)
       pending += ((f, op))
       notifyAll()
@@ -57,13 +47,14 @@ object concurrent:
     }
 
     override def run(): Unit =
-      @tailrec def recur(): Unit = nextPending() match
-        case Some((f, op)) =>
-          f.complete(Try(op()))
-          recur()
-        case None =>
-      try recur()
-      finally terminated = true
+      while
+        nextPending() match
+          case Some((f, op)) =>
+            f.complete(Try(op()))
+            true
+          case None =>
+            false
+      do ()
   end Executor
 end concurrent