Clean up verbose debug output

2 files changed, 18 insertions, 50 deletions

diff --git a/src/async/library/scala/async/Async.scala b/src/async/library/scala/async/Async.scala
index d7f4101..6f44925 100644
--- a/src/async/library/scala/async/Async.scala
+++ b/src/async/library/scala/async/Async.scala
@@ -46,7 +46,7 @@ object Async extends AsyncUtils {
         case Block(stats, expr) =>
           val asyncBlockBuilder = new builder.AsyncBlockBuilder(stats, expr, 0, 1000, 1000, Map())
 
-          vprintln(s"states of current method (${asyncBlockBuilder.asyncStates}):")
+          vprintln(s"states of current method:")
           asyncBlockBuilder.asyncStates foreach vprintln
 
           val handlerExpr = asyncBlockBuilder.mkHandlerExpr()
@@ -55,7 +55,7 @@ object Async extends AsyncUtils {
           vprintln(handlerExpr)
 
           val handlerForLastState: c.Expr[PartialFunction[Int, Unit]] = {
-            val tree = Apply(Select(Ident("result"), c.universe.newTermName("success")),
+            val tree = Apply(Select(Ident("result"), newTermName("success")),
               List(asyncBlockBuilder.asyncStates.last.body))
             builder.mkHandler(asyncBlockBuilder.asyncStates.last.state, c.Expr[Unit](tree))
           }
@@ -64,10 +64,17 @@ object Async extends AsyncUtils {
           vprintln(handlerForLastState)
 
           val localVarTrees = asyncBlockBuilder.asyncStates.init.flatMap(_.allVarDefs).toList
-
-          val unitIdent = Ident(definitions.UnitClass)
-
-          val resumeFunTree: c.Tree = DefDef(Modifiers(), newTermName("resume"), List(), List(List()), unitIdent,
+          
+          /*
+            def resume(): Unit = {
+              try {
+                (handlerExpr.splice orElse handlerForLastState.splice)(state)
+              } catch {
+                case NonFatal(t) => result.failure(t)
+              }
+            }
+           */
+          val resumeFunTree: c.Tree = DefDef(Modifiers(), newTermName("resume"), List(), List(List()), Ident(definitions.UnitClass),
             Try(Apply(Select(
               Apply(Select(handlerExpr.tree, newTermName("orElse")), List(handlerForLastState.tree)),
               newTermName("apply")), List(Ident(newTermName("state")))),
@@ -78,34 +85,18 @@ object Async extends AsyncUtils {
                   Block(List(
                     Apply(Select(Ident(newTermName("result")), newTermName("failure")), List(Ident(newTermName("t"))))),
                     Literal(Constant(()))))), EmptyTree))
-
-          val methodBody = reify {
+          
+          reify {
             val result = Promise[T]()
             var state = 0
-
-            /*
-          def resume(): Unit = {
-            try {
-              (handlerExpr.splice orElse handlerForLastState.splice)(state)
-            } catch {
-              case NonFatal(t) => result.failure(t)
-            }
-          }
-          resume()
-          */
-
+            
             c.Expr(Block(
               localVarTrees :+ resumeFunTree,
               Apply(Ident(newTermName("resume")), List()))).splice
-
+            
             result.future
           }
 
-          //vprintln("ASYNC: Generated method body:")
-          //vprintln(c.universe.showRaw(methodBody))
-          //vprintln(c.universe.show(methodBody))
-          methodBody
-
         case _ =>
           // issue error message
           reify {
diff --git a/src/async/library/scala/async/ExprBuilder.scala b/src/async/library/scala/async/ExprBuilder.scala
index a47cd1a..c0ebe69 100644
--- a/src/async/library/scala/async/ExprBuilder.scala
+++ b/src/async/library/scala/async/ExprBuilder.scala
@@ -429,7 +429,6 @@ class ExprBuilder[C <: Context with Singleton](val c: C) extends AsyncUtils {
         
         val ifBudget: Int = remainingBudget / 2
         remainingBudget -= ifBudget //TODO test if budget > 0
-        vprintln(s"ASYNC IF: ifBudget = $ifBudget")
         // state that we continue with after if-else: currState + ifBudget
         
         val thenBudget: Int = ifBudget / 2
@@ -445,12 +444,6 @@ class ExprBuilder[C <: Context with Singleton](val c: C) extends AsyncUtils {
           case _ =>
             new AsyncBlockBuilder(List(thenp), Literal(Constant(())), currState + 1, currState + ifBudget, thenBudget, toRename)
         }
-        vprintln("ASYNC IF: thenBuilder: "+thenBuilder)
-        vprintln("ASYNC IF: states of thenp:")
-        for (s <- thenBuilder.asyncStates)
-          vprintln(s.toString)
-        
-        // insert states of thenBuilder into asyncStates
         asyncStates ++= thenBuilder.asyncStates
         toRename ++= thenBuilder.toRename
         
@@ -460,12 +453,6 @@ class ExprBuilder[C <: Context with Singleton](val c: C) extends AsyncUtils {
           case _ =>
             new AsyncBlockBuilder(List(elsep), Literal(Constant(())), currState + thenBudget, currState + ifBudget, elseBudget, toRename)
         }
-        vprintln("ASYNC IF: elseBuilder: "+elseBuilder)
-        vprintln("ASYNC IF: states of elsep:")
-        for (s <- elseBuilder.asyncStates)
-          vprintln(s.toString)
-        
-        // insert states of elseBuilder into asyncStates
         asyncStates ++= elseBuilder.asyncStates
         toRename ++= elseBuilder.toRename
         
@@ -480,8 +467,6 @@ class ExprBuilder[C <: Context with Singleton](val c: C) extends AsyncUtils {
     // complete last state builder (representing the expressions after the last await)
     stateBuilder += expr
     val lastState = stateBuilder.complete(endState).result
-    vprintln("ASYNC: last state of current AsyncBlockBuilder "+this+":")
-    vprintln("ASYNC: "+lastState)
     asyncStates += lastState
     
     /* Builds the handler expression for a sequence of async states.
@@ -489,9 +474,6 @@ class ExprBuilder[C <: Context with Singleton](val c: C) extends AsyncUtils {
     def mkHandlerExpr(): c.Expr[PartialFunction[Int, Unit]] = {
       assert(asyncStates.size > 1)
       
-      vprintln(s"!!ASYNC mkHandlerExpr: asyncStates.size = ${asyncStates.size}")
-      vprintln(s"!!ASYNC state 0: ${asyncStates(0)}")
-      
       var handlerTree =
         if (asyncStates.size > 2) asyncStates(0).mkHandlerTreeForState()
         else asyncStates(0).mkHandlerTreeForState()
@@ -501,19 +483,14 @@ class ExprBuilder[C <: Context with Singleton](val c: C) extends AsyncUtils {
       if (asyncStates.size == 2)
         handlerExpr
       else if (asyncStates.size == 3) {
-        // asyncStates(1) must continue with endState
         val handlerTreeForLastState = asyncStates(1).mkHandlerTreeForState()
         val currentHandlerTreeNaked = c.resetAllAttrs(handlerExpr.tree.duplicate)
         c.Expr(
           Apply(Select(currentHandlerTreeNaked, newTermName("orElse")),
                 List(handlerTreeForLastState))).asInstanceOf[c.Expr[PartialFunction[Int, Unit]]]
       } else { // asyncStates.size > 3
-        vprintln("!!ASYNC start for loop")
-        
-        // do not traverse first state: asyncStates.tail
-        // do not traverse last state:  asyncStates.tail.init
+        // do not traverse first or last state:  asyncStates.tail.init
         for (asyncState <- asyncStates.tail.init) {
-          vprintln(s"!!ASYNC current asyncState: $asyncState")
           val handlerTreeForNextState = asyncState.mkHandlerTreeForState()
           val currentHandlerTreeNaked = c.resetAllAttrs(handlerExpr.tree.duplicate)
           handlerExpr = c.Expr(