Minimize the public API

 - Remove the CPS fallback version of async. That was not intended
   to be part of 1.0.
 - Lookup the await method beside the macro, rather than requiring
   all calls to go to AsyncBase.await.
 - Create a minimal version of Async that just contains await/async
   and delegates to the macro implementation in internal._
 - Add scaladoc.

7 files changed, 29 insertions, 17 deletions

diff --git a/src/main/scala/scala/async/internal/AsyncAnalysis.scala b/src/main/scala/scala/async/internal/AsyncAnalysis.scala
index 122109e..69e4c3c 100644
--- a/src/main/scala/scala/async/internal/AsyncAnalysis.scala
+++ b/src/main/scala/scala/async/internal/AsyncAnalysis.scala
@@ -18,13 +18,13 @@ trait AsyncAnalysis {
    *
    * Must be called on the original tree, not on the ANF transformed tree.
    */
-  def reportUnsupportedAwaits(tree: Tree, report: Boolean): Boolean = {
-    val analyzer = new UnsupportedAwaitAnalyzer(report)
+  def reportUnsupportedAwaits(tree: Tree): Unit = {
+    val analyzer = new UnsupportedAwaitAnalyzer
     analyzer.traverse(tree)
     analyzer.hasUnsupportedAwaits
   }
 
-  private class UnsupportedAwaitAnalyzer(report: Boolean) extends AsyncTraverser {
+  private class UnsupportedAwaitAnalyzer extends AsyncTraverser {
     var hasUnsupportedAwaits = false
 
     override def nestedClass(classDef: ClassDef) {
@@ -87,8 +87,7 @@ trait AsyncAnalysis {
 
     private def reportError(pos: Position, msg: String) {
       hasUnsupportedAwaits = true
-      if (report)
-        abort(pos, msg)
+      abort(pos, msg)
     }
   }
 }
diff --git a/src/main/scala/scala/async/internal/AsyncBase.scala b/src/main/scala/scala/async/internal/AsyncBase.scala
index e44c27f..89d5a4d 100644
--- a/src/main/scala/scala/async/internal/AsyncBase.scala
+++ b/src/main/scala/scala/async/internal/AsyncBase.scala
@@ -61,6 +61,11 @@ abstract class AsyncBase {
     c.Expr[futureSystem.Fut[T]](code)
   }
 
+  protected[async] def awaitMethod(u: Universe)(asyncMacroSymbol: u.Symbol): u.Symbol = {
+    import u._
+    asyncMacroSymbol.owner.typeSignature.member(newTermName("await"))
+  }  
+  
   protected[async] def nullOut(u: Universe)(name: u.Expr[String], v: u.Expr[Any]): u.Expr[Unit] =
     u.reify { () }
 }
diff --git a/src/main/scala/scala/async/internal/AsyncId.scala b/src/main/scala/scala/async/internal/AsyncId.scala
index 7f7807f..c123675 100644
--- a/src/main/scala/scala/async/internal/AsyncId.scala
+++ b/src/main/scala/scala/async/internal/AsyncId.scala
@@ -78,7 +78,5 @@ object IdentityFutureSystem extends FutureSystem {
       prom.splice.a = value.splice.get
       Expr[Unit](Literal(Constant(()))).splice
     }
-
-    def castTo[A: WeakTypeTag](future: Expr[Fut[Any]]): Expr[Fut[A]] = ???
   }
 }
diff --git a/src/main/scala/scala/async/internal/AsyncTransform.scala b/src/main/scala/scala/async/internal/AsyncTransform.scala
index 27d95a4..cdae074 100644
--- a/src/main/scala/scala/async/internal/AsyncTransform.scala
+++ b/src/main/scala/scala/async/internal/AsyncTransform.scala
@@ -15,7 +15,7 @@ trait AsyncTransform {
     // This implicit propagates the annotated type in the type tag.
     implicit val uncheckedBoundsResultTag: WeakTypeTag[T] = WeakTypeTag[T](rootMirror, FixedMirrorTypeCreator(rootMirror, uncheckedBounds(resultType.tpe)))
 
-    reportUnsupportedAwaits(body, report = !cpsFallbackEnabled)
+    reportUnsupportedAwaits(body)
 
     // Transform to A-normal form:
     //  - no await calls in qualifiers or arguments,
diff --git a/src/main/scala/scala/async/internal/FutureSystem.scala b/src/main/scala/scala/async/internal/FutureSystem.scala
index f7fdc49..9fe88b4 100644
--- a/src/main/scala/scala/async/internal/FutureSystem.scala
+++ b/src/main/scala/scala/async/internal/FutureSystem.scala
@@ -51,9 +51,6 @@ trait FutureSystem {
 
     def spawn(tree: Tree, execContext: Tree): Tree =
       future(Expr[Unit](tree))(Expr[ExecContext](execContext)).tree
-
-    // This is only needed in `AsyncBaseWithCPSFallback` and should be removed once CPS fall-back support is dropped.
-    def castTo[A: WeakTypeTag](future: Expr[Fut[Any]]): Expr[Fut[A]]
   }
 
   def mkOps(c: SymbolTable): Ops { val universe: c.type }
@@ -96,9 +93,5 @@ object ScalaConcurrentFutureSystem extends FutureSystem {
       prom.splice.complete(value.splice)
       Expr[Unit](Literal(Constant(()))).splice
     }
-
-    def castTo[A: WeakTypeTag](future: Expr[Fut[Any]]): Expr[Fut[A]] = reify {
-      future.splice.asInstanceOf[Fut[A]]
-    }
   }
 }
diff --git a/src/main/scala/scala/async/internal/ScalaConcurrentAsync.scala b/src/main/scala/scala/async/internal/ScalaConcurrentAsync.scala
new file mode 100644
index 0000000..4e1a0af
--- /dev/null
+++ b/src/main/scala/scala/async/internal/ScalaConcurrentAsync.scala
@@ -0,0 +1,18 @@
+package scala
+package async
+package internal
+
+import scala.language.experimental.macros
+import scala.reflect.macros.Context
+import scala.concurrent.Future
+
+object ScalaConcurrentAsync extends AsyncBase {
+  type FS = ScalaConcurrentFutureSystem.type
+  val futureSystem: FS = ScalaConcurrentFutureSystem
+
+  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)
+  }
+}
diff --git a/src/main/scala/scala/async/internal/TransformUtils.scala b/src/main/scala/scala/async/internal/TransformUtils.scala
index 663ca45..9722610 100644
--- a/src/main/scala/scala/async/internal/TransformUtils.scala
+++ b/src/main/scala/scala/async/internal/TransformUtils.scala
@@ -89,8 +89,7 @@ private[async] trait TransformUtils {
     val Try_isFailure = TryClass.typeSignature.member(newTermName("isFailure")).ensuring(_ != NoSymbol)
     val TryAnyType    = appliedType(TryClass.toType, List(definitions.AnyTpe))
     val NonFatalClass = rootMirror.staticModule("scala.util.control.NonFatal")
-    val AsyncClass    = rootMirror.staticClass("scala.async.internal.AsyncBase")
-    val Async_await   = AsyncClass.typeSignature.member(newTermName("await")).ensuring(_ != NoSymbol)
+    val Async_await   = asyncBase.awaitMethod(global)(macroApplication.symbol).ensuring(_ != NoSymbol)
   }
 
   def isSafeToInline(tree: Tree) = {