Move implementation details to scala.async.internal._.

If we intend to keep CPS fallback around for any length of time
it should probably move there too.

1 files changed, 0 insertions, 94 deletions

diff --git a/src/main/scala/scala/async/Async.scala b/src/main/scala/scala/async/Async.scala
deleted file mode 100644
index 5f577cf..0000000
--- a/src/main/scala/scala/async/Async.scala
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
- */
-
-package scala.async
-
-import scala.language.experimental.macros
-import scala.reflect.macros.Context
-import scala.reflect.internal.annotations.compileTimeOnly
-import scala.tools.nsc.Global
-import language.reflectiveCalls
-import scala.concurrent.ExecutionContext
-
-object Async extends AsyncBase {
-
-  import scala.concurrent.Future
-
-  lazy val futureSystem = ScalaConcurrentFutureSystem
-  type FS = ScalaConcurrentFutureSystem.type
-
-  def async[T](body: T)(implicit execContext: ExecutionContext): Future[T] = macro asyncImpl[T]
-
-  override def asyncImpl[T: c.WeakTypeTag](c: Context)
-                                          (body: c.Expr[T])
-                                          (execContext: c.Expr[futureSystem.ExecContext]): c.Expr[Future[T]] = {
-    super.asyncImpl[T](c)(body)(execContext)
-  }
-}
-
-object AsyncId extends AsyncBase {
-  lazy val futureSystem = IdentityFutureSystem
-  type FS = IdentityFutureSystem.type
-
-  def async[T](body: T) = macro asyncIdImpl[T]
-
-  def asyncIdImpl[T: c.WeakTypeTag](c: Context)(body: c.Expr[T]): c.Expr[T] = asyncImpl[T](c)(body)(c.literalUnit)
-}
-
-/**
- * A base class for the `async` macro. Subclasses must provide:
- *
- * - Concrete types for a given future system
- * - Tree manipulations to create and complete the equivalent of Future and Promise
- * in that system.
- * - The `async` macro declaration itself, and a forwarder for the macro implementation.
- * (The latter is temporarily needed to workaround bug SI-6650 in the macro system)
- *
- * The default implementation, [[scala.async.Async]], binds the macro to `scala.concurrent._`.
- */
-abstract class AsyncBase {
-  self =>
-
-  type FS <: FutureSystem
-  val futureSystem: FS
-
-  /**
-   * A call to `await` must be nested in an enclosing `async` block.
-   *
-   * A call to `await` does not block the current thread, rather it is a delimiter
-   * used by the enclosing `async` macro. Code following the `await`
-   * call is executed asynchronously, when the argument of `await` has been completed.
-   *
-   * @param awaitable the future from which a value is awaited.
-   * @tparam T        the type of that value.
-   * @return          the value.
-   */
-  @compileTimeOnly("`await` must be enclosed in an `async` block")
-  def await[T](awaitable: futureSystem.Fut[T]): T = ???
-
-  protected[async] def fallbackEnabled = false
-
-  def asyncImpl[T: c.WeakTypeTag](c: Context)
-                                 (body: c.Expr[T])
-                                 (execContext: c.Expr[futureSystem.ExecContext]): c.Expr[futureSystem.Fut[T]] = {
-    import c.universe._
-
-    val asyncMacro = AsyncMacro(c, futureSystem)
-
-    val code = asyncMacro.asyncTransform[T](
-      body.tree.asInstanceOf[asyncMacro.global.Tree],
-      execContext.tree.asInstanceOf[asyncMacro.global.Tree],
-      fallbackEnabled)(implicitly[c.WeakTypeTag[T]].asInstanceOf[asyncMacro.global.WeakTypeTag[T]])
-
-    AsyncUtils.vprintln(s"async state machine transform expands to:\n ${code}")
-    c.Expr[futureSystem.Fut[T]](code.asInstanceOf[Tree])
-  }
-}
-
-/** Internal class used by the `async` macro; should not be manually extended by client code */
-abstract class StateMachine[Result, EC] extends (scala.util.Try[Any] => Unit) with (() => Unit) {
-  def result: Result
-
-  def execContext: EC
-}