SI-6095, SI-6098 - clean up public API, add deprecations

Remove Scheduler, Cancellable, and Task trait.
Hide impl.Promise object.
Deprecate managedBlock methods in TaskRunners.
Remove duplicate toBoxed method and pointless renaming import.
Remove duplicate import of CanBuildFrom and Builder in Future.
Organize imports in impl.Promise.

Review by @axel22 and @heathermiller

13 files changed, 23 insertions, 107 deletions

diff --git a/src/library/scala/concurrent/ExecutionContext.scala b/src/library/scala/concurrent/ExecutionContext.scala
index debfc226db..8081bb32da 100644
--- a/src/library/scala/concurrent/ExecutionContext.scala
+++ b/src/library/scala/concurrent/ExecutionContext.scala
@@ -77,7 +77,7 @@ object ExecutionContext {
   
   /** The default reporter simply prints the stack trace of the `Throwable` to System.err.
    */
-  def defaultReporter: Throwable => Unit = { case t => t.printStackTrace() }
+  def defaultReporter: Throwable => Unit = (t: Throwable) => t.printStackTrace()
 }
 
 
diff --git a/src/library/scala/concurrent/Future.scala b/src/library/scala/concurrent/Future.scala
index e556be4fe3..f82b79cb18 100644
--- a/src/library/scala/concurrent/Future.scala
+++ b/src/library/scala/concurrent/Future.scala
@@ -14,7 +14,6 @@ import java.util.concurrent.{ ConcurrentLinkedQueue, TimeUnit, Callable }
 import java.util.concurrent.TimeUnit.{ NANOSECONDS => NANOS, MILLISECONDS ⇒ MILLIS }
 import java.lang.{ Iterable => JIterable }
 import java.util.{ LinkedList => JLinkedList }
-import java.{ lang => jl }
 import java.util.concurrent.atomic.{ AtomicReferenceFieldUpdater, AtomicInteger, AtomicBoolean }
 
 import scala.concurrent.util.Duration
@@ -565,17 +564,15 @@ trait Future[+T] extends Awaitable[T] {
  */
 object Future {
   
-  import java.{ lang => jl }
-  
   private[concurrent] val toBoxed = Map[Class[_], Class[_]](
-    classOf[Boolean] -> classOf[jl.Boolean],
-    classOf[Byte]    -> classOf[jl.Byte],
-    classOf[Char]    -> classOf[jl.Character],
-    classOf[Short]   -> classOf[jl.Short],
-    classOf[Int]     -> classOf[jl.Integer],
-    classOf[Long]    -> classOf[jl.Long],
-    classOf[Float]   -> classOf[jl.Float],
-    classOf[Double]  -> classOf[jl.Double],
+    classOf[Boolean] -> classOf[java.lang.Boolean],
+    classOf[Byte]    -> classOf[java.lang.Byte],
+    classOf[Char]    -> classOf[java.lang.Character],
+    classOf[Short]   -> classOf[java.lang.Short],
+    classOf[Int]     -> classOf[java.lang.Integer],
+    classOf[Long]    -> classOf[java.lang.Long],
+    classOf[Float]   -> classOf[java.lang.Float],
+    classOf[Double]  -> classOf[java.lang.Double],
     classOf[Unit]    -> classOf[scala.runtime.BoxedUnit]
   )
 
@@ -604,9 +601,6 @@ object Future {
   */
   def apply[T](body: =>T)(implicit execctx: ExecutionContext): Future[T] = impl.Future(body)
 
-  import scala.collection.mutable.Builder
-  import scala.collection.generic.CanBuildFrom
-
   /** Simple version of `Futures.traverse`. Transforms a `TraversableOnce[Future[A]]` into a `Future[TraversableOnce[A]]`.
    *  Useful for reducing many `Future`s into a single `Future`.
    */
diff --git a/src/library/scala/concurrent/FutureTaskRunner.scala b/src/library/scala/concurrent/FutureTaskRunner.scala
index 9d6f8a7a88..d7f1e1c2f9 100644
--- a/src/library/scala/concurrent/FutureTaskRunner.scala
+++ b/src/library/scala/concurrent/FutureTaskRunner.scala
@@ -15,7 +15,7 @@ import language.{implicitConversions, higherKinds}
  *
  *  @author Philipp Haller
  */
-@deprecated("Use `ExecutionContext`s instead.", "2.10.0")
+@deprecated("Use `ExecutionContext` instead.", "2.10.0")
 trait FutureTaskRunner extends TaskRunner {
 
   /** The type of the futures that the underlying task runner supports.
@@ -33,6 +33,7 @@ trait FutureTaskRunner extends TaskRunner {
    /* Possibly blocks the current thread, for example, waiting for
     * a lock or condition.
     */
+  @deprecated("Use `blocking` instead.", "2.10.0")
   def managedBlock(blocker: ManagedBlocker): Unit
 
 }
diff --git a/src/library/scala/concurrent/ManagedBlocker.scala b/src/library/scala/concurrent/ManagedBlocker.scala
index 9c6f4d51d6..47bbb91f6f 100644
--- a/src/library/scala/concurrent/ManagedBlocker.scala
+++ b/src/library/scala/concurrent/ManagedBlocker.scala
@@ -12,6 +12,7 @@ package scala.concurrent
  *
  *  @author Philipp Haller
  */
+@deprecated("Use `blocking` instead.", "2.10.0")
 trait ManagedBlocker {
 
   /**
diff --git a/src/library/scala/concurrent/Scheduler.scala b/src/library/scala/concurrent/Scheduler.scala
deleted file mode 100644
index 6645abcc4e..0000000000
--- a/src/library/scala/concurrent/Scheduler.scala
+++ /dev/null
@@ -1,54 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2011, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-package scala.concurrent
-
-import scala.concurrent.util.Duration
-
-/** A service for scheduling tasks and thunks for one-time, or periodic execution.
- */
-trait Scheduler {
-
-  /** Schedules a thunk for repeated execution with an initial delay and a frequency.
-   *
-   *  @param delay      the initial delay after which the thunk should be executed
-   *                    the first time
-   *  @param frequency  the frequency with which the thunk should be executed,
-   *                    as a time period between subsequent executions
-   */
-  def schedule(delay: Duration, frequency: Duration)(thunk: => Unit): Cancellable
-
-  /** Schedules a task for execution after a given delay.
-   *
-   *  @param delay  the duration after which the task should be executed
-   *  @param task   the task that is scheduled for execution
-   *  @return       a `Cancellable` that may be used to cancel the execution
-   *                of the task
-   */
-  def scheduleOnce(delay: Duration, task: Runnable): Cancellable
-
-  /** Schedules a thunk for execution after a given delay.
-   *
-   *  @param delay  the duration after which the thunk should be executed
-   *  @param task   the thunk that is scheduled for execution
-   *  @return       a `Cancellable` that may be used to cancel the execution
-   *                of the thunk
-   */
-  def scheduleOnce(delay: Duration)(task: => Unit): Cancellable
-
-}
-
-
-
-trait Cancellable {
-
-  /** Cancels the underlying task.
-   */
-  def cancel(): Unit
-
-}
diff --git a/src/library/scala/concurrent/Task.scala b/src/library/scala/concurrent/Task.scala
deleted file mode 100644
index eb3efbb422..0000000000
--- a/src/library/scala/concurrent/Task.scala
+++ /dev/null
@@ -1,13 +0,0 @@
-package scala.concurrent
-
-
-
-trait Task[+T] {
-
-  def start(): Unit
-
-  def future: Future[T]
-
-}
-
-
diff --git a/src/library/scala/concurrent/TaskRunner.scala b/src/library/scala/concurrent/TaskRunner.scala
index 3180e9ce8a..2e11ac42b0 100644
--- a/src/library/scala/concurrent/TaskRunner.scala
+++ b/src/library/scala/concurrent/TaskRunner.scala
@@ -14,7 +14,7 @@ import language.{higherKinds, implicitConversions}
  *
  *  @author Philipp Haller
  */
-@deprecated("Use `ExecutionContext`s instead.", "2.10.0")
+@deprecated("Use `ExecutionContext` instead.", "2.10.0")
 trait TaskRunner {
 
   type Task[T]
diff --git a/src/library/scala/concurrent/TaskRunners.scala b/src/library/scala/concurrent/TaskRunners.scala
index 7994255b25..8f7d952ed8 100644
--- a/src/library/scala/concurrent/TaskRunners.scala
+++ b/src/library/scala/concurrent/TaskRunners.scala
@@ -14,7 +14,7 @@ import java.util.concurrent.{ThreadPoolExecutor, LinkedBlockingQueue, TimeUnit}
  *
  *  @author Philipp Haller
  */
-@deprecated("Use `ExecutionContext`s instead.", "2.10.0")
+@deprecated("Use `ExecutionContext` instead.", "2.10.0")
 object TaskRunners {
 
   implicit val threadRunner: FutureTaskRunner =
diff --git a/src/library/scala/concurrent/ThreadPoolRunner.scala b/src/library/scala/concurrent/ThreadPoolRunner.scala
index fd6882348a..594555d49b 100644
--- a/src/library/scala/concurrent/ThreadPoolRunner.scala
+++ b/src/library/scala/concurrent/ThreadPoolRunner.scala
@@ -16,7 +16,7 @@ import language.implicitConversions
  *
  *  @author Philipp Haller
  */
-@deprecated("Use `ExecutionContext`s instead.", "2.10.0")
+@deprecated("Use `ExecutionContext` instead.", "2.10.0")
 trait ThreadPoolRunner extends FutureTaskRunner {
 
   type Task[T] = Callable[T] with Runnable
@@ -43,6 +43,7 @@ trait ThreadPoolRunner extends FutureTaskRunner {
     executor execute task
   }
 
+  @deprecated("Use `blocking` instead.", "2.10.0")
   def managedBlock(blocker: ManagedBlocker) {
     blocker.block()
   }
diff --git a/src/library/scala/concurrent/ThreadRunner.scala b/src/library/scala/concurrent/ThreadRunner.scala
index 76be94aa6b..ab709e0210 100644
--- a/src/library/scala/concurrent/ThreadRunner.scala
+++ b/src/library/scala/concurrent/ThreadRunner.scala
@@ -15,6 +15,7 @@ import language.implicitConversions
  *
  *  @author Philipp Haller
  */
+@deprecated("Use `ExecutionContext` instead.", "2.10.0")
 class ThreadRunner extends FutureTaskRunner {
 
   type Task[T] = () => T
@@ -47,6 +48,7 @@ class ThreadRunner extends FutureTaskRunner {
     () => result.get.fold[S](throw _, identity _)
   }
 
+  @deprecated("Use `blocking` instead.", "2.10.0")
   def managedBlock(blocker: ManagedBlocker) {
     blocker.block()
   }
diff --git a/src/library/scala/concurrent/impl/Future.scala b/src/library/scala/concurrent/impl/Future.scala
index 0c031743db..132e1d79e7 100644
--- a/src/library/scala/concurrent/impl/Future.scala
+++ b/src/library/scala/concurrent/impl/Future.scala
@@ -21,19 +21,6 @@ private[concurrent] trait Future[+T] extends scala.concurrent.Future[T] with Awa
 }
 
 private[concurrent] object Future {
-  import java.{ lang => jl }
-
-  private val toBoxed = Map[Class[_], Class[_]](
-    classOf[Boolean] -> classOf[jl.Boolean],
-    classOf[Byte]    -> classOf[jl.Byte],
-    classOf[Char]    -> classOf[jl.Character],
-    classOf[Short]   -> classOf[jl.Short],
-    classOf[Int]     -> classOf[jl.Integer],
-    classOf[Long]    -> classOf[jl.Long],
-    classOf[Float]   -> classOf[jl.Float],
-    classOf[Double]  -> classOf[jl.Double],
-    classOf[Unit]    -> classOf[scala.runtime.BoxedUnit]
-  )
 
   /** Wraps a block of code into an awaitable object. */
   private[concurrent] def body2awaitable[T](body: =>T) = new Awaitable[T] {
@@ -44,7 +31,7 @@ private[concurrent] object Future {
     def result(atMost: Duration)(implicit permit: CanAwait) = body
   }
   
-  def boxedType(c: Class[_]): Class[_] = if (c.isPrimitive) toBoxed(c) else c
+  def boxedType(c: Class[_]): Class[_] = if (c.isPrimitive) scala.concurrent.Future.toBoxed(c) else c
 
   private[impl] class PromiseCompletingRunnable[T](body: => T)
     extends Runnable {
diff --git a/src/library/scala/concurrent/impl/Promise.scala b/src/library/scala/concurrent/impl/Promise.scala
index ccfcd30c97..84638586cf 100644
--- a/src/library/scala/concurrent/impl/Promise.scala
+++ b/src/library/scala/concurrent/impl/Promise.scala
@@ -10,14 +10,11 @@ package scala.concurrent.impl
 
 
 
-import java.util.concurrent.TimeUnit.{ NANOSECONDS, MILLISECONDS }
-import scala.concurrent.{ Awaitable, ExecutionContext, blocking, CanAwait, OnCompleteRunnable, TimeoutException, ExecutionException }
-//import scala.util.continuations._
+import java.util.concurrent.TimeUnit.NANOSECONDS
+import scala.concurrent.{ ExecutionContext, CanAwait, OnCompleteRunnable, TimeoutException, ExecutionException }
 import scala.concurrent.util.Duration
-import scala.util
 import scala.annotation.tailrec
 import scala.util.control.NonFatal
-//import scala.concurrent.NonDeterministic
 
 
 
@@ -41,7 +38,7 @@ private class CallbackRunnable[T](val executor: ExecutionContext, val onComplete
   }
 }
 
-object Promise {
+private[concurrent] object Promise {
 
   private def resolveEither[T](source: Either[Throwable, T]): Either[Throwable, T] = source match {
     case Left(t) => resolver(t)
diff --git a/src/library/scala/concurrent/ops.scala b/src/library/scala/concurrent/ops.scala
index 2cea29aefe..4de8f6cba3 100644
--- a/src/library/scala/concurrent/ops.scala
+++ b/src/library/scala/concurrent/ops.scala
@@ -15,7 +15,7 @@ import scala.util.control.Exception.allCatch
  *
  *  @author  Martin Odersky, Stepan Koltsov, Philipp Haller
  */
-@deprecated("Use `future` instead.", "2.10.0")
+@deprecated("Use `Future` instead.", "2.10.0")
 object ops
 {
   val defaultRunner: FutureTaskRunner = TaskRunners.threadRunner