Further cleanup in AST generation

 - centralize names
 - centralize more module/class lookup
 - reduce duplication
 - centralize use of resetAllAttrs
 - remove uses of asInstanceOf

1 files changed, 12 insertions, 10 deletions

diff --git a/src/main/scala/scala/async/Async.scala b/src/main/scala/scala/async/Async.scala
index d64e04a..acd5128 100644
--- a/src/main/scala/scala/async/Async.scala
+++ b/src/main/scala/scala/async/Async.scala
@@ -65,13 +65,14 @@ abstract class AsyncBase extends AsyncUtils {
   @deprecated("`await` must be enclosed in an `async` block", "0.1")
   def await[T](awaitable: futureSystem.Fut[T]): T = ???
 
-  def asyncImpl[T: c.WeakTypeTag](c: Context)(body: c.Expr[T]) = {
+  def asyncImpl[T: c.WeakTypeTag](c: Context)(body: c.Expr[T]): c.Expr[futureSystem.Fut[T]] = {
     import c.universe._
     import Flag._
 
-    val builder = new ExprBuilder[c.type, self.FS](c, self.futureSystem)
+    val builder = new ExprBuilder[c.type, futureSystem.type](c, self.futureSystem)
 
     import builder.defn._
+    import builder.name
     import builder.futureSystemOps
 
     val awaitMethod = awaitSym(c)
@@ -91,7 +92,7 @@ abstract class AsyncBase extends AsyncUtils {
         val handlerForLastState: c.Expr[PartialFunction[Int, Unit]] = {
           val lastState = asyncBlockBuilder.asyncStates.last
           val lastStateBody = c.Expr[T](lastState.body)
-          builder.mkHandler(lastState.state, futureSystemOps.completeProm(c.Expr[futureSystem.Prom[T]](Ident("result")), reify(scala.util.Success(lastStateBody.splice))))
+          builder.mkHandler(lastState.state, futureSystemOps.completeProm(c.Expr[futureSystem.Prom[T]](Ident(name.result)), reify(scala.util.Success(lastStateBody.splice))))
         }
 
         vprintln("GENERATED handler for last state:")
@@ -108,30 +109,31 @@ abstract class AsyncBase extends AsyncUtils {
             }
           }
          */
-        val nonFatalModule = c.mirror.staticModule("scala.util.control.NonFatal")
-        val resumeFunTree: c.Tree = DefDef(Modifiers(), newTermName("resume"), List(), List(List()), Ident(definitions.UnitClass),
+        val nonFatalModule = builder.defn.NonFatalClass
+        val resumeFunTree: c.Tree = DefDef(Modifiers(), name.resume, List(), List(List()), Ident(definitions.UnitClass),
           Try(
             reify {
               val combinedHandler = mkPartialFunction_orElse(handlerExpr)(handlerForLastState).splice
-              combinedHandler.apply(c.Expr[Int](Ident(newTermName("state"))).splice)
+              combinedHandler.apply(c.Expr[Int](Ident(name.state)).splice)
             }.tree
             ,
             List(
               CaseDef(
-                Apply(Ident(nonFatalModule), List(Bind(newTermName("t"), Ident(nme.WILDCARD)))),
+                Apply(Ident(nonFatalModule), List(Bind(name.tr, Ident(nme.WILDCARD)))),
                 EmptyTree,
                 Block(List({
-                  val t = c.Expr[Throwable](Ident(newTermName("t")))
-                  futureSystemOps.completeProm[T](c.Expr[futureSystem.Prom[T]](Ident(newTermName("result"))), reify(scala.util.Failure(t.splice))).tree
+                  val t = c.Expr[Throwable](Ident(name.tr))
+                  futureSystemOps.completeProm[T](c.Expr[futureSystem.Prom[T]](Ident(name.result)), reify(scala.util.Failure(t.splice))).tree
                 }), c.literalUnit.tree))), EmptyTree))
 
+
         val prom: Expr[futureSystem.Prom[T]] = reify {
           val result = futureSystemOps.createProm[T].splice
           var state = 0
           futureSystemOps.future[Unit] {
             c.Expr[Unit](Block(
               localVarTrees :+ resumeFunTree,
-              Apply(Ident(newTermName("resume")), List())))
+              Apply(Ident(name.resume), List())))
           }(futureSystemOps.execContext).splice
           result
         }