migrates to 2.11.0-RC1

build.sbt

@@ -1,4 +1,4 @@
-scalaVersion := "2.10.3"
+scalaVersion := "2.11.0-RC1"
 
 // Uncomment to test with a locally built copy of Scala.
 // scalaHome := Some(file("/code/scala2/build/pack"))

src/main/scala/scala/async/internal/AsyncAnalysis.scala

@@ -10,7 +10,7 @@ import scala.collection.mutable
 trait AsyncAnalysis {
   self: AsyncMacro =>
 
-  import global._
+  import c.universe._
 
   /**
    * Analyze the contents of an `async` block in order to:
@@ -21,14 +21,14 @@ trait AsyncAnalysis {
   def reportUnsupportedAwaits(tree: Tree): Unit = {
     val analyzer = new UnsupportedAwaitAnalyzer
     analyzer.traverse(tree)
-    analyzer.hasUnsupportedAwaits
+    // analyzer.hasUnsupportedAwaits // XB: not used?!
   }
 
   private class UnsupportedAwaitAnalyzer extends AsyncTraverser {
     var hasUnsupportedAwaits = false
 
     override def nestedClass(classDef: ClassDef) {
-      val kind = if (classDef.symbol.isTrait) "trait" else "class"
+      val kind = if (classDef.symbol.asClass.isTrait) "trait" else "class"
       reportUnsupportedAwait(classDef, s"nested ${kind}")
     }
 
@@ -59,10 +59,10 @@ trait AsyncAnalysis {
           reportUnsupportedAwait(tree, "try/catch")
           super.traverse(tree)
         case Return(_)                                        =>
-          abort(tree.pos, "return is illegal within a async block")
+          c.abort(tree.pos, "return is illegal within a async block")
         case ValDef(mods, _, _, _) if mods.hasFlag(Flag.LAZY) =>
           // TODO lift this restriction
-          abort(tree.pos, "lazy vals are illegal within an async block")
+          c.abort(tree.pos, "lazy vals are illegal within an async block")
         case CaseDef(_, guard, _) if guard exists isAwait     =>
           // TODO lift this restriction
           reportUnsupportedAwait(tree, "pattern guard")
@@ -87,7 +87,7 @@ trait AsyncAnalysis {
 
     private def reportError(pos: Position, msg: String) {
       hasUnsupportedAwaits = true
-      abort(pos, msg)
+      c.abort(pos, msg)
     }
   }
 }

src/main/scala/scala/async/internal/AsyncBase.scala

@@ -42,34 +42,22 @@ abstract class AsyncBase {
   def asyncImpl[T: c.WeakTypeTag](c: Context)
                                  (body: c.Expr[T])
                                  (execContext: c.Expr[futureSystem.ExecContext]): c.Expr[futureSystem.Fut[T]] = {
-    import c.universe._
+    import c.universe._, c.internal._, decorators._
     val asyncMacro = AsyncMacro(c, self)
 
-    val isPresentationCompiler = asyncMacro.global.forInteractive
-
-    val code = asyncMacro.asyncTransform[T](
-      body.tree.asInstanceOf[asyncMacro.global.Tree],
-      execContext.tree.asInstanceOf[asyncMacro.global.Tree]
-    )(implicitly[c.WeakTypeTag[T]].asInstanceOf[asyncMacro.global.WeakTypeTag[T]]).asInstanceOf[Tree]
-
+    val code = asyncMacro.asyncTransform[T](body.tree, execContext.tree)(c.weakTypeTag[T])
     AsyncUtils.vprintln(s"async state machine transform expands to:\n ${code}")
-    val result = if (isPresentationCompiler) {
-      asyncMacro.suppressExpansion()
-      c.macroApplication
-    } else {
-      // Mark range positions for synthetic code as transparent to allow some wiggle room for overlapping ranges
-      for (t <- code)
-        t.pos = t.pos.makeTransparent
-      code
-    }
-    c.Expr[futureSystem.Fut[T]](result)
+
+    // Mark range positions for synthetic code as transparent to allow some wiggle room for overlapping ranges
+    for (t <- code) t.setPos(t.pos.makeTransparent)
+    c.Expr[futureSystem.Fut[T]](code)
   }
 
   protected[async] def awaitMethod(u: Universe)(asyncMacroSymbol: u.Symbol): u.Symbol = {
     import u._
     asyncMacroSymbol.owner.typeSignature.member(newTermName("await"))
-  }  
-  
+  }
+
   protected[async] def nullOut(u: Universe)(name: u.Expr[String], v: u.Expr[Any]): u.Expr[Unit] =
     u.reify { () }
 }

src/main/scala/scala/async/internal/AsyncId.scala

@@ -7,7 +7,6 @@ package scala.async.internal
 import language.experimental.macros
 import scala.reflect.macros.Context
 import scala.reflect.api.Universe
-import scala.reflect.internal.SymbolTable
 
 object AsyncId extends AsyncBase {
   lazy val futureSystem = IdentityFutureSystem
@@ -52,12 +51,11 @@ object IdentityFutureSystem extends FutureSystem {
   type ExecContext = Unit
   type Tryy[A] = scala.util.Try[A]
 
-  def mkOps(c: SymbolTable): Ops {val universe: c.type} = new Ops {
-    val universe: c.type = c
+  def mkOps(c0: Context): Ops {val c: c0.type} = new Ops {
+    val c: c0.type = c0
+    import c.universe._
 
-    import universe._
-
-    def execContext: Expr[ExecContext] = Expr[Unit](Literal(Constant(())))
+    def execContext: Expr[ExecContext] = c.Expr[Unit](Literal(Constant(())))
 
     def promType[A: WeakTypeTag]: Type = weakTypeOf[Prom[A]]
     def tryType[A: WeakTypeTag]: Type = weakTypeOf[scala.util.Try[A]]
@@ -76,12 +74,12 @@ object IdentityFutureSystem extends FutureSystem {
     def onComplete[A, U](future: Expr[Fut[A]], fun: Expr[Tryy[A] => U],
                          execContext: Expr[ExecContext]): Expr[Unit] = reify {
       fun.splice.apply(util.Success(future.splice))
-      Expr[Unit](Literal(Constant(()))).splice
+      c.Expr[Unit](Literal(Constant(()))).splice
     }
 
     def completeProm[A](prom: Expr[Prom[A]], value: Expr[Tryy[A]]): Expr[Unit] = reify {
       prom.splice.a = value.splice.get
-      Expr[Unit](Literal(Constant(()))).splice
+      c.Expr[Unit](Literal(Constant(()))).splice
     }
 
     def tryyIsFailure[A](tryy: Expr[Tryy[A]]): Expr[Boolean] = reify {

src/main/scala/scala/async/internal/AsyncMacro.scala

@@ -1,51 +1,25 @@
 package scala.async.internal
 
-import scala.tools.nsc.Global
-import scala.tools.nsc.transform.TypingTransformers
-
 object AsyncMacro {
-  def apply(c: reflect.macros.Context, base: AsyncBase): AsyncMacro = {
+  def apply(c0: reflect.macros.Context, base: AsyncBase): AsyncMacro { val c: c0.type } = {
     import language.reflectiveCalls
-    val powerContext = c.asInstanceOf[c.type { val universe: Global; val callsiteTyper: universe.analyzer.Typer }]
-    new AsyncMacro {
-      val global: powerContext.universe.type   = powerContext.universe
-      val callSiteTyper: global.analyzer.Typer = powerContext.callsiteTyper
-      val macroApplication: global.Tree        = c.macroApplication.asInstanceOf[global.Tree]
+    new AsyncMacro { self =>
+      val c: c0.type                                             = c0
       // This member is required by `AsyncTransform`:
-      val asyncBase: AsyncBase                 = base
+      val asyncBase: AsyncBase                                   = base
       // These members are required by `ExprBuilder`:
-      val futureSystem: FutureSystem           = base.futureSystem
-      val futureSystemOps: futureSystem.Ops {val universe: global.type} = futureSystem.mkOps(global)
+      val futureSystem: FutureSystem                             = base.futureSystem
+      val futureSystemOps: futureSystem.Ops {val c: self.c.type} = futureSystem.mkOps(c)
     }
   }
 }
 
 private[async] trait AsyncMacro
-  extends TypingTransformers
-  with AnfTransform with TransformUtils with Lifter
+  extends AnfTransform with TransformUtils with Lifter
   with ExprBuilder with AsyncTransform with AsyncAnalysis with LiveVariables {
 
-  val global: Global
-  val callSiteTyper: global.analyzer.Typer
-  val macroApplication: global.Tree
-
-  lazy val macroPos = macroApplication.pos.makeTransparent
-  def atMacroPos(t: global.Tree) = global.atPos(macroPos)(t)
-
-  def suppressExpansion() {
-    // Have your cake : Scala IDE sees original trees and hyperlinking, etc within async blocks "Just Works"
-    // Eat it too     : (domain specific errors like "unsupported use of await"
-    //
-    // TODO remove this once we unsupport 2.10.x, scalac 2.11 does this automatically.
-
-    import global.Tree
-    type Suppress = { def suppressMacroExpansion(a: Tree): Tree }
-    try {
-      global.asInstanceOf[Suppress].suppressMacroExpansion(macroApplication)
-    } catch {
-      case _: NoSuchMethodException =>
-        global.analyzer.asInstanceOf[Suppress].suppressMacroExpansion(macroApplication)
-    }
-  }
+  val c: scala.reflect.macros.Context
 
+  lazy val macroPos = c.macroApplication.pos.makeTransparent
+  def atMacroPos(t: c.Tree) = c.universe.atPos(macroPos)(t)
 }

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)
 
@@ -55,7 +57,7 @@ trait AsyncTransform {
       val template = Template(List(tryToUnit, typeOf[() => Unit]).map(TypeTree(_)), emptyValDef, body)
 
       val t = ClassDef(NoMods, name.stateMachineT, Nil, template)
-      callSiteTyper.typedPos(macroPos)(Block(t :: Nil, Literal(Constant(()))))
+      typingTransform(atPos(macroPos)(Block(t :: Nil, Literal(Constant(())))))((tree, api) => api.typecheck(tree))
       t
     }
 
@@ -78,9 +80,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), gen.mkZero(fieldSym.info))
+          Assign(gen.mkAttributedStableRef(thisType(fieldSym.owner), fieldSym), gen.mkZero(fieldSym.info))
         )
       }
       val asyncState = asyncBlock.asyncStates.find(_.state == state).get
@@ -102,7 +104,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
@@ -121,7 +123,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))
   }
@@ -141,79 +143,70 @@ 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 set = Assign(gen.mkAttributedStableRef(fieldSym.owner.thisType, fieldSym), transform(rhs))
-            changeOwner(set, tree.symbol, currentOwner)
-            localTyper.typedPos(tree.pos)(set)
-          }
-        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)
-          }
-        case _                                               =>
-          super.transform(tree)
-      }
+          val set = Assign(gen.mkAttributedStableRef(thisType(fieldSym.owner.asClass), fieldSym), api.recur(rhs))
+          set.changeOwner(tree.symbol, api.currentOwner)
+          api.typecheck(atPos(tree.pos)(set))
+        }
+      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
 
       case dd@DefDef(_, name.resume, _, _, _, _) if dd.symbol.owner == stateMachineClass =>
-        (ctx: analyzer.Context) =>
-          val changed = changeOwner(resumeBody, callSiteTyper.context.owner, dd.symbol)
-          val res = fixup(dd, changed, ctx)
+        (api: TypingTransformApi) =>
+          val changed = resumeBody.changeOwner(enclosingOwner, dd.symbol)
+          val res = fixup(dd, changed, api)
           res
     }
     result