Rebase and address reviewer comments.

Author: DarkDimius

src/dotty/tools/backend/jvm/BottomTypes.scala

@@ -44,7 +44,7 @@ class BottomTypes extends MiniPhaseTransform {
 
 
   def adaptBottom(treeOfBottomType: tpd.Tree, expectedType: Type)(implicit ctx: Context) = {
-    if (Erasure.Boxing.isNonJVMBottomType(treeOfBottomType.tpe) && (treeOfBottomType.tpe ne expectedType))
+    if (defn.isBottomType(treeOfBottomType.tpe) && (treeOfBottomType.tpe ne expectedType))
       Erasure.Boxing.adaptToType(treeOfBottomType, expectedType)
     else treeOfBottomType
   }
@@ -68,7 +68,7 @@ class BottomTypes extends MiniPhaseTransform {
   override def transformApply(tree: tpd.Apply)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
     val fun = tree.fun
     val newArgs: List[tpd.Tree] = tree.args.zip(fun.tpe.dealias.firstParamTypes).map(x => adaptBottom(x._1, x._2))
-    val changeNeeded = tree.args == newArgs // cpy.Apply does not check if elements are the same,
+    val changeNeeded = tree.args != newArgs // cpy.Apply does not check if elements are the same,
                                             // it only does `eq` on lists as whole
     if (changeNeeded) cpy.Apply(tree)(fun = fun, args = newArgs)
     else tree

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

@@ -246,15 +246,15 @@ object Erasure extends TypeTestsCasts{
      *    e -> unbox(e, PT)  otherwise, if `PT` is an erased value type
      *    e -> box(e)        if `e` is of primitive type and `PT` is not a primitive type
      *    e -> unbox(e, PT)  if `PT` is a primitive type and `e` is not of primitive type
-     *    e -> cast(e, PT)   otherwise
+     *    e -> cast(e, PT)   otherwise, including if `PT` is a bottom type.
      */
     def adaptToType(tree: Tree, pt: Type)(implicit ctx: Context): Tree =
       if (pt.isInstanceOf[FunProto]) tree
       else tree.tpe.widen match {
         case MethodType(Nil, _) if tree.isTerm =>
           adaptToType(tree.appliedToNone, pt)
         case tpw =>
-          if (pt.isInstanceOf[ProtoType] || ((!pt.isValueType || !isNonJVMBottomType(tree.tpe)) && (tree.tpe <:< pt)))
+          if (pt.isInstanceOf[ProtoType] || ((!pt.isValueType || !defn.isBottomType(tree.tpe)) && (tree.tpe <:< pt)))
             tree
           else if (tpw.isErasedValueType)
             adaptToType(box(tree), pt)
@@ -268,11 +268,6 @@ object Erasure extends TypeTestsCasts{
             cast(tree, pt)
       }
 
-
-    /** Is `tpe` a type which is a bottom type for Dotty, but not a bottom type for JVM */
-    def isNonJVMBottomType(tpe: Type)(implicit ctx: Context): Boolean = {
-      tpe.derivesFrom(ctx.definitions.NothingClass) || tpe.derivesFrom(ctx.definitions.NullClass)
-    }
   }
 
   class Typer extends typer.ReTyper with NoChecking {

tests/pos/i828.scala

@@ -1,3 +1,18 @@
 object X {
   val x: Int = null.asInstanceOf[Nothing]
+  def d: Int = null.asInstanceOf[Nothing]
+  var s: Int = 0
+  s = null.asInstanceOf[Nothing]
+  def takeInt(i: Int): Unit
+  takeInt(null.asInstanceOf[Nothing])
+}
+
+object Y {
+  val n: Null = null
+  val x: Object = n
+  def d: Object = n
+  var s: Object = 0
+  s = n
+  def takeInt(i: Object): Unit
+  takeInt(n)
 }