Synthezise a match directly.

Rather than a function applied to the state.

2 files changed, 9 insertions, 24 deletions

diff --git a/src/main/scala/scala/async/Async.scala b/src/main/scala/scala/async/Async.scala
index 2d7f324..ac965b4 100644
--- a/src/main/scala/scala/async/Async.scala
+++ b/src/main/scala/scala/async/Async.scala
@@ -23,7 +23,7 @@ object Async extends AsyncBase {
   def async[T](body: T) = macro asyncImpl[T]
 
   override def asyncImpl[T: c.WeakTypeTag](c: Context)(body: c.Expr[T]): c.Expr[Future[T]] = super.asyncImpl[T](c)(body)
-    }
+}
 
 object AsyncId extends AsyncBase {
   lazy val futureSystem = IdentityFutureSystem
@@ -84,14 +84,12 @@ abstract class AsyncBase {
 
         val handlerCases: List[CaseDef] = asyncBlockBuilder.mkCombinedHandlerCases[T]()
 
-        val combinedHander = c.Expr[Int => Unit](builder.mkFunction(handlerCases))
-
         val localVarTrees = asyncBlockBuilder.asyncStates.init.flatMap(_.allVarDefs).toList
 
         /*
           def resume(): Unit = {
             try {
-              combinedHander(state)
+              state match { case 0 => ... ; ... }
             } catch {
               case NonFatal(t) => result.failure(t)
             }
@@ -100,10 +98,7 @@ abstract class AsyncBase {
         val nonFatalModule = builder.defn.NonFatalClass
         val resumeFunTree: c.Tree = DefDef(Modifiers(), name.resume, Nil, List(Nil), Ident(definitions.UnitClass),
           Try(
-            reify {
-              combinedHander.splice.apply(c.Expr[Int](Ident(name.state)).splice)
-            }.tree
-            ,
+            Match(Ident(name.state), handlerCases),
             List(
               CaseDef(
                 Apply(Ident(nonFatalModule), List(Bind(name.tr, Ident(nme.WILDCARD)))),
diff --git a/src/main/scala/scala/async/ExprBuilder.scala b/src/main/scala/scala/async/ExprBuilder.scala
index f360c92..3f82754 100644
--- a/src/main/scala/scala/async/ExprBuilder.scala
+++ b/src/main/scala/scala/async/ExprBuilder.scala
@@ -22,18 +22,15 @@ final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSy
 
   object name {
     def suffix(string: String) = string + "$async"
+    def suffixedName(prefix: String) = newTermName(suffix(prefix))
 
-    def expandedTermName(prefix: String) = newTermName(suffix(prefix))
-
-    def expandedTypeName(prefix: String) = newTypeName(suffix(prefix))
-
-    val state = expandedTermName("state")
-    val result = expandedTermName("result")
-    val tr = newTermName("tr")
+    val state = suffixedName("state")
+    val result = suffixedName("result")
+    val resume = suffixedName("resume")
 
     // TODO do we need to freshen any of these?
-    val resume = expandedTermName("resume")
     val x1 = newTermName("x$1")
+    val tr = newTermName("tr")
   }
 
   private val execContext = futureSystemOps.execContext
@@ -66,13 +63,6 @@ final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSy
   def mkHandlerCase(num: Int, rhs: c.Tree): CaseDef =
     CaseDef(c.literal(num).tree, EmptyTree, rhs)
 
-  private def paramValDef(name: TermName, sym: Symbol) = ValDef(Modifiers(PARAM), name, Ident(sym), EmptyTree)
-
-  private def paramValDef(name: TermName, tpe: Type) = ValDef(Modifiers(PARAM), name, TypeTree(tpe), EmptyTree)
-
-  def mkFunction(cases: List[CaseDef]): c.Tree =
-    Function(List(paramValDef(name.x1, definitions.IntClass)), Match(Ident(name.x1), cases))
-
   class AsyncState(stats: List[c.Tree], val state: Int, val nextState: Int) {
     val body: c.Tree = stats match {
       case stat :: Nil => stat
@@ -150,7 +140,7 @@ final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSy
       val updateState = mkStateTree(nextState)
 
       val handlerTree =
-        Function(List(paramValDef(name.tr, tryType)), Block(tryGetTree, updateState, mkResumeApply))
+        Function(List(ValDef(Modifiers(PARAM), name.tr, TypeTree(tryType), EmptyTree)), Block(tryGetTree, updateState, mkResumeApply))
 
       futureSystemOps.onComplete(c.Expr(awaitable), c.Expr(handlerTree), execContext).tree
     }