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.

27 files changed, 166 insertions, 140 deletions

diff --git a/src/main/scala/scala/async/AsyncBase.scala b/src/main/scala/scala/async/AsyncBase.scala
new file mode 100644
index 0000000..ff04a57
--- /dev/null
+++ b/src/main/scala/scala/async/AsyncBase.scala
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.async
+
+import scala.language.experimental.macros
+import scala.reflect.macros.Context
+import scala.concurrent.{Future, ExecutionContext}
+import scala.async.internal.{AsyncBase, ScalaConcurrentFutureSystem}
+
+object Async extends AsyncBase {
+  type FS = ScalaConcurrentFutureSystem.type
+  val futureSystem: FS = ScalaConcurrentFutureSystem
+
+  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)
+  }
+}
diff --git a/src/main/scala/scala/async/StateMachine.scala b/src/main/scala/scala/async/StateMachine.scala
new file mode 100644
index 0000000..823df71
--- /dev/null
+++ b/src/main/scala/scala/async/StateMachine.scala
@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.async
+
+/** 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
+}
diff --git a/src/main/scala/scala/async/continuations/AsyncBaseWithCPSFallback.scala b/src/main/scala/scala/async/continuations/AsyncBaseWithCPSFallback.scala
index 7abc6e8..2902558 100644
--- a/src/main/scala/scala/async/continuations/AsyncBaseWithCPSFallback.scala
+++ b/src/main/scala/scala/async/continuations/AsyncBaseWithCPSFallback.scala
@@ -9,8 +9,9 @@ import scala.language.experimental.macros
 
 import scala.reflect.macros.Context
 import scala.util.continuations._
+import scala.async.internal.{AsyncMacro, AsyncUtils}
 
-trait AsyncBaseWithCPSFallback extends AsyncBase {
+trait AsyncBaseWithCPSFallback extends internal.AsyncBase {
 
   /* Fall-back for `await` using CPS plugin.
    * 
diff --git a/src/main/scala/scala/async/continuations/ScalaConcurrentCPSFallback.scala b/src/main/scala/scala/async/continuations/ScalaConcurrentCPSFallback.scala
index 018ad05..f864ad6 100644
--- a/src/main/scala/scala/async/continuations/ScalaConcurrentCPSFallback.scala
+++ b/src/main/scala/scala/async/continuations/ScalaConcurrentCPSFallback.scala
@@ -7,6 +7,7 @@ package continuations
 
 import scala.util.continuations._
 import scala.concurrent.{Future, Promise, ExecutionContext}
+import scala.async.internal.ScalaConcurrentFutureSystem
 
 trait ScalaConcurrentCPSFallback {
   self: AsyncBaseWithCPSFallback =>
diff --git a/src/main/scala/scala/async/AnfTransform.scala b/src/main/scala/scala/async/internal/AnfTransform.scala
index 14263da..80f8161 100644
--- a/src/main/scala/scala/async/AnfTransform.scala
+++ b/src/main/scala/scala/async/internal/AnfTransform.scala
@@ -3,9 +3,10 @@
  * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package scala.async
+package scala.async.internal
 
 import scala.tools.nsc.Global
+import scala.Predef._
 
 private[async] trait AnfTransform {
   self: AsyncMacro =>
diff --git a/src/main/scala/scala/async/AsyncAnalysis.scala b/src/main/scala/scala/async/internal/AsyncAnalysis.scala
index 424318e..62842c9 100644
--- a/src/main/scala/scala/async/AsyncAnalysis.scala
+++ b/src/main/scala/scala/async/internal/AsyncAnalysis.scala
@@ -2,7 +2,7 @@
  * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package scala.async
+package scala.async.internal
 
 import scala.reflect.macros.Context
 import scala.collection.mutable
diff --git a/src/main/scala/scala/async/Async.scala b/src/main/scala/scala/async/internal/AsyncBase.scala
index 5f577cf..2f7e38d 100644
--- a/src/main/scala/scala/async/Async.scala
+++ b/src/main/scala/scala/async/internal/AsyncBase.scala
@@ -2,39 +2,10 @@
  * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package scala.async
+package scala.async.internal
 
-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)
-}
+import scala.reflect.macros.Context
 
 /**
  * A base class for the `async` macro. Subclasses must provide:
@@ -85,10 +56,3 @@ abstract class AsyncBase {
     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
-}
diff --git a/src/main/scala/scala/async/internal/AsyncId.scala b/src/main/scala/scala/async/internal/AsyncId.scala
new file mode 100644
index 0000000..394f587
--- /dev/null
+++ b/src/main/scala/scala/async/internal/AsyncId.scala
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.async.internal
+
+import language.experimental.macros
+import scala.reflect.macros.Context
+import scala.reflect.internal.SymbolTable
+
+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 trivial implementation of [[FutureSystem]] that performs computations
+ * on the current thread. Useful for testing.
+ */
+object IdentityFutureSystem extends FutureSystem {
+
+  class Prom[A](var a: A)
+
+  type Fut[A] = A
+  type ExecContext = Unit
+
+  def mkOps(c: SymbolTable): Ops {val universe: c.type} = new Ops {
+    val universe: c.type = c
+
+    import universe._
+
+    def execContext: Expr[ExecContext] = Expr[Unit](Literal(Constant(())))
+
+    def promType[A: WeakTypeTag]: Type = weakTypeOf[Prom[A]]
+    def execContextType: Type = weakTypeOf[Unit]
+
+    def createProm[A: WeakTypeTag]: Expr[Prom[A]] = reify {
+      new Prom(null.asInstanceOf[A])
+    }
+
+    def promiseToFuture[A: WeakTypeTag](prom: Expr[Prom[A]]) = reify {
+      prom.splice.a
+    }
+
+    def future[A: WeakTypeTag](t: Expr[A])(execContext: Expr[ExecContext]) = t
+
+    def onComplete[A, U](future: Expr[Fut[A]], fun: Expr[scala.util.Try[A] => U],
+                         execContext: Expr[ExecContext]): Expr[Unit] = reify {
+      fun.splice.apply(util.Success(future.splice))
+      Expr[Unit](Literal(Constant(()))).splice
+    }
+
+    def completeProm[A](prom: Expr[Prom[A]], value: Expr[scala.util.Try[A]]): Expr[Unit] = reify {
+      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/AsyncMacro.scala b/src/main/scala/scala/async/internal/AsyncMacro.scala
index 8827351..6b7d031 100644
--- a/src/main/scala/scala/async/AsyncMacro.scala
+++ b/src/main/scala/scala/async/internal/AsyncMacro.scala
@@ -1,4 +1,4 @@
-package scala.async
+package scala.async.internal
 
 import scala.tools.nsc.Global
 import scala.tools.nsc.transform.TypingTransformers
diff --git a/src/main/scala/scala/async/AsyncTransform.scala b/src/main/scala/scala/async/internal/AsyncTransform.scala
index 129f88e..bdc8664 100644
--- a/src/main/scala/scala/async/AsyncTransform.scala
+++ b/src/main/scala/scala/async/internal/AsyncTransform.scala
@@ -1,4 +1,4 @@
-package scala.async
+package scala.async.internal
 
 trait AsyncTransform {
   self: AsyncMacro =>
diff --git a/src/main/scala/scala/async/AsyncUtils.scala b/src/main/scala/scala/async/internal/AsyncUtils.scala
index 1ade5f0..8700bd6 100644
--- a/src/main/scala/scala/async/AsyncUtils.scala
+++ b/src/main/scala/scala/async/internal/AsyncUtils.scala
@@ -1,7 +1,7 @@
 /*
  * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
  */
-package scala.async
+package scala.async.internal
 
 object AsyncUtils {
 
diff --git a/src/main/scala/scala/async/ExprBuilder.scala b/src/main/scala/scala/async/internal/ExprBuilder.scala
index a3837d3..1ce30e6 100644
--- a/src/main/scala/scala/async/ExprBuilder.scala
+++ b/src/main/scala/scala/async/internal/ExprBuilder.scala
@@ -1,7 +1,7 @@
 /*
  * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
  */
-package scala.async
+package scala.async.internal
 
 import scala.reflect.macros.Context
 import scala.collection.mutable.ListBuffer
@@ -9,6 +9,7 @@ import collection.mutable
 import language.existentials
 import scala.reflect.api.Universe
 import scala.reflect.api
+import scala.Some
 
 trait ExprBuilder {
   builder: AsyncMacro =>
diff --git a/src/main/scala/scala/async/FutureSystem.scala b/src/main/scala/scala/async/internal/FutureSystem.scala
index 0c04296..101b7bf 100644
--- a/src/main/scala/scala/async/FutureSystem.scala
+++ b/src/main/scala/scala/async/internal/FutureSystem.scala
@@ -1,7 +1,7 @@
 /*
  * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
  */
-package scala.async
+package scala.async.internal
 
 import scala.language.higherKinds
 
@@ -15,7 +15,7 @@ import scala.reflect.internal.SymbolTable
  * customize the code generation.
  *
  * The API mirrors that of `scala.concurrent.Future`, see the instance
- * [[scala.async.ScalaConcurrentFutureSystem]] for an example of how
+ * [[ScalaConcurrentFutureSystem]] for an example of how
  * to implement this.
  */
 trait FutureSystem {
@@ -61,7 +61,6 @@ trait FutureSystem {
   def mkOps(c: SymbolTable): Ops { val universe: c.type }
 }
 
-
 object ScalaConcurrentFutureSystem extends FutureSystem {
 
   import scala.concurrent._
@@ -105,49 +104,3 @@ object ScalaConcurrentFutureSystem extends FutureSystem {
     }
   }
 }
-
-/**
- * A trivial implementation of [[scala.async.FutureSystem]] that performs computations
- * on the current thread. Useful for testing.
- */
-object IdentityFutureSystem extends FutureSystem {
-
-  class Prom[A](var a: A)
-
-  type Fut[A] = A
-  type ExecContext = Unit
-
-  def mkOps(c: SymbolTable): Ops {val universe: c.type} = new Ops {
-    val universe: c.type = c
-
-    import universe._
-
-    def execContext: Expr[ExecContext] = Expr[Unit](Literal(Constant(())))
-
-    def promType[A: WeakTypeTag]: Type = weakTypeOf[Prom[A]]
-    def execContextType: Type = weakTypeOf[Unit]
-
-    def createProm[A: WeakTypeTag]: Expr[Prom[A]] = reify {
-      new Prom(null.asInstanceOf[A])
-    }
-
-    def promiseToFuture[A: WeakTypeTag](prom: Expr[Prom[A]]) = reify {
-      prom.splice.a
-    }
-
-    def future[A: WeakTypeTag](t: Expr[A])(execContext: Expr[ExecContext]) = t
-
-    def onComplete[A, U](future: Expr[Fut[A]], fun: Expr[scala.util.Try[A] => U],
-                         execContext: Expr[ExecContext]): Expr[Unit] = reify {
-      fun.splice.apply(util.Success(future.splice))
-      Expr[Unit](Literal(Constant(()))).splice
-    }
-
-    def completeProm[A](prom: Expr[Prom[A]], value: Expr[scala.util.Try[A]]): Expr[Unit] = reify {
-      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/Lifter.scala b/src/main/scala/scala/async/internal/Lifter.scala
index 52ce47d..f49dcbb 100644
--- a/src/main/scala/scala/async/Lifter.scala
+++ b/src/main/scala/scala/async/internal/Lifter.scala
@@ -1,4 +1,4 @@
-package scala.async
+package scala.async.internal
 
 trait Lifter {
   self: AsyncMacro =>
diff --git a/src/main/scala/scala/async/StateAssigner.scala b/src/main/scala/scala/async/internal/StateAssigner.scala
index bc60a6d..cdde7a4 100644
--- a/src/main/scala/scala/async/StateAssigner.scala
+++ b/src/main/scala/scala/async/internal/StateAssigner.scala
@@ -2,7 +2,7 @@
  * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package scala.async
+package scala.async.internal
 
 private[async] final class StateAssigner {
   private var current = -1
@@ -11,4 +11,4 @@ private[async] final class StateAssigner {
     current += 1
     current
   }
-}
\ No newline at end of file
+}
diff --git a/src/main/scala/scala/async/TransformUtils.scala b/src/main/scala/scala/async/internal/TransformUtils.scala
index d69d03a..2582c91 100644
--- a/src/main/scala/scala/async/TransformUtils.scala
+++ b/src/main/scala/scala/async/internal/TransformUtils.scala
@@ -1,7 +1,7 @@
 /*
  * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
  */
-package scala.async
+package scala.async.internal
 
 import scala.reflect.macros.Context
 import reflect.ClassTag
@@ -89,7 +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.AsyncBase")
+    val AsyncClass    = rootMirror.staticClass("scala.async.internal.AsyncBase")
     val Async_await   = AsyncClass.typeSignature.member(newTermName("await")).ensuring(_ != NoSymbol)
   }
 
diff --git a/src/test/scala/scala/async/TreeInterrogation.scala b/src/test/scala/scala/async/TreeInterrogation.scala
index 86a7157..f1cb251 100644
--- a/src/test/scala/scala/async/TreeInterrogation.scala
+++ b/src/test/scala/scala/async/TreeInterrogation.scala
@@ -7,6 +7,7 @@ package scala.async
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 import org.junit.Test
+import scala.async.internal.AsyncId
 import AsyncId._
 import tools.reflect.ToolBox
 
@@ -17,7 +18,7 @@ class TreeInterrogation {
     val cm = reflect.runtime.currentMirror
     val tb = mkToolbox(s"-cp ${toolboxClasspath}")
     val tree = tb.parse(
-      """| import _root_.scala.async.AsyncId._
+      """| import _root_.scala.async.internal.AsyncId._
         | async {
         |   val x = await(1)
         |   val y = x * 2
@@ -70,7 +71,7 @@ object TreeInterrogation extends App {
     val tb = mkToolbox("-cp ${toolboxClasspath} -Xprint:typer -uniqid")
     import scala.async.Async._
     val tree = tb.parse(
-      """ import _root_.scala.async.AsyncId.{async, await}
+      """ import _root_.scala.async.internal.AsyncId.{async, await}
         | def foo[T](a0: Int)(b0: Int*) = s"a0 = $a0, b0 = ${b0.head}"
         | val res = async {
         |   var i = 0
diff --git a/src/test/scala/scala/async/neg/LocalClasses0Spec.scala b/src/test/scala/scala/async/neg/LocalClasses0Spec.scala
index dcd9bb8..6ebc9ca 100644
--- a/src/test/scala/scala/async/neg/LocalClasses0Spec.scala
+++ b/src/test/scala/scala/async/neg/LocalClasses0Spec.scala
@@ -8,12 +8,13 @@ package neg
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 import org.junit.Test
+import scala.async.internal.AsyncId
 
 @RunWith(classOf[JUnit4])
 class LocalClasses0Spec {
   @Test
   def localClassCrashIssue16() {
-    import scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     async {
       class B { def f = 1 }
       await(new B()).f
diff --git a/src/test/scala/scala/async/neg/NakedAwait.scala b/src/test/scala/scala/async/neg/NakedAwait.scala
index b0d5fde..aa62d37 100644
--- a/src/test/scala/scala/async/neg/NakedAwait.scala
+++ b/src/test/scala/scala/async/neg/NakedAwait.scala
@@ -25,7 +25,7 @@ class NakedAwait {
   def `await not allowed in by-name argument`() {
     expectError("await must not be used under a by-name argument.") {
       """
-        | import _root_.scala.async.AsyncId._
+        | import _root_.scala.async.internal.AsyncId._
         | def foo(a: Int)(b: => Int) = 0
         | async { foo(0)(await(0)) }
       """.stripMargin
@@ -36,7 +36,7 @@ class NakedAwait {
   def `await not allowed in boolean short circuit argument 1`() {
     expectError("await must not be used under a by-name argument.") {
       """
-        | import _root_.scala.async.AsyncId._
+        | import _root_.scala.async.internal.AsyncId._
         | async { true && await(false) }
       """.stripMargin
     }
@@ -46,7 +46,7 @@ class NakedAwait {
   def `await not allowed in boolean short circuit argument 2`() {
     expectError("await must not be used under a by-name argument.") {
       """
-        | import _root_.scala.async.AsyncId._
+        | import _root_.scala.async.internal.AsyncId._
         | async { true || await(false) }
       """.stripMargin
     }
@@ -56,7 +56,7 @@ class NakedAwait {
   def nestedObject() {
     expectError("await must not be used under a nested object.") {
       """
-        | import _root_.scala.async.AsyncId._
+        | import _root_.scala.async.internal.AsyncId._
         | async { object Nested { await(false) } }
       """.stripMargin
     }
@@ -66,7 +66,7 @@ class NakedAwait {
   def nestedTrait() {
     expectError("await must not be used under a nested trait.") {
       """
-        | import _root_.scala.async.AsyncId._
+        | import _root_.scala.async.internal.AsyncId._
         | async { trait Nested { await(false) } }
       """.stripMargin
     }
@@ -76,7 +76,7 @@ class NakedAwait {
   def nestedClass() {
     expectError("await must not be used under a nested class.") {
       """
-        | import _root_.scala.async.AsyncId._
+        | import _root_.scala.async.internal.AsyncId._
         | async { class Nested { await(false) } }
       """.stripMargin
     }
@@ -86,7 +86,7 @@ class NakedAwait {
   def nestedFunction() {
     expectError("await must not be used under a nested function.") {
       """
-        | import _root_.scala.async.AsyncId._
+        | import _root_.scala.async.internal.AsyncId._
         | async { () => { await(false) } }
       """.stripMargin
     }
@@ -96,7 +96,7 @@ class NakedAwait {
   def nestedPatMatFunction() {
     expectError("await must not be used under a nested class.") { // TODO more specific error message
       """
-        | import _root_.scala.async.AsyncId._
+        | import _root_.scala.async.internal.AsyncId._
         | async { { case x => { await(false) } } : PartialFunction[Any, Any] }
       """.stripMargin
     }
@@ -106,7 +106,7 @@ class NakedAwait {
   def tryBody() {
     expectError("await must not be used under a try/catch.") {
       """
-        | import _root_.scala.async.AsyncId._
+        | import _root_.scala.async.internal.AsyncId._
         | async { try { await(false) } catch { case _ => } }
       """.stripMargin
     }
@@ -116,7 +116,7 @@ class NakedAwait {
   def catchBody() {
     expectError("await must not be used under a try/catch.") {
       """
-        | import _root_.scala.async.AsyncId._
+        | import _root_.scala.async.internal.AsyncId._
         | async { try { () } catch { case _ => await(false) } }
       """.stripMargin
     }
@@ -126,7 +126,7 @@ class NakedAwait {
   def finallyBody() {
     expectError("await must not be used under a try/catch.") {
       """
-        | import _root_.scala.async.AsyncId._
+        | import _root_.scala.async.internal.AsyncId._
         | async { try { () } finally { await(false) } }
       """.stripMargin
     }
@@ -136,7 +136,7 @@ class NakedAwait {
   def nestedMethod() {
     expectError("await must not be used under a nested method.") {
       """
-        | import _root_.scala.async.AsyncId._
+        | import _root_.scala.async.internal.AsyncId._
         | async { def foo = await(false) }
       """.stripMargin
     }
@@ -146,7 +146,7 @@ class NakedAwait {
   def returnIllegal() {
     expectError("return is illegal") {
       """
-        | import _root_.scala.async.AsyncId._
+        | import _root_.scala.async.internal.AsyncId._
         | def foo(): Any = async { return false }
         | ()
         |
@@ -158,7 +158,7 @@ class NakedAwait {
   def lazyValIllegal() {
     expectError("lazy vals are illegal") {
       """
-        | import _root_.scala.async.AsyncId._
+        | import _root_.scala.async.internal.AsyncId._
         | def foo(): Any = async { val x = { lazy val y = 0; y } }
         | ()
         |
diff --git a/src/test/scala/scala/async/run/anf/AnfTransformSpec.scala b/src/test/scala/scala/async/run/anf/AnfTransformSpec.scala
index abce3ce..e389a19 100644
--- a/src/test/scala/scala/async/run/anf/AnfTransformSpec.scala
+++ b/src/test/scala/scala/async/run/anf/AnfTransformSpec.scala
@@ -13,6 +13,7 @@ import scala.async.Async.{async, await}
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
+import scala.async.internal.AsyncId
 
 
 class AnfTestClass {
@@ -114,8 +115,6 @@ class AnfTransformSpec {
 
   @Test
   def `inlining block does not produce duplicate definition`() {
-    import scala.async.AsyncId
-
     AsyncId.async {
       val f = 12
       val x = AsyncId.await(f)
@@ -132,8 +131,6 @@ class AnfTransformSpec {
 
   @Test
   def `inlining block in tail position does not produce duplicate definition`() {
-    import scala.async.AsyncId
-
     AsyncId.async {
       val f = 12
       val x = AsyncId.await(f)
@@ -176,7 +173,7 @@ class AnfTransformSpec {
   @Test
   def nestedAwaitAsBareExpression() {
     import ExecutionContext.Implicits.global
-    import _root_.scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     val result = async {
       await(await("").isEmpty)
     }
@@ -186,7 +183,7 @@ class AnfTransformSpec {
   @Test
   def nestedAwaitInBlock() {
     import ExecutionContext.Implicits.global
-    import _root_.scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     val result = async {
       ()
       await(await("").isEmpty)
@@ -197,7 +194,7 @@ class AnfTransformSpec {
   @Test
   def nestedAwaitInIf() {
     import ExecutionContext.Implicits.global
-    import _root_.scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     val result = async {
       if ("".isEmpty)
         await(await("").isEmpty)
@@ -208,7 +205,7 @@ class AnfTransformSpec {
 
   @Test
   def byNameExpressionsArentLifted() {
-    import _root_.scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     def foo(ignored: => Any, b: Int) = b
     val result = async {
       foo(???, await(1))
@@ -218,7 +215,7 @@ class AnfTransformSpec {
 
   @Test
   def evaluationOrderRespected() {
-    import scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     def foo(a: Int, b: Int) = (a, b)
     val result = async {
       var i = 0
@@ -233,7 +230,7 @@ class AnfTransformSpec {
 
   @Test
   def awaitInNonPrimaryParamSection1() {
-    import _root_.scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     def foo(a0: Int)(b0: Int) = s"a0 = $a0, b0 = $b0"
     val res = async {
       var i = 0
@@ -245,7 +242,7 @@ class AnfTransformSpec {
 
   @Test
   def awaitInNonPrimaryParamSection2() {
-    import _root_.scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     def foo[T](a0: Int)(b0: Int*) = s"a0 = $a0, b0 = ${b0.head}"
     val res = async {
       var i = 0
@@ -257,7 +254,7 @@ class AnfTransformSpec {
 
   @Test
   def awaitInNonPrimaryParamSectionWithLazy1() {
-    import _root_.scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     def foo[T](a: => Int)(b: Int) = b
     val res = async {
       def get = async {0}
@@ -268,7 +265,7 @@ class AnfTransformSpec {
 
   @Test
   def awaitInNonPrimaryParamSectionWithLazy2() {
-    import _root_.scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     def foo[T](a: Int)(b: => Int) = a
     val res = async {
       def get = async {0}
@@ -279,7 +276,7 @@ class AnfTransformSpec {
 
   @Test
   def awaitWithLazy() {
-    import _root_.scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     def foo[T](a: Int, b: => Int) = a
     val res = async {
       def get = async {0}
@@ -290,7 +287,7 @@ class AnfTransformSpec {
 
   @Test
   def awaitOkInReciever() {
-    import scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     class Foo { def bar(a: Int)(b: Int) = a + b }
     async {
       await(async(new Foo)).bar(1)(2)
@@ -299,7 +296,7 @@ class AnfTransformSpec {
 
   @Test
   def namedArgumentsRespectEvaluationOrder() {
-    import scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     def foo(a: Int, b: Int) = (a, b)
     val result = async {
       var i = 0
@@ -314,7 +311,7 @@ class AnfTransformSpec {
 
   @Test
   def namedAndDefaultArgumentsRespectEvaluationOrder() {
-    import scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     var i = 0
     def next() = {
       i += 1;
@@ -332,7 +329,7 @@ class AnfTransformSpec {
 
   @Test
   def repeatedParams1() {
-    import scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     var i = 0
     def foo(a: Int, b: Int*) = b.toList
     def id(i: Int) = i
@@ -343,7 +340,7 @@ class AnfTransformSpec {
 
   @Test
   def repeatedParams2() {
-    import scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     var i = 0
     def foo(a: Int, b: Int*) = b.toList
     def id(i: Int) = i
diff --git a/src/test/scala/scala/async/run/hygiene/Hygiene.scala b/src/test/scala/scala/async/run/hygiene/Hygiene.scala
index 9d1df21..8081ee7 100644
--- a/src/test/scala/scala/async/run/hygiene/Hygiene.scala
+++ b/src/test/scala/scala/async/run/hygiene/Hygiene.scala
@@ -9,11 +9,12 @@ package hygiene
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
+import scala.async.internal.AsyncId
 
 @RunWith(classOf[JUnit4])
 class HygieneSpec {
 
-  import scala.async.AsyncId.{async, await}
+  import AsyncId.{async, await}
 
   @Test
   def `is hygenic`() {
diff --git a/src/test/scala/scala/async/run/ifelse0/IfElse0.scala b/src/test/scala/scala/async/run/ifelse0/IfElse0.scala
index e2b1ca6..fc438a1 100644
--- a/src/test/scala/scala/async/run/ifelse0/IfElse0.scala
+++ b/src/test/scala/scala/async/run/ifelse0/IfElse0.scala
@@ -13,6 +13,7 @@ import scala.async.Async.{async, await}
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 import org.junit.Test
+import scala.async.internal.AsyncId
 
 
 class TestIfElseClass {
diff --git a/src/test/scala/scala/async/run/ifelse0/WhileSpec.scala b/src/test/scala/scala/async/run/ifelse0/WhileSpec.scala
index 1f1033a..b8d88fb 100644
--- a/src/test/scala/scala/async/run/ifelse0/WhileSpec.scala
+++ b/src/test/scala/scala/async/run/ifelse0/WhileSpec.scala
@@ -9,6 +9,7 @@ package ifelse0
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 import org.junit.Test
+import scala.async.internal.AsyncId
 
 @RunWith(classOf[JUnit4])
 class WhileSpec {
@@ -64,4 +65,4 @@ class WhileSpec {
     }
     result mustBe (100)
   }
-}
\ No newline at end of file
+}
diff --git a/src/test/scala/scala/async/run/match0/Match0.scala b/src/test/scala/scala/async/run/match0/Match0.scala
index 8b99214..49a3a69 100644
--- a/src/test/scala/scala/async/run/match0/Match0.scala
+++ b/src/test/scala/scala/async/run/match0/Match0.scala
@@ -13,6 +13,7 @@ import scala.async.Async.{async, await}
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 import org.junit.Test
+import scala.async.internal.AsyncId
 
 
 class TestMatchClass {
diff --git a/src/test/scala/scala/async/run/nesteddef/NestedDef.scala b/src/test/scala/scala/async/run/nesteddef/NestedDef.scala
index cf74602..409f70a 100644
--- a/src/test/scala/scala/async/run/nesteddef/NestedDef.scala
+++ b/src/test/scala/scala/async/run/nesteddef/NestedDef.scala
@@ -5,6 +5,7 @@ package nesteddef
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 import org.junit.Test
+import scala.async.internal.AsyncId
 
 @RunWith(classOf[JUnit4])
 class NestedDef {
diff --git a/src/test/scala/scala/async/run/noawait/NoAwaitSpec.scala b/src/test/scala/scala/async/run/noawait/NoAwaitSpec.scala
index e2c69d0..ba9c9be 100644
--- a/src/test/scala/scala/async/run/noawait/NoAwaitSpec.scala
+++ b/src/test/scala/scala/async/run/noawait/NoAwaitSpec.scala
@@ -6,6 +6,7 @@ package scala.async
 package run
 package noawait
 
+import scala.async.internal.AsyncId
 import AsyncId._
 import org.junit.Test
 import org.junit.runner.RunWith
diff --git a/src/test/scala/scala/async/run/toughtype/ToughType.scala b/src/test/scala/scala/async/run/toughtype/ToughType.scala
index 2737132..ec2278f 100644
--- a/src/test/scala/scala/async/run/toughtype/ToughType.scala
+++ b/src/test/scala/scala/async/run/toughtype/ToughType.scala
@@ -13,6 +13,7 @@ import scala.async.Async._
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
+import scala.async.internal.AsyncId
 
 
 object ToughTypeObject {
@@ -97,7 +98,7 @@ class ToughTypeSpec {
   }
 
   @Test def singletonTypeIssue17() {
-    import scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     class A { class B }
     async {
       val a = new A
@@ -107,7 +108,7 @@ class ToughTypeSpec {
   }
 
   @Test def existentialMatch() {
-    import scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     trait Container[+A]
     case class ContainerImpl[A](value: A) extends Container[A]
     def foo: Container[_] = async {
@@ -123,7 +124,7 @@ class ToughTypeSpec {
   }
 
   @Test def existentialIfElse0() {
-    import scala.async.AsyncId.{async, await}
+    import AsyncId.{async, await}
     trait Container[+A]
     case class ContainerImpl[A](value: A) extends Container[A]
     def foo: Container[_] = async {