Preparing for Scala 2.11.0

.travis.yml

@@ -2,8 +2,7 @@ language: scala
 script: 
   - sbt ++$TRAVIS_SCALA_VERSION clean test publishLocal
 scala:
-  - 2.10.3
-  - 2.11.0-M6
+  - 2.11.0-SNAPSHOT
 jdk:
   - openjdk6
   - openjdk7

README.md

@@ -2,6 +2,7 @@
 
 [![Build Status](https://secure.travis-ci.org/scala/async.png)](http://travis-ci.org/scala/async)
 
+Note: this branch targets Scala 2.11.x, support for Scala 2.10.x has been moved to [this branch](https://github.com/scala/async/tree/2.10.x).
 
 ## Quick start
 

build.sbt

@@ -1,24 +1,18 @@
-scalaVersion := "2.10.3"
+scalaVersion := "2.11.0-SNAPSHOT"
 
 // Uncomment to test with a locally built copy of Scala.
 // scalaHome := Some(file("/code/scala2/build/pack"))
-
+resolvers ++= (if (scalaVersion.value.endsWith("SNAPSHOT")) List(Resolver.sonatypeRepo("snapshots")) else Nil)
 
 organization := "org.scala-lang.modules"
 
 name := "scala-async"
 
 version := "0.9.0-SNAPSHOT"
 
-libraryDependencies <++= (scalaVersion) {
-  sv => Seq(
-    // TODO we should make this provided after we rely on @compileTimeOnly in scla-library in 2.11.-
-    //      but if we do that now, and a user doesn't have this on the classpath, they can get the
-    //      dreaded MissingRequirementErrors when unpickling types from scala.async.Async
-    "org.scala-lang" % "scala-reflect" % sv,
-    "org.scala-lang" % "scala-compiler" % sv % "provided"
-  )
-}
+libraryDependencies += "org.scala-lang" % "scala-reflect" % scalaVersion.value % "provided"
+
+libraryDependencies += "org.scala-lang" % "scala-compiler" % scalaVersion.value % "test" // for ToolBox
 
 libraryDependencies += "junit" % "junit-dep" % "4.10" % "test"
 

src/main/scala/scala/async/Async.scala

@@ -6,7 +6,7 @@ package scala.async
 
 import scala.language.experimental.macros
 import scala.concurrent.{Future, ExecutionContext}
-import scala.reflect.internal.annotations.compileTimeOnly
+import scala.annotation.compileTimeOnly
 
 /**
  * Async blocks provide a direct means to work with [[scala.concurrent.Future]].

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)
 }