removes "import global._" and "def Expr" in TransformUtils

3 files changed, 14 insertions, 16 deletions

diff --git a/src/main/scala/scala/async/internal/AsyncTransform.scala b/src/main/scala/scala/async/internal/AsyncTransform.scala
index ca53ff1..bf774a7 100644
--- a/src/main/scala/scala/async/internal/AsyncTransform.scala
+++ b/src/main/scala/scala/async/internal/AsyncTransform.scala
@@ -78,7 +78,7 @@ trait AsyncTransform {
         val fieldSym = fld.symbol
         Block(
           List(
-            asyncBase.nullOut(global)(Expr[String](Literal(Constant(fieldSym.name.toString))), Expr[Any](Ident(fieldSym))).tree
+            asyncBase.nullOut(global)(c.Expr[String](Literal(Constant(fieldSym.name.toString))), c.Expr[Any](Ident(fieldSym))).tree
           ),
           Assign(gen.mkAttributedStableRef(fieldSym.owner.thisType, fieldSym), gen.mkZero(fieldSym.info))
         )
@@ -102,7 +102,7 @@ trait AsyncTransform {
         ValDef(NoMods, name.stateMachine, TypeTree(), Apply(Select(New(Ident(stateMachine.symbol)), nme.CONSTRUCTOR), Nil)),
         futureSystemOps.spawn(Apply(selectStateMachine(name.apply), Nil), selectStateMachine(name.execContext))
       ),
-      futureSystemOps.promiseToFuture(Expr[futureSystem.Prom[T]](selectStateMachine(name.result))).tree)
+      futureSystemOps.promiseToFuture(c.Expr[futureSystem.Prom[T]](selectStateMachine(name.result))).tree)
     }
 
     val isSimple = asyncBlock.asyncStates.size == 1
diff --git a/src/main/scala/scala/async/internal/ExprBuilder.scala b/src/main/scala/scala/async/internal/ExprBuilder.scala
index fa50905..f314851 100644
--- a/src/main/scala/scala/async/internal/ExprBuilder.scala
+++ b/src/main/scala/scala/async/internal/ExprBuilder.scala
@@ -80,8 +80,8 @@ trait ExprBuilder {
       List(nextState)
 
     override def mkHandlerCaseForState: CaseDef = {
-      val callOnComplete = futureSystemOps.onComplete(Expr(awaitable.expr),
-        Expr(This(tpnme.EMPTY)), Expr(Ident(name.execContext))).tree
+      val callOnComplete = futureSystemOps.onComplete(c.Expr(awaitable.expr),
+        c.Expr(This(tpnme.EMPTY)), c.Expr(Ident(name.execContext))).tree
       mkHandlerCase(state, stats :+ callOnComplete)
     }
 
@@ -89,7 +89,7 @@ trait ExprBuilder {
       val tryGetTree =
         Assign(
           Ident(awaitable.resultName),
-          TypeApply(Select(futureSystemOps.tryyGet[T](Expr[futureSystem.Tryy[T]](Ident(symLookup.applyTrParam))).tree, newTermName("asInstanceOf")), List(TypeTree(awaitable.resultType)))
+          TypeApply(Select(futureSystemOps.tryyGet[T](c.Expr[futureSystem.Tryy[T]](Ident(symLookup.applyTrParam))).tree, newTermName("asInstanceOf")), List(TypeTree(awaitable.resultType)))
         )
 
       /* if (tr.isFailure)
@@ -101,10 +101,10 @@ trait ExprBuilder {
        * }
        */
       val ifIsFailureTree =
-        If(futureSystemOps.tryyIsFailure(Expr[futureSystem.Tryy[T]](Ident(symLookup.applyTrParam))).tree,
+        If(futureSystemOps.tryyIsFailure(c.Expr[futureSystem.Tryy[T]](Ident(symLookup.applyTrParam))).tree,
            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(Ident(symLookup.applyTrParam), newTermName("asInstanceOf")),
                          List(TypeTree(futureSystemOps.tryType[T]))))).tree,
            Block(List(tryGetTree, mkStateTree(nextState, symLookup)), mkResumeApply(symLookup))
@@ -327,9 +327,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, rhs.tree)
         }
         asyncStates.toList match {
@@ -370,9 +370,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))
                   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
                 })), EmptyTree))
 
       /**
diff --git a/src/main/scala/scala/async/internal/TransformUtils.scala b/src/main/scala/scala/async/internal/TransformUtils.scala
index 83feb86..95d3f16 100644
--- a/src/main/scala/scala/async/internal/TransformUtils.scala
+++ b/src/main/scala/scala/async/internal/TransformUtils.scala
@@ -12,7 +12,7 @@ import reflect.ClassTag
 private[async] trait TransformUtils {
   self: AsyncMacro =>
 
-  import global._
+  import c.universe._
 
   object name {
     val resume        = newTermName("resume")
@@ -60,11 +60,9 @@ private[async] trait TransformUtils {
     (i, j) => util.Try(namess(i)(j)).getOrElse(s"arg_${i}_${j}")
   }
 
-  def Expr[A: WeakTypeTag](t: Tree) = global.Expr[A](rootMirror, new FixedMirrorTreeCreator(rootMirror, t))
-
   object defn {
     def mkList_apply[A](args: List[Expr[A]]): Expr[List[A]] = {
-      Expr(Apply(Ident(definitions.List_apply), args.map(_.tree)))
+      c.Expr(Apply(Ident(definitions.List_apply), args.map(_.tree)))
     }
 
     def mkList_contains[A](self: Expr[List[A]])(elem: Expr[Any]) = reify {