Insert correct boxing/unboxing conversions for branches

... of an If, Match, or Try. Fixes #355.

Author: odersky

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

@@ -252,6 +252,36 @@ object Erasure extends TypeTestsCasts{
       if (tree.typeOpt.isRef(defn.UnitClass)) tree.withType(tree.typeOpt)
       else super.typedLiteral(tree)
 
+    // The following methods, typedIf, typedMatch and typedTry need to compensate
+    // for the fact that after erasure, a subtype may notbe compatible with the
+    // type of a lub. Hence we might need to readapt branches to the common type.
+    // Note that the typing of SeqLiteral faces a similar problem but solves it
+    // differently: It adapts all elements to the erasure of the type that existed
+    // before. TODO: It looks like a good idea to harmonize this.
+    // 
+    override def typedIf(tree: untpd.If, pt: Type)(implicit ctx: Context): If = {
+      val tree1 = super.typedIf(tree, pt)
+      println(i"typed if $tree1 with $pt = ${tree1.tpe}")
+      if (pt.isValueType) tree1
+      else cpy.If(tree1)(thenp = adapt(tree1.thenp, tree1.tpe), elsep = adapt(tree1.elsep, tree1.tpe))
+    }
+    
+    override def typedMatch(tree: untpd.Match, pt: Type)(implicit ctx: Context): Match = {
+      val tree1 = super.typedMatch(tree, pt).asInstanceOf[Match]
+      if (pt.isValueType) tree1
+      else cpy.Match(tree1)(tree1.selector, tree1.cases.map(adaptCase(_, tree1.tpe)))
+    }
+    
+    override def typedTry(tree: untpd.Try, pt: Type)(implicit ctx: Context): Try = {
+      val tree1 = super.typedTry(tree, pt)
+      if (pt.isValueType) tree1
+      else cpy.Try(tree1)(expr = adapt(tree1.expr, tree1.tpe), cases = tree1.cases.map(adaptCase(_, tree1.tpe)))
+    }
+
+    private def adaptCase(cdef: CaseDef, pt: Type)(implicit ctx: Context): CaseDef = 
+      cpy.CaseDef(cdef)(body = adapt(cdef.body, pt))
+      
+
     /** Type check select nodes, applying the following rewritings exhaustively
      *  on selections `e.m`, where `OT` is the type of the owner of `m` and `ET`
      *  is the erased type of the selection's original qualifier expression.

tests/pos/erased-lub.scala

@@ -0,0 +1,27 @@
+// Verify that expressions below perform correct boxings in erasure.
+object Test {
+  def id[T](t: T) = t
+
+  val x = true
+  val one = 1
+
+  { if (x) id(one) else 0 } + 1
+
+  { if (x) new scala.util.Random()}.asInstanceOf[Runnable]
+
+  { x match {
+      case true => id(one)
+      case _ => 0
+    }
+  } + 1
+
+  { try {
+      id(one)
+    } catch {
+      case ex: Exception => 0
+    }
+  }.asInstanceOf[Runnable]
+
+  val arr = Array(id(one), 0)
+
+}