Add LiftTry phase

Phase lifts tries that would be illegal because they execute on non-empty
expression stacks.

Author: odersky

src/dotty/tools/dotc/Compiler.scala

@@ -48,6 +48,7 @@ class Compiler {
            new ExtensionMethods,
            new ExpandSAMs,
            new TailRec,
+           new LiftTry,
            new ClassOf),
       List(new PatternMatcher,
            new ExplicitOuter,

src/dotty/tools/dotc/transform/LiftTry.scala

@@ -0,0 +1,66 @@
+package dotty.tools.dotc
+package transform
+
+import TreeTransforms._
+import core.DenotTransformers._
+import core.Symbols._
+import core.Contexts._
+import core.Types._
+import core.Flags._
+import core.Decorators._
+import NonLocalReturns._
+
+/** Lifts try's that might be executed on non-empty expression stacks
+ *  to their own methods. I.e.
+ *
+ *      try body catch handler
+ *
+ *  is lifted to
+ *
+ *      { def liftedTree$n() = try body catch handler; liftedTree$n() }
+ */
+class LiftTry extends MiniPhase with IdentityDenotTransformer { thisTransform =>
+  import ast.tpd._
+
+  /** the following two members override abstract members in Transform */
+  val phaseName: String = "liftTry"
+
+  val treeTransform = new Transform(needLift = false)
+  val liftingTransform = new Transform(needLift = true)
+
+  class Transform(needLift: Boolean) extends TreeTransform {
+    def phase = thisTransform
+
+    override def prepareForApply(tree: Apply)(implicit ctx: Context) =
+      if (tree.fun.symbol.is(Label)) this
+      else liftingTransform
+
+    override def prepareForValDef(tree: ValDef)(implicit ctx: Context) =
+      if (!tree.symbol.exists  ||
+          tree.symbol.isSelfSym ||
+          tree.symbol.owner == ctx.owner.enclosingMethod) this
+      else liftingTransform
+
+    override def prepareForAssign(tree: Assign)(implicit ctx: Context) =
+      if (tree.lhs.symbol.maybeOwner == ctx.owner.enclosingMethod) this
+      else liftingTransform
+
+    override def prepareForReturn(tree: Return)(implicit ctx: Context) =
+      if (!isNonLocalReturn(tree)) this
+      else liftingTransform
+
+    override def prepareForTemplate(tree: Template)(implicit ctx: Context) =
+      treeTransform
+
+    override def transformTry(tree: Try)(implicit ctx: Context, info: TransformerInfo): Tree =
+      if (needLift) {
+        ctx.debuglog(i"lifting tree at ${tree.pos}, current owner = ${ctx.owner}")
+        val fn = ctx.newSymbol(
+          ctx.owner, ctx.freshName("liftedTree").toTermName, Synthetic | Method,
+          MethodType(Nil, tree.tpe), coord = tree.pos)
+        tree.changeOwnerAfter(ctx.owner, fn, thisTransform)
+        Block(DefDef(fn, tree) :: Nil, ref(fn).appliedToNone)
+      }
+      else tree
+  }
+}

test/dotc/tests.scala

@@ -115,7 +115,7 @@ class tests extends CompilerTest {
   @Test def neg_zoo = compileFile(negDir, "zoo", xerrors = 12)
 
   val negTailcallDir = negDir + "tailcall/"
-  @Test def neg_tailcall_t1672b = compileFile(negTailcallDir, "t1672b", xerrors = 6)
+  @Test def neg_tailcall_t1672b = compileFile(negTailcallDir, "t1672b", xerrors = 5)
   @Test def neg_tailcall_t3275 = compileFile(negTailcallDir, "t3275", xerrors = 1)
   @Test def neg_tailcall_t6574 = compileFile(negTailcallDir, "t6574", xerrors = 2)
   @Test def neg_tailcall = compileFile(negTailcallDir, "tailrec", xerrors = 7)

tests/run/StackMap.scala

@@ -0,0 +1,7 @@
+object Test {
+  var implicitsCache = null
+  
+  def main(args: Array[String]): Unit = {
+     implicitsCache = try{null} catch { case ex: Exception => null }
+  }
+}

tests/run/liftedTry.scala

@@ -0,0 +1,21 @@
+object Test {
+
+  def raise(x: Int) = { throw new Exception(s"$x"); 0 }
+  def handle: Throwable => Int = { case ex: Exception => ex.getMessage().toInt }
+
+  val x = try raise(1) catch handle
+
+  def foo(x: Int) = {
+    val y = try raise(x) catch handle
+    y
+  }
+
+  foo(try 3 catch handle)
+
+  def main(args: Array[String]) = {
+    assert(x == 1)
+    assert(foo(2) == 2)
+    assert(foo(try raise(3) catch handle) == 3)
+  }
+}
+