Disallow comparison between object and null

Author: noti0na1

compiler/src/dotty/tools/dotc/core/JavaNullInterop.scala

@@ -52,12 +52,12 @@ object JavaNullInterop {
    *
    *  But the selection can throw an NPE if the returned value is `null`.
    */
-  def nullifyMember(sym: Symbol, tp: Type, isEnum: Boolean)(implicit ctx: Context): Type = {
+  def nullifyMember(sym: Symbol, tp: Type, isEnumValueDef: Boolean)(implicit ctx: Context): Type = {
     assert(ctx.explicitNulls)
     assert(sym.is(JavaDefined), "can only nullify java-defined members")
 
     // Some special cases when nullifying the type
-    if (isEnum || sym.name == nme.TYPE_)
+    if (isEnumValueDef || sym.name == nme.TYPE_)
       // Don't nullify the `TYPE` field in every class and Java enum instances
       tp
     else if (sym.name == nme.toString_ || sym.isConstructor || hasNotNullAnnot(sym))

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -813,9 +813,20 @@ trait Implicits { self: Typer =>
         else if (cls2.isPrimitiveValueClass)
           cmpWithBoxed(cls2, cls1)
         else if (cls1 == defn.NullClass)
-          cls1 == cls2 || cls2.derivesFrom(defn.ObjectClass)
-        else if (cls2 == defn.NullClass)
-          cls1.derivesFrom(defn.ObjectClass)
+          cls1 == cls2
+        else if (!ctx.explicitNulls)
+          // If explicit nulls is enabled, we want to disallow comparison between Object and Null.
+          // If a nullable value has a non-nullable type, we can still cast it to nullable type
+          // then compare.
+          //
+          // Example:
+          // val x: String = null.asInstanceOf[String]
+          // if (x == null) {} // error: x is non-nullable
+          // if (x.asInstanceOf[String|Null] == null) {} // ok
+          if (cls1 == defn.NullClass)
+            cls2.derivesFrom(defn.ObjectClass)
+          else
+            cls2 == defn.NullClass && cls1.derivesFrom(defn.ObjectClass)
         else
           false
       }
@@ -1464,7 +1475,7 @@ trait Implicits { self: Typer =>
         case alt1: SearchSuccess =>
           var diff = compareCandidate(alt1, alt2.ref, alt2.level)
           assert(diff <= 0)   // diff > 0 candidates should already have been eliminated in `rank`
-          
+
           if diff == 0 then
             // Fall back: if both results are extension method applications,
             // compare the extension methods instead of their wrappers.

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -59,7 +59,6 @@ class CompilationTests extends ParallelTesting {
       compileFile("tests/pos-special/typeclass-scaling.scala", defaultOptions.and("-Xmax-inlines", "40")),
       compileFile("tests/pos-special/indent-colons.scala", defaultOptions.and("-Yindent-colons")),
       compileFile("tests/pos-special/i7296.scala", defaultOptions.and("-strict", "-deprecation", "-Xfatal-warnings")),
-      compileFile("tests/pos-special/nullable.scala", defaultOptions.and("-Yexplicit-nulls")),
       compileFile("tests/pos-special/notNull.scala", defaultOptions.and("-Yexplicit-nulls")),
       compileDir("tests/pos-special/adhoc-extension", defaultOptions.and("-strict", "-feature", "-Xfatal-warnings")),
       compileFile("tests/pos-special/i7575.scala", defaultOptions.and("-language:dynamics")),

tests/explicit-nulls/neg/eq.scala

@@ -2,25 +2,36 @@
 class Foo {
   // Null itself
   val x0: Null = null
+  x0 != x0
   x0 == null
   x0 != null
   null == x0
   null == null
+  null != null
 
-  // Nullable types: OK
-  val x1: String|Null = null
-  x1 == null
-  null == x1
-  x1 == x0
-  x1 != x0
-  x0 == x1
+  // Non-nullable types: error
+  val x1: String = "hello"
+  x1 != null  // error
+  x1 == null  // error
+  null == x1  // error
+  null != x1  // error
+  x1 == x0    // error
+  x0 != x1    // error
+  x1.asInstanceOf[String|Null] == null
+  x1.asInstanceOf[String|Null] == x0
+  x1.asInstanceOf[Any] == null
+  x1.asInstanceOf[Any] == x0
 
-  // Reference types, even non-nullable ones: OK.
-  // Allowed as an escape hatch.
-  val x2: String = "hello"
-  x2 != null
+  // Nullable types: OK
+  val x2: String|Null = null
   x2 == null
   null == x2
+  x2 == x0
+  x2 != x0
+  x0 == x2
+  x2 == x1
+  x2 != x1
+  x1 == x2
 
   // Value types: not allowed.
   1 == null     // error

tests/explicit-nulls/run/eq.scala

@@ -14,6 +14,8 @@ object Test {
     assert(x != "xx")
     assert(x != y)
     assert(y == y)
+    assert(z.asInstanceOf[String|Null] != null)
+    assert(z.asInstanceOf[Any] != null)
 
     assert(x != null)
     assert(null != x)