Output .dot graph of state machine in verbose mode.

Sample: https://gist.github.com/88225478b11c118609b9348d61e13630

View with a local Graphviz install or http://graphviz.it/#/gallery/unix.gv

Sample generated from late expansion of:

    val result = run(
      """
        import scala.async.run.late.{autoawait,lateasync}
        case class FixedFoo(foo: Int)
        class Foobar(val foo: Int, val bar: Double) {
          def guard: Boolean = true
          @autoawait @lateasync def getValue = 4.2
          @autoawait @lateasync def func(f: Any) = {
            ("": Any) match {
              case (x1, y1) if guard => x1.toString; y1.toString
              case (x2, y2) if guard => x2.toString; y2.toString
              case (x3, y3) if guard => x3.toString; y3.toString
              case (x4, y4) =>
                 getValue; x4.toString; y4.toString
            }
          }
        }
        object Test {
          @lateasync def test() = new Foobar(0, 0).func(4)
        }
        """)

Author: retronym

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

@@ -70,9 +70,6 @@ trait AsyncTransform {
       buildAsyncBlock(anfTree, symLookup)
     }
 
-    if(AsyncUtils.verbose)
-      logDiagnostics(anfTree, asyncBlock.asyncStates.map(_.toString))
-
     val liftedFields: List[Tree] = liftables(asyncBlock.asyncStates)
 
     // live variables analysis
@@ -114,10 +111,14 @@ trait AsyncTransform {
       futureSystemOps.spawn(body, execContext) // generate lean code for the simple case of `async { 1 + 1 }`
     else
       startStateMachine
+
+    if(AsyncUtils.verbose) {
+      logDiagnostics(anfTree, asyncBlock, asyncBlock.asyncStates.map(_.toString))
+    }
     cleanupContainsAwaitAttachments(result)
   }
 
-  def logDiagnostics(anfTree: Tree, states: Seq[String]) {
+  def logDiagnostics(anfTree: Tree, block: AsyncBlock, states: Seq[String]) {
     def location = try {
       macroPos.source.path
     } catch {
@@ -129,6 +130,10 @@ trait AsyncTransform {
     AsyncUtils.vprintln(s"${c.macroApplication}")
     AsyncUtils.vprintln(s"ANF transform expands to:\n $anfTree")
     states foreach (s => AsyncUtils.vprintln(s))
+    AsyncUtils.vprintln("===== BEFORE DSE =====")
+    AsyncUtils.vprintln(block.toDot(afterDSE = false))
+    AsyncUtils.vprintln("===== AFTER DSE =====")
+    AsyncUtils.vprintln(block.toDot(afterDSE = true))
   }
 
   /**

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

@@ -345,6 +345,8 @@ trait ExprBuilder {
     def asyncStates: List[AsyncState]
 
     def onCompleteHandler[T: WeakTypeTag]: Tree
+
+    def toDot(afterDSE: Boolean): String
   }
 
   case class SymLookup(stateMachineClass: Symbol, applyTrParam: Symbol) {
@@ -369,6 +371,57 @@ trait ExprBuilder {
     val blockBuilder = new AsyncBlockBuilder(stats, expr, startState, endState, symLookup)
 
     new AsyncBlock {
+      val liveStates = mutable.AnyRefMap[Integer, Integer]()
+      val deadStates = mutable.AnyRefMap[Integer, Integer]()
+
+      // render with http://graphviz.it/#/new
+      def toDot(afterDSE: Boolean): String = {
+        val states = asyncStates
+        def toHtmlLabel(label: String, preText: String, builder: StringBuilder): Unit = {
+          builder.append("<b>").append(label).append("</b>").append("<br/>")
+          builder.append("<font face=\"Courier\">")
+          preText.split("\n").foreach {
+            (line: String) =>
+              builder.append("<br/>")
+              builder.append(line.replaceAllLiterally("\"", "&quot;").replaceAllLiterally("<", "&lt;").replaceAllLiterally(">", "&gt;"))
+          }
+          builder.append("</font>")
+        }
+        val dotBuilder = new StringBuilder()
+        dotBuilder.append("digraph {\n")
+        def stateLabel(s: Int) = {
+          val beforeDseLabel = if (s == 0) "INITIAL" else if (s == Int.MaxValue) "TERMINAL" else if (s > 0) "S" + s else "C" + Math.abs(s)
+          if (afterDSE) {
+            "\"S" + liveStates.getOrElse(s, s) + " (" + beforeDseLabel + ")\""
+          } else {
+            beforeDseLabel
+          }
+
+        }
+        val length = asyncStates.size
+        for ((state, i) <- asyncStates.zipWithIndex) {
+          val liveStateIdOpt: Option[Int] = if (afterDSE) {
+            liveStates.get(state.state).map(_.intValue())
+          } else Some(state.state)
+          for (_ <- liveStateIdOpt) {
+            dotBuilder.append(s"""${stateLabel(state.state)} [label=""").append("<")
+            if (i != length - 1) {
+              val CaseDef(_, _, body) = state.mkHandlerCaseForState
+              toHtmlLabel(stateLabel(state.state), showCode(body), dotBuilder)
+            } else {
+              toHtmlLabel(stateLabel(state.state), state.allStats.map(showCode(_)).mkString("\n"), dotBuilder)
+            }
+            dotBuilder.append("> ]\n")
+          }
+        }
+        for (state <- states; if liveStates.contains(state.state); succ <- state.nextStates) {
+          dotBuilder.append(s"""${stateLabel(state.state)} -> ${stateLabel(succ)}""")
+          dotBuilder.append("\n")
+        }
+        dotBuilder.append("}\n")
+        dotBuilder.toString
+      }
+
       def asyncStates = blockBuilder.asyncStates.toList
 
       def mkCombinedHandlerCases[T: WeakTypeTag]: List[CaseDef] = {
@@ -436,8 +489,6 @@ trait ExprBuilder {
       // enable emission of a tableswitch.
       private def eliminateDeadStates(m: Match): Tree = {
         object DeadState {
-          private val liveStates = mutable.AnyRefMap[Integer, Integer]()
-          private val deadStates = mutable.AnyRefMap[Integer, Integer]()
           private var compactedStateId = 1
           for (CaseDef(Literal(Constant(stateId: Integer)), EmptyTree, body) <- m.cases) {
             body match {

src/test/scala/scala/async/run/late/LateExpansion.scala

@@ -7,7 +7,7 @@ import org.junit.{Assert, Test}
 
 import scala.annotation.StaticAnnotation
 import scala.annotation.meta.{field, getter}
-import scala.async.TreeInterrogation
+import scala.async.TreeInterrogationApp
 import scala.async.internal.AsyncId
 import scala.reflect.internal.util.ScalaClassLoader.URLClassLoader
 import scala.tools.nsc._
@@ -27,6 +27,7 @@ class LateExpansion {
         | """.stripMargin)
     assertEquals("foobar", result)
   }
+
   @Test def testGuard(): Unit = {
     val result = wrapAndRun(
       """
@@ -143,6 +144,7 @@ class LateExpansion {
         |}
         | """.stripMargin)
   }
+
   @Test def shadowing2(): Unit = {
     val result = run(
       """
@@ -366,6 +368,7 @@ class LateExpansion {
       }
       """)
   }
+
   @Test def testNegativeArraySizeExceptionFine1(): Unit = {
     val result = run(
       """
@@ -386,10 +389,35 @@ class LateExpansion {
       }
       """)
   }
+
+  @Test def testNull(): Unit = {
+    val result = run(
+      """
+        import scala.async.run.late.{autoawait,lateasync}
+        case class FixedFoo(foo: Int)
+        class Foobar(val foo: Int, val bar: Double) {
+          def guard: Boolean = true
+          @autoawait @lateasync def getValue = 4.2
+          @autoawait @lateasync def func(f: Any) = {
+            ("": Any) match {
+              case (x1, y1) if guard => x1.toString; y1.toString
+              case (x2, y2) if guard => x2.toString; y2.toString
+              case (x3, y3) if guard => x3.toString; y3.toString
+              case (x4, y4) =>
+                 getValue; x4.toString; y4.toString
+            }
+          }
+        }
+        object Test {
+          @lateasync def test() = new Foobar(0, 0).func(4)
+        }
+        """)
+  }
+
   def run(code: String): Any = {
     val reporter = new StoreReporter
     val settings = new Settings(println(_))
-    // settings.processArgumentString("-Xprint:patmat,postpatmat,jvm -Ybackend:GenASM -nowarn")
+     settings.processArgumentString("-Xprint:patmat,postpatmat,jvm -nowarn")
     settings.outdir.value = sys.props("java.io.tmpdir")
     settings.embeddedDefaults(getClass.getClassLoader)
     val isInSBT = !settings.classpath.isSetByUser
@@ -407,9 +435,9 @@ class LateExpansion {
 
     val run = new Run
     val source = newSourceFile(code)
-//    TreeInterrogation.withDebug {
-      run.compileSources(source :: Nil)
-//    }
+        TreeInterrogationApp.withDebug {
+    run.compileSources(source :: Nil)
+        }
     Assert.assertTrue(reporter.infos.mkString("\n"), !reporter.hasErrors)
     val loader = new URLClassLoader(Seq(new File(settings.outdir.value).toURI.toURL), global.getClass.getClassLoader)
     val cls = loader.loadClass("Test")
@@ -418,6 +446,7 @@ class LateExpansion {
 }
 
 abstract class LatePlugin extends Plugin {
+
   import global._
 
   override val components: List[PluginComponent] = List(new PluginComponent with TypingTransformers {
@@ -434,16 +463,16 @@ abstract class LatePlugin extends Plugin {
         super.transform(tree) match {
           case ap@Apply(fun, args) if fun.symbol.hasAnnotation(autoAwaitSym) =>
             localTyper.typed(Apply(TypeApply(gen.mkAttributedRef(asyncIdSym.typeOfThis, awaitSym), TypeTree(ap.tpe) :: Nil), ap :: Nil))
-          case sel@Select(fun, _) if sel.symbol.hasAnnotation(autoAwaitSym) && !(tree.tpe.isInstanceOf[MethodTypeApi] || tree.tpe.isInstanceOf[PolyTypeApi] ) =>
+          case sel@Select(fun, _) if sel.symbol.hasAnnotation(autoAwaitSym) && !(tree.tpe.isInstanceOf[MethodTypeApi] || tree.tpe.isInstanceOf[PolyTypeApi]) =>
             localTyper.typed(Apply(TypeApply(gen.mkAttributedRef(asyncIdSym.typeOfThis, awaitSym), TypeTree(sel.tpe) :: Nil), sel :: Nil))
           case dd: DefDef if dd.symbol.hasAnnotation(lateAsyncSym) => atOwner(dd.symbol) {
-            deriveDefDef(dd){ rhs: Tree =>
+            deriveDefDef(dd) { rhs: Tree =>
               val invoke = Apply(TypeApply(gen.mkAttributedRef(asyncIdSym.typeOfThis, asyncSym), TypeTree(rhs.tpe) :: Nil), List(rhs))
               localTyper.typed(atPos(dd.pos)(invoke))
             }
           }
           case vd: ValDef if vd.symbol.hasAnnotation(lateAsyncSym) => atOwner(vd.symbol) {
-            deriveValDef(vd){ rhs: Tree =>
+            deriveValDef(vd) { rhs: Tree =>
               val invoke = Apply(TypeApply(gen.mkAttributedRef(asyncIdSym.typeOfThis, asyncSym), TypeTree(rhs.tpe) :: Nil), List(rhs))
               localTyper.typed(atPos(vd.pos)(invoke))
             }
@@ -454,6 +483,7 @@ abstract class LatePlugin extends Plugin {
         }
       }
     }
+
     override def newPhase(prev: Phase): Phase = new StdPhase(prev) {
       override def apply(unit: CompilationUnit): Unit = {
         val translated = newTransformer(unit).transformUnit(unit)