Shuffle a bit more code around.

3 files changed, 19 insertions, 32 deletions

diff --git a/src/main/scala/scala/async/Async.scala b/src/main/scala/scala/async/Async.scala
index cdeadd8..2d7f324 100644
--- a/src/main/scala/scala/async/Async.scala
+++ b/src/main/scala/scala/async/Async.scala
@@ -10,7 +10,7 @@ import scala.collection.mutable.ListBuffer
 import scala.concurrent.{Future, Promise, ExecutionContext, future}
 import ExecutionContext.Implicits.global
 import scala.util.control.NonFatal
-import scala.util.continuations.{shift, reset, cpsParam}
+import AsyncUtils.vprintln
 
 
 /*
@@ -45,7 +45,7 @@ object AsyncId extends AsyncBase {
  *
  * The default implementation, [[scala.async.Async]], binds the macro to `scala.concurrent._`.
  */
-abstract class AsyncBase extends AsyncUtils {
+abstract class AsyncBase {
   self =>
 
   type FS <: FutureSystem
@@ -76,8 +76,6 @@ abstract class AsyncBase extends AsyncUtils {
     import builder.name
     import builder.futureSystemOps
 
-    val awaitMethod = awaitSym(c)
-
     body.tree match {
       case Block(stats, expr) =>
         val asyncBlockBuilder = new builder.AsyncBlockBuilder(stats, expr, 0, 1000, 1000, Map())
diff --git a/src/main/scala/scala/async/AsyncUtils.scala b/src/main/scala/scala/async/AsyncUtils.scala
index d288d34..3b590be 100644
--- a/src/main/scala/scala/async/AsyncUtils.scala
+++ b/src/main/scala/scala/async/AsyncUtils.scala
@@ -3,29 +3,13 @@
  */
 package scala.async
 
-import scala.reflect.macros.Context
-
 /*
  * @author Philipp Haller
  */
-trait AsyncUtils {
+object AsyncUtils {
 
-  val verbose = false
+  private val verbose = false
   
-  protected def vprintln(s: Any): Unit = if (verbose)
+  private[async] def vprintln(s: Any): Unit = if (verbose)
     println("[async] "+s)
-  
-  /* Symbol of the `Async.await` method in context `c`.
-   */
-  protected def awaitSym(c: Context): c.universe.Symbol = {
-    val asyncMod = c.mirror.staticModule("scala.async.Async")
-    val tpe = asyncMod.moduleClass.asType.toType
-    tpe.member(c.universe.newTermName("await"))
-  }
-  
-  protected def awaitCpsSym(c: Context): c.universe.Symbol = {
-    val asyncMod = c.mirror.staticModule("scala.async.Async")
-    val tpe = asyncMod.moduleClass.asType.toType
-    tpe.member(c.universe.newTermName("awaitCps"))
-  }
 }
diff --git a/src/main/scala/scala/async/ExprBuilder.scala b/src/main/scala/scala/async/ExprBuilder.scala
index e298a05..f360c92 100644
--- a/src/main/scala/scala/async/ExprBuilder.scala
+++ b/src/main/scala/scala/async/ExprBuilder.scala
@@ -4,13 +4,14 @@
 package scala.async
 
 import scala.reflect.macros.Context
-import scala.collection.mutable.{ListBuffer, Builder}
+import scala.collection.mutable.ListBuffer
 import concurrent.Future
+import AsyncUtils.vprintln
 
 /*
  * @author Philipp Haller
  */
-final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSystem: FS) extends AsyncUtils {
+final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSystem: FS) {
   builder =>
 
   lazy val futureSystemOps = futureSystem.mkOps(c)
@@ -21,7 +22,9 @@ final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSy
 
   object name {
     def suffix(string: String) = string + "$async"
+
     def expandedTermName(prefix: String) = newTermName(suffix(prefix))
+
     def expandedTypeName(prefix: String) = newTypeName(suffix(prefix))
 
     val state = expandedTermName("state")
@@ -37,17 +40,13 @@ final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSy
 
   private def resetDuplicate(tree: Tree) = c.resetAllAttrs(tree.duplicate)
 
-  private val awaitMethod = awaitSym(c)
-
   private def mkResumeApply = Apply(Ident(name.resume), Nil)
 
   def mkStateTree(nextState: Int): c.Tree =
     mkStateTree(c.literal(nextState).tree)
 
   def mkStateTree(nextState: Tree): c.Tree =
-    Assign(
-      Ident(name.state),
-      nextState)
+    Assign(Ident(name.state), nextState)
 
   def defaultValue(tpe: Type): Literal = {
     val defaultValue: Any =
@@ -307,7 +306,7 @@ final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSy
 
     /* TODO Fall back to CPS plug-in if tree contains an `await` call. */
     def checkForUnsupportedAwait(tree: c.Tree) = if (tree exists {
-      case Apply(fun, _) if fun.symbol == awaitMethod => true
+      case Apply(fun, _) if fun.symbol == Async_await => true
       case _ => false
     }) c.abort(tree.pos, "await unsupported in this position") //throw new FallbackToCpsException
 
@@ -322,7 +321,7 @@ final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSy
     // populate asyncStates
     for (stat <- stats) stat match {
       // the val name = await(..) pattern
-      case ValDef(mods, name, tpt, Apply(fun, args)) if fun.symbol == awaitMethod =>
+      case ValDef(mods, name, tpt, Apply(fun, args)) if fun.symbol == Async_await =>
         val newName = c.fresh(name)
         toRename += (stat.symbol -> newName)
 
@@ -453,5 +452,11 @@ final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSy
 
     val TryClass = c.mirror.staticClass("scala.util.Try")
     val NonFatalClass = c.mirror.staticModule("scala.util.control.NonFatal")
+
+    val Async_await = {
+      val asyncMod = c.mirror.staticModule("scala.async.Async")
+      val tpe = asyncMod.moduleClass.asType.toType
+      tpe.member(c.universe.newTermName("await"))
+    }
   }
 }