1 files changed, 41 insertions, 47 deletions
diff --git a/src/main/scala/scala/async/internal/AsyncTransform.scala b/src/main/scala/scala/async/internal/AsyncTransform.scala
index 47a2704..ec3a2a1 100644
--- a/src/main/scala/scala/async/internal/AsyncTransform.scala
+++ b/src/main/scala/scala/async/internal/AsyncTransform.scala
@@ -3,7 +3,9 @@ package scala.async.internal
 trait AsyncTransform {
   self: AsyncMacro =>
 
-  import global._
+  import c.universe._
+  import c.internal._
+  import decorators._
 
   val asyncBase: AsyncBase
 
@@ -13,7 +15,7 @@ trait AsyncTransform {
     // We annotate the type of the whole expression as `T @uncheckedBounds` so as not to introduce
     // warnings about non-conformant LUBs. See SI-7694
     // This implicit propagates the annotated type in the type tag.
-    implicit val uncheckedBoundsResultTag: WeakTypeTag[T] = WeakTypeTag[T](rootMirror, FixedMirrorTypeCreator(rootMirror, uncheckedBounds(resultType.tpe)))
+    implicit val uncheckedBoundsResultTag: WeakTypeTag[T] = c.WeakTypeTag[T](uncheckedBounds(resultType.tpe))
 
     reportUnsupportedAwaits(body)
 
@@ -70,9 +72,9 @@ 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(c.universe)(c.Expr[String](Literal(Constant(fieldSym.name.toString))), c.Expr[Any](Ident(fieldSym))).tree
           ),
-          Assign(gen.mkAttributedStableRef(fieldSym.owner.thisType, fieldSym), mkZero(fieldSym.info))
+          Assign(gen.mkAttributedStableRef(thisType(fieldSym.owner), fieldSym), mkZero(fieldSym.info))
         )
       }
       val asyncState = asyncBlock.asyncStates.find(_.state == state).get
@@ -93,7 +95,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
@@ -112,7 +114,7 @@ trait AsyncTransform {
     }
 
     AsyncUtils.vprintln(s"In file '$location':")
-    AsyncUtils.vprintln(s"${macroApplication}")
+    AsyncUtils.vprintln(s"${c.macroApplication}")
     AsyncUtils.vprintln(s"ANF transform expands to:\n $anfTree")
     states foreach (s => AsyncUtils.vprintln(s))
   }
@@ -131,83 +133,75 @@ trait AsyncTransform {
     liftedSyms.foreach {
       sym =>
         if (sym != null) {
-          sym.owner = stateMachineClass
+          sym.setOwner(stateMachineClass)
           if (sym.isModule)
-            sym.moduleClass.owner = stateMachineClass
+            sym.asModule.moduleClass.setOwner(stateMachineClass)
         }
     }
     // Replace the ValDefs in the splicee with Assigns to the corresponding lifted
     // fields. Similarly, replace references to them with references to the field.
     //
     // This transform will only be run on the RHS of `def foo`.
-    class UseFields extends MacroTypingTransformer {
-      override def transform(tree: Tree): Tree = tree match {
-        case _ if currentOwner == stateMachineClass          =>
-          super.transform(tree)
-        case ValDef(_, _, _, rhs) if liftedSyms(tree.symbol) =>
-          atOwner(currentOwner) {
-            val fieldSym = tree.symbol
-            val lhs = atPos(tree.pos) {
-              gen.mkAttributedStableRef(fieldSym.owner.thisType, fieldSym)
-            }
-            val assign = treeCopy.Assign(tree, lhs, transform(rhs)).setType(definitions.UnitTpe)
-            changeOwner(assign, tree.symbol, currentOwner)
-            assign
-          }
-        case _: DefTree if liftedSyms(tree.symbol)           =>
-          EmptyTree
-        case Ident(name) if liftedSyms(tree.symbol)          =>
+    val useFields: (Tree, TypingTransformApi) => Tree = (tree, api) => tree match {
+      case _ if api.currentOwner == stateMachineClass          =>
+        api.default(tree)
+      case ValDef(_, _, _, rhs) if liftedSyms(tree.symbol) =>
+        api.atOwner(api.currentOwner) {
           val fieldSym = tree.symbol
-          atPos(tree.pos) {
-            gen.mkAttributedStableRef(fieldSym.owner.thisType, fieldSym).setType(tree.tpe)
+          val lhs = atPos(tree.pos) {
+            gen.mkAttributedStableRef(thisType(fieldSym.owner.asClass), fieldSym)
           }
-        case _                                               =>
-          super.transform(tree)
-      }
+          treeCopy.Assign(tree, lhs, api.recur(rhs)).setType(definitions.UnitTpe).changeOwner(fieldSym, api.currentOwner)
+        }
+      case _: DefTree if liftedSyms(tree.symbol)           =>
+        EmptyTree
+      case Ident(name) if liftedSyms(tree.symbol)          =>
+        val fieldSym = tree.symbol
+        atPos(tree.pos) {
+          gen.mkAttributedStableRef(thisType(fieldSym.owner.asClass), fieldSym).setType(tree.tpe)
+        }
+      case _                                               =>
+        api.default(tree)
     }
 
     val liftablesUseFields = liftables.map {
       case vd: ValDef => vd
-      case x          =>
-        val useField = new UseFields()
-        //.substituteSymbols(fromSyms, toSyms)
-        useField.atOwner(stateMachineClass)(useField.transform(x))
+      case x          => typingTransform(x, stateMachineClass)(useFields)
     }
 
-    tree.children.foreach {
-      t =>
-        new ChangeOwnerAndModuleClassTraverser(callSiteTyper.context.owner, tree.symbol).traverse(t)
-    }
+    tree.children.foreach(_.changeOwner(enclosingOwner, tree.symbol))
     val treeSubst = tree
 
     /* Fixes up DefDef: use lifted fields in `body` */
-    def fixup(dd: DefDef, body: Tree, ctx: analyzer.Context): Tree = {
+    def fixup(dd: DefDef, body: Tree, api: TypingTransformApi): Tree = {
       val spliceeAnfFixedOwnerSyms = body
-      val useField = new UseFields()
-      val newRhs = useField.atOwner(dd.symbol)(useField.transform(spliceeAnfFixedOwnerSyms))
-      val typer = global.analyzer.newTyper(ctx.make(dd, dd.symbol))
-      treeCopy.DefDef(dd, dd.mods, dd.name, dd.tparams, dd.vparamss, dd.tpt, typer.typed(newRhs))
+      val newRhs = typingTransform(spliceeAnfFixedOwnerSyms, dd.symbol)(useFields)
+      val newRhsTyped = api.atOwner(dd, dd.symbol)(api.typecheck(newRhs))
+      treeCopy.DefDef(dd, dd.mods, dd.name, dd.tparams, dd.vparamss, dd.tpt, newRhsTyped)
     }
 
     liftablesUseFields.foreach(t => if (t.symbol != null) stateMachineClass.info.decls.enter(t.symbol))
 
     val result0 = transformAt(treeSubst) {
       case t@Template(parents, self, stats) =>
-        (ctx: analyzer.Context) => {
+        (api: TypingTransformApi) => {
           treeCopy.Template(t, parents, self, liftablesUseFields ++ stats)
         }
     }
     val result = transformAt(result0) {
       case dd@DefDef(_, name.apply, _, List(List(_)), _, _) if dd.symbol.owner == stateMachineClass =>
-        (ctx: analyzer.Context) =>
-          val typedTree = fixup(dd, changeOwner(applyBody, callSiteTyper.context.owner, dd.symbol), ctx)
+        (api: TypingTransformApi) =>
+          val typedTree = fixup(dd, applyBody.changeOwner(enclosingOwner, dd.symbol), api)
           typedTree
     }
     result
   }
 
   def typecheckClassDef(cd: ClassDef): ClassDef = {
-    val Block(cd1 :: Nil, _) = callSiteTyper.typedPos(macroPos)(Block(cd :: Nil, Literal(Constant(()))))
+    val Block(cd1 :: Nil, _) = typingTransform(atPos(macroPos)(Block(cd :: Nil, Literal(Constant(())))))(
+      (tree, api) =>
+        api.typecheck(tree)
+    )
     cd1.asInstanceOf[ClassDef]
   }
 }