[backport] Avoid dead code warnings in generated code.

If we blindly splicing `{..$stats, ..$generatedCode}`, and the last
expression in `$stats` is of type `Nothing`, we'll incur a dead
code warning when typechecking the block.

This commit:
  - introduces a helper method to augment user-written stats with
    synthetic code
  - Emit a try/finally in that code (so we advance the state, even if we
    are about to exit the state machine in the async-block global
    exception handler
  - Hide `Nothing` typed expressions from the dead code analysis
    by wrapping them in an `expr: Any`

Fixes #150 (the part reported in the comments, not the original ticket.)

Author: retronym

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

@@ -34,7 +34,12 @@ trait ExprBuilder {
     var stats: List[Tree]
 
     def statsAnd(trees: List[Tree]): List[Tree] = {
-      val body = adaptToUnit(stats)
+      val body = stats match {
+        case init :+ last if tpeOf(last) =:= definitions.NothingTpe =>
+          adaptToUnit(init :+ Typed(last, TypeTree(definitions.AnyTpe)))
+        case _ =>
+          adaptToUnit(stats)
+      }
       Try(body, Nil, adaptToUnit(trees)) :: Nil
     }
 

src/test/scala/scala/async/package.scala

@@ -42,6 +42,32 @@ package object async {
     m.mkToolBox(options = compileOptions)
   }
 
+  import scala.tools.nsc._, reporters._
+  def mkGlobal(compileOptions: String = ""): Global = {
+    val source = """
+                   | class Test {
+                   |   def test = {
+                   |     import scala.async.Async._, scala.concurrent._, ExecutionContext.Implicits.global
+                   |     async {
+                   |       val opt = await(async(Option.empty[String => Future[Unit]]))
+                   |       opt match {
+                   |         case None =>
+                   |           throw new RuntimeException("case a")
+                   |         case Some(f) =>
+                   |           await(f("case b"))
+                   |       }
+                   |     }
+                   |   }
+                   | }
+                   | """.stripMargin
+    val settings = new Settings()
+    settings.processArgumentString(compileOptions)
+    settings.usejavacp.value = true
+    settings.embeddedDefaults(getClass.getClassLoader)
+    val reporter = new StoreReporter
+    new Global(settings, reporter)
+  }
+
   def scalaBinaryVersion: String = {
     val PreReleasePattern = """.*-(M|RC).*""".r
     val Pattern = """(\d+\.\d+)\..*""".r

src/test/scala/scala/async/run/WarningsSpec.scala

@@ -7,10 +7,8 @@ package run
 
 import org.junit.Test
 
-import scala.async.internal.AsyncId
-import scala.concurrent.Await
-import scala.concurrent.duration._
 import scala.language.{postfixOps, reflectiveCalls}
+import scala.tools.nsc.reporters.StoreReporter
 
 
 class WarningsSpec {
@@ -32,4 +30,29 @@ class WarningsSpec {
       """.stripMargin
     })
   }
+
+  @Test
+  def noDeadCodeWarning() {
+    val global = mkGlobal("-cp ${toolboxClasspath} -Yrangepos -Ywarn-dead-code -Xfatal-warnings")
+    val source = """
+        | class Test {
+        |  def test = {
+        |    import scala.async.Async._, scala.concurrent._, ExecutionContext.Implicits.global
+        |    async {
+        |      val opt = await(async(Option.empty[String => Future[Unit]]))
+        |      opt match {
+        |        case None =>
+        |          throw new RuntimeException("case a")
+        |        case Some(f) =>
+        |          await(f("case b"))
+        |      }
+        |    }
+        |  }
+        |}
+      """.stripMargin
+    val run = new global.Run
+    val sourceFile = global.newSourceFile(source)
+    run.compileSources(sourceFile :: Nil)
+    assert(!global.reporter.hasErrors, global.reporter.asInstanceOf[StoreReporter].infos)
+  }
 }