Use compiler integrated async phase under -Xasync

Author: retronym

build.sbt

@@ -3,6 +3,7 @@ ScalaModulePlugin.scalaModuleSettingsJVM
 
 name := "scala-async"
 
+scalaVersion := "2.12.11-bin-fd83137-SNAPSHOT"
 libraryDependencies += "org.scala-lang" % "scala-reflect" % scalaVersion.value % "provided"
 libraryDependencies += "org.scala-lang" % "scala-compiler" % scalaVersion.value % "test" // for ToolBox
 libraryDependencies += "junit" % "junit" % "4.12" % "test"
@@ -11,6 +12,7 @@ libraryDependencies += "com.novocode" % "junit-interface" % "0.11" % "test"
 ScalaModulePlugin.enableOptimizer
 testOptions += Tests.Argument(TestFrameworks.JUnit, "-q", "-v", "-s")
 scalacOptions in Test ++= Seq("-Yrangepos")
+scalacOptions in Test ++= (if (scalaVersion.value == "2.12.11-bin-fd83137-SNAPSHOT") List("-Xasync") else Nil)
 
 parallelExecution in Global := false
 

src/main/scala/scala/async/internal/AsyncTransform.scala

@@ -56,7 +56,7 @@ trait AsyncTransform {
         val apply0DefDef: DefDef = {
           // We extend () => Unit so we can pass this class as the by-name argument to `Future.apply`.
           // See SI-1247 for the the optimization that avoids creation.
-          DefDef(NoMods, name.apply, Nil, Nil, TypeTree(definitions.UnitTpe), Apply(Ident(name.apply), literalNull :: Nil))
+          DefDef(NoMods, name.apply, Nil, List(Nil), TypeTree(definitions.UnitTpe), Apply(Ident(name.apply), literalNull :: Nil))
         }
         List(emptyConstructor, stateVar) ++ resultAndAccessors ++ List(execContextValDef) ++ List(applyDefDefDummyBody, apply0DefDef)
       }

src/main/scala/scala/async/internal/ExprBuilder.scala

@@ -536,6 +536,9 @@ trait ExprBuilder {
                 Block(toList(complete), Return(literalUnit))
               }
               If(Apply(Ident(defn.NonFatalClass), List(Ident(name.t))), thenn, Throw(Ident(name.t)))
+              // TODO scala-async accidentally started catching NonFatal exceptions in:
+              // https://github.com/scala/scala-async/commit/e3ff0382ae4e015fc69da8335450718951714982#diff-136ab0b6ecaee5d240cd109e2b17ccb2R411
+              // Should we restore the old behavior ?!?!
               thenn
             })), EmptyTree)
       }

src/main/scala/scala/async/internal/ScalaConcurrentAsync.scala

@@ -24,6 +24,65 @@ object ScalaConcurrentAsync extends AsyncBase {
   override def asyncImpl[T: c.WeakTypeTag](c: whitebox.Context)
                                           (body: c.Expr[T])
                                           (execContext: c.Expr[futureSystem.ExecContext]): c.Expr[Future[T]] = {
-    super.asyncImpl[T](c)(body)(execContext)
+    import c.universe._
+    if (!c.compilerSettings.contains("-Xasync")) {
+      super.asyncImpl[T](c)(body)(execContext)
+    } else try {
+      val awaitSym = typeOf[Async.type].decl(TermName("await"))
+      def mark(t: DefDef): Tree = {
+        import language.reflectiveCalls
+        c.internal.asInstanceOf[{
+          def markForAsyncTransform(owner: Symbol, method: DefDef, awaitSymbol: Symbol, config: Map[String, AnyRef]): DefDef
+        }].markForAsyncTransform(c.internal.enclosingOwner, t, awaitSym, Map.empty)
+      }
+      val name = TypeName("stateMachine$async_" + body.tree.pos.line)
+      // TODO all but the `apply` method code could live in a abstract base class shipped as runtime support.
+
+      // TODO scala-async accidentally started catching NonFatal exceptions in:
+      // https://github.com/scala/scala-async/commit/e3ff0382ae4e015fc69da8335450718951714982#diff-136ab0b6ecaee5d240cd109e2b17ccb2R411
+      // This follows the new behaviour but should we fix the regression?
+
+      val tree = q"""
+
+      final class $name extends _root_.scala.Function1[_root_.scala.util.Try[_root_.scala.AnyRef], _root_.scala.Unit] {
+        private val execContext$$async = ${execContext.tree}
+        private val result$$async: _root_.scala.concurrent.Promise[_root_.scala.AnyRef] = _root_.scala.concurrent.Promise[_root_.scala.AnyRef]();
+
+        // FSM translated method
+        ${mark(q"""override def apply(tr$$async: _root_.scala.util.Try[_root_.scala.AnyRef]) = ${body.tree}""")}
+
+        // Required methods
+        protected var state$$async: _root_.scala.Int = 0
+
+        protected def completeFailure(t: _root_.scala.Throwable): _root_.scala.Unit = result$$async.complete(_root_.scala.util.Failure(t))
+
+        protected def completeSuccess(value: _root_.scala.AnyRef): _root_.scala.Unit = result$$async.complete(_root_.scala.util.Success(value))
+        protected def onComplete(f: _root_.scala.concurrent.Future[_root_.scala.AnyRef]): _root_.scala.Unit = f.onComplete(this)(execContext$$async)
+        protected def getCompleted(f: _root_.scala.concurrent.Future[_root_.scala.AnyRef]): _root_.scala.util.Try[_root_.scala.AnyRef] = {
+          if (f.isCompleted) {
+            f.value.get
+          } else null
+        }
+        protected def tryGet(tr: _root_.scala.util.Try[_root_.scala.AnyRef]): _root_.scala.AnyRef = tr match {
+          case _root_.scala.util.Success(value) =>
+            value.asInstanceOf[_root_.scala.AnyRef]
+          case _root_.scala.util.Failure(throwable) =>
+            completeFailure(throwable)
+            this // sentinel value to indicate the dispatch loop should exit.
+        }
+        def start(): _root_.scala.concurrent.Future[_root_.scala.AnyRef] = {
+          // This cast is safe because we know that `def apply` does not consult its argument when `state == 0`.
+          _root_.scala.concurrent.Future.unit.asInstanceOf[_root_.scala.concurrent.Future[_root_.scala.AnyRef]].onComplete(this)(execContext$$async)
+          result$$async.future
+        }
+
+      }
+      new $name().start().asInstanceOf[${c.macroApplication.tpe}]
+    """
+      c.Expr[Future[T]](tree)
+    } catch {
+      case e: ReflectiveOperationException =>
+        c.abort(c.macroApplication.pos, "-Xasync is provided as a Scala compiler option, but the async macro is unable to call c.internal.markForAsyncTransform. " + e.getClass.getName + " " + e.getMessage)
+    }
   }
 }