Erasure: properly handle null in value classes

This fixes the issues reported in SI-5866 and SI-8097

Author: smarter

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

@@ -170,15 +170,29 @@ object Erasure extends TypeTestsCasts{
     def unbox(tree: Tree, pt: Type)(implicit ctx: Context): Tree = ctx.traceIndented(i"unboxing ${tree.showSummary}: ${tree.tpe} as a $pt") {
       pt match {
         case ErasedValueType(clazz, underlying) =>
+          def unboxedTree(t: Tree) =
+            adaptToType(t, clazz.typeRef)
+            .select(valueClassUnbox(clazz))
+            .appliedToNone
+
+          // Null unboxing needs to be treated separately since we cannot call a method on null.
+          // "Unboxing" null to underlying is equivalent to doing null.asInstanceOf[underlying]
+          // See tests/pos/valueclasses/nullAsInstanceOfVC.scala for cases where this might happen.
           val tree1 =
-            if ((tree.tpe isRef defn.NullClass) && underlying.isPrimitiveValueType)
-              // convert `null` directly to underlying type, as going
-              // via the unboxed type would yield a NPE (see SI-5866)
-              unbox(tree, underlying)
-            else
-              adaptToType(tree, clazz.typeRef)
-                .select(valueClassUnbox(clazz))
-                .appliedToNone
+            if (tree.tpe isRef defn.NullClass)
+              adaptToType(tree, underlying)
+            else if (!(tree.tpe <:< clazz.typeRef)) {
+              assert(!(tree.tpe.typeSymbol.isPrimitiveValueClass))
+              val nullTree = Literal(Constant(null))
+              val unboxedNull = adaptToType(nullTree, underlying)
+
+              evalOnce(tree) { t =>
+                If(t.select(defn.Object_eq).appliedTo(nullTree),
+                  unboxedNull,
+                  unboxedTree(t))
+              }
+            } else unboxedTree(tree)
+
           cast(tree1, pt)
         case _ =>
           val cls = pt.widen.classSymbol

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

@@ -14,6 +14,7 @@ import typer.ErrorReporting._
 import ast.Trees._
 import Erasure.Boxing._
 import core.TypeErasure._
+import ValueClasses._
 
 /** This transform normalizes type tests and type casts,
  *  also replacing type tests with singleton argument type with reference equality check
@@ -90,7 +91,9 @@ trait TypeTestsCasts {
           }
           else if (argCls.isPrimitiveValueClass)
             unbox(qual.ensureConforms(defn.ObjectType), argType)
-          else
+          else if (isDerivedValueClass(argCls)) {
+            qual // adaptToType in Erasure will do the necessary type adaptation
+          } else
             derivedTree(qual, defn.Any_asInstanceOf, argType)
         }
         def erasedArg = erasure(tree.args.head.tpe, semiEraseVCs = false)

test/dotc/tests.scala

@@ -79,6 +79,7 @@ class tests extends CompilerTest {
   @Test def pos_overloadedAccess = compileFile(posDir, "overloadedAccess", twice)
   @Test def pos_approximateUnion = compileFile(posDir, "approximateUnion", twice)
   @Test def pos_tailcall = compileDir(posDir, "tailcall", twice)
+  @Test def pos_valueclasses = compileDir(posDir, "valueclasses", twice)
   @Test def pos_nullarify = compileFile(posDir, "nullarify", args = "-Ycheck:nullarify" :: Nil)
   @Test def pos_subtyping = compileFile(posDir, "subtyping", twice)
   @Test def pos_t2613 = compileFile(posSpecialDir, "t2613")(allowDeepSubtypes)

tests/pos/valueclasses/nullAsInstanceOfVC.scala

@@ -0,0 +1,27 @@
+// These issues were originally reported in SI-5866 and SI-8097
+// FIXME: Make this a run test once we have run tests.
+
+object VCNull {
+  case class Foo(d: Double) extends AnyVal {
+    override def toString = s"Foo($d)"
+  }
+  case class Bar(s: String) extends AnyVal {
+    override def toString = s"Bar($s)"
+  }
+
+  def testDirect(): Unit = {
+    val fooDirect: Foo = null.asInstanceOf[Foo]
+    val barDirect: Bar = null.asInstanceOf[Bar]
+  }
+
+  def testIndirect(): Unit = {
+    val fooIndirect: Foo = { val n: Any = null; n.asInstanceOf[Foo] }
+    val barIndirect: Bar = { val n: Any = null; n.asInstanceOf[Bar] }
+  }
+
+  def nullOf[T]: T = null.asInstanceOf[T]
+  def testGeneric(): Unit = {
+    val fooGeneric: Foo = nullOf[Foo]
+    val barGeneric: Bar = nullOf[Bar]
+  }
+}