1 files changed, 16 insertions, 15 deletions
diff --git a/src/main/scala/scala/async/internal/ExprBuilder.scala b/src/main/scala/scala/async/internal/ExprBuilder.scala
index 2dd485d..4e521c9 100644
--- a/src/main/scala/scala/async/internal/ExprBuilder.scala
+++ b/src/main/scala/scala/async/internal/ExprBuilder.scala
@@ -13,11 +13,12 @@ import scala.reflect.api
 trait ExprBuilder {
   builder: AsyncMacro =>
 
-  import global._
+  import c.universe._
   import defn._
+  import c.internal._
 
   val futureSystem: FutureSystem
-  val futureSystemOps: futureSystem.Ops { val universe: global.type }
+  val futureSystemOps: futureSystem.Ops { val c: builder.c.type }
 
   val stateAssigner  = new StateAssigner
   val labelDefStates = collection.mutable.Map[Symbol, Int]()
@@ -81,12 +82,12 @@ trait ExprBuilder {
 
     override def mkHandlerCaseForState[T: WeakTypeTag]: CaseDef = {
       val fun = This(tpnme.EMPTY)
-      val callOnComplete = futureSystemOps.onComplete[Any, Unit](Expr[futureSystem.Fut[Any]](awaitable.expr),
-        Expr[futureSystem.Tryy[Any] => Unit](fun), Expr[futureSystem.ExecContext](Ident(name.execContext))).tree
+      val callOnComplete = futureSystemOps.onComplete[Any, Unit](c.Expr[futureSystem.Fut[Any]](awaitable.expr),
+        c.Expr[futureSystem.Tryy[Any] => Unit](fun), c.Expr[futureSystem.ExecContext](Ident(name.execContext))).tree
       val tryGetOrCallOnComplete =
         if (futureSystemOps.continueCompletedFutureOnSameThread)
-          If(futureSystemOps.isCompleted(Expr[futureSystem.Fut[_]](awaitable.expr)).tree,
-            Block(ifIsFailureTree[T](futureSystemOps.getCompleted[Any](Expr[futureSystem.Fut[Any]](awaitable.expr)).tree) :: Nil, literalUnit),
+          If(futureSystemOps.isCompleted(c.Expr[futureSystem.Fut[_]](awaitable.expr)).tree,
+            Block(ifIsFailureTree[T](futureSystemOps.getCompleted[Any](c.Expr[futureSystem.Fut[Any]](awaitable.expr)).tree) :: Nil, literalUnit),
             Block(callOnComplete :: Nil, Return(literalUnit)))
         else
           Block(callOnComplete :: Nil, Return(literalUnit))
@@ -96,7 +97,7 @@ trait ExprBuilder {
     private def tryGetTree(tryReference: => Tree) =
       Assign(
         Ident(awaitable.resultName),
-        TypeApply(Select(futureSystemOps.tryyGet[Any](Expr[futureSystem.Tryy[Any]](tryReference)).tree, newTermName("asInstanceOf")), List(TypeTree(awaitable.resultType)))
+        TypeApply(Select(futureSystemOps.tryyGet[Any](c.Expr[futureSystem.Tryy[Any]](tryReference)).tree, newTermName("asInstanceOf")), List(TypeTree(awaitable.resultType)))
       )
 
     /* if (tr.isFailure)
@@ -108,10 +109,10 @@ trait ExprBuilder {
      * }
      */
     def ifIsFailureTree[T: WeakTypeTag](tryReference: => Tree) =
-      If(futureSystemOps.tryyIsFailure(Expr[futureSystem.Tryy[T]](tryReference)).tree,
+      If(futureSystemOps.tryyIsFailure(c.Expr[futureSystem.Tryy[T]](tryReference)).tree,
         Block(futureSystemOps.completeProm[T](
-          Expr[futureSystem.Prom[T]](symLookup.memberRef(name.result)),
-          Expr[futureSystem.Tryy[T]](
+          c.Expr[futureSystem.Prom[T]](symLookup.memberRef(name.result)),
+          c.Expr[futureSystem.Tryy[T]](
             TypeApply(Select(tryReference, newTermName("asInstanceOf")),
               List(TypeTree(futureSystemOps.tryType[T]))))).tree :: Nil,
           Return(literalUnit)),
@@ -223,7 +224,7 @@ trait ExprBuilder {
     def checkForUnsupportedAwait(tree: Tree) = if (tree exists {
       case Apply(fun, _) if isAwait(fun) => true
       case _                             => false
-    }) abort(tree.pos, "await must not be used in this position")
+    }) c.abort(tree.pos, "await must not be used in this position")
 
     def nestedBlockBuilder(nestedTree: Tree, startState: Int, endState: Int) = {
       val (nestedStats, nestedExpr) = statsAndExpr(nestedTree)
@@ -336,9 +337,9 @@ trait ExprBuilder {
       def mkCombinedHandlerCases[T: WeakTypeTag]: List[CaseDef] = {
         val caseForLastState: CaseDef = {
           val lastState = asyncStates.last
-          val lastStateBody = Expr[T](lastState.body)
+          val lastStateBody = c.Expr[T](lastState.body)
           val rhs = futureSystemOps.completeProm(
-            Expr[futureSystem.Prom[T]](symLookup.memberRef(name.result)), futureSystemOps.tryySuccess[T](lastStateBody))
+            c.Expr[futureSystem.Prom[T]](symLookup.memberRef(name.result)), futureSystemOps.tryySuccess[T](lastStateBody))
           mkHandlerCase(lastState.state, Block(rhs.tree, Return(literalUnit)))
         }
         asyncStates.toList match {
@@ -378,9 +379,9 @@ trait ExprBuilder {
               CaseDef(
                 Bind(name.t, Ident(nme.WILDCARD)),
                 Apply(Ident(defn.NonFatalClass), List(Ident(name.t))), {
-                  val t = Expr[Throwable](Ident(name.t))
+                  val t = c.Expr[Throwable](Ident(name.t))
                   val complete = futureSystemOps.completeProm[T](
-                    Expr[futureSystem.Prom[T]](symLookup.memberRef(name.result)), futureSystemOps.tryyFailure[T](t)).tree
+                    c.Expr[futureSystem.Prom[T]](symLookup.memberRef(name.result)), futureSystemOps.tryyFailure[T](t)).tree
                   Block(complete :: Nil, Return(literalUnit))
                 })), EmptyTree)