Add a special rule for CanEqualNull

Author: noti0na1

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

@@ -743,8 +743,12 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         }
         compareTypeBounds
       case tp2: AnnotatedType if tp2.isRefining =>
-        (tp1.derivesAnnotWith(tp2.annot.sameAnnotation) || tp1.isBottomType) &&
-        recur(tp1, tp2.parent)
+        // `CanEqualNull` is a special refining annotation.
+        // An annotated type is equivalent to the original type.
+        (tp1.derivesAnnotWith(tp2.annot.sameAnnotation)
+        || tp2.annot.matches(defn.CanEqualNullAnnot)
+        || tp1.isBottomType)
+        && recur(tp1, tp2.parent)
       case ClassInfo(pre2, cls2, _, _, _) =>
         def compareClassInfo = tp1 match {
           case ClassInfo(pre1, cls1, _, _, _) =>

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

@@ -173,8 +173,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
         // 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 then cls1 == cls2
-        else cls1 == defn.NothingClass || cls2 == defn.NothingClass
+        cls1 == defn.NullClass && cls1 == cls2
       else if cls1 == defn.NullClass then
         cls1 == cls2 || cls2.derivesFrom(defn.ObjectClass)
       else if cls2 == defn.NullClass then

library/src/scala/annotation/CanEqualNull.scala

@@ -1,3 +1,21 @@
 package scala.annotation
 
+/** An annotation makes reference types comparable to `null` in explicit nulls.
+ * `CanEqualNull` is a special refining annotation. An annotated type is equivalent to the original type.
+ *
+ *  For example:
+ *  ```scala
+ *  val s1: String = ???
+ *  s1 == null // error
+ *  val s2: String @CanEqualNull = ???
+ *  s2 == null // ok
+ *
+ *  // String =:= String @CanEqualNull
+ *  val s3: String = s2
+ *  val s4: String @CanEqualNull = s1
+ *
+ *  val ss: Array[String @CanEqualNull] = ??
+ *  ss.map(_ == null)
+ *  ```
+ */
 final class CanEqualNull extends RefiningAnnotation

tests/explicit-nulls/unsafe-java-common/java-class/S.scala

@@ -1,41 +1,55 @@
 import scala.language.unsafeJavaReturn
+
+import scala.annotation.CanEqualNull
 import java.{util => ju}
 
 class S {
 
   def test[T <: AnyRef](jc: JC) = {
-    // val a: Int = jc.a
-
-    // val b = jc.b // it returns String @CanEqualNull
-    // val b2: String = b
-    // val b3: String = jc.b
-    // val bb = jc.b == null // it's ok to compare String @CanEqualNull with Null
-    // val btl = jc.b.trim().length() // String @CanEqualNull is just String, unsafe selecting
-
-    // val c = jc.c
-    // val cl = c.length
-    // val c2: Array[String] = c
-    val c3: Array[String] = jc.c
-    // val c4: Array[Int] = c.map(_.length())
-
-    // val f1: Int = jc.f1()
-    // val f2: Array[Int] = jc.f2()
-    // val f2n = jc.f2() == null
-
-    // val g1: String = jc.g1()
-    // val g1n = jc.g1() == null
-    // val g1tl = jc.g1().trim().length()
-
-    // val g2h: ju.List[String] = jc.g2()
-
-    // val g3: Array[String] = jc.g3()
-    // val g3n = jc.g3() == null
-    // val g3m: Array[Boolean] = jc.g3().map(_ == null)
-
-    // val h1: T = jc.h1[T]()
-
-    // val h2: ju.List[T] = jc.h2()
-
-    // val h3: Array[T] = jc.h3()
+    val a: Int = jc.a
+
+    val b = jc.b // it returns String @CanEqualNull
+    val b2: String = b
+    val b3: String @CanEqualNull = jc.b
+    val b4: String = jc.b
+    val bb = jc.b == null // it's ok to compare String @CanEqualNull with Null
+    val btl = jc.b.trim().length() // String @CanEqualNull is just String, unsafe selecting
+
+    val c = jc.c
+    val cl = c.length
+    val c2: Array[String] = c
+    val c3: Array[String @CanEqualNull] @CanEqualNull = jc.c
+    val c4: Array[String] = jc.c
+    val cml: Array[Int] = c.map(_.length())
+
+    val f1: Int = jc.f1()
+
+    val f21: Array[Int] @CanEqualNull = jc.f2()
+    val f22: Array[Int] = jc.f2()
+    val f2n = jc.f2() == null
+
+    val g11: String @CanEqualNull = jc.g1()
+    val g12: String = jc.g1()
+    val g1n = jc.g1() == null
+    val g1tl = jc.g1().trim().length()
+
+    val g21: ju.List[String] @CanEqualNull = jc.g2()
+    val g22: ju.List[String] = jc.g2()
+
+    val g31: Array[String @CanEqualNull] @CanEqualNull = jc.g3()
+    val g32: Array[String] = jc.g3()
+    val g3n = jc.g3() == null
+    val g3m: Array[Boolean] = jc.g3().map(_ == null)
+
+    val h11: T @CanEqualNull = jc.h1[T]()
+    val h12: T = jc.h1[T]()
+    val h1n = jc.h1[T]() == null
+
+    val h21: ju.List[T] @CanEqualNull = jc.h2[T]()
+    val h22: ju.List[T] = jc.h2[T]()
+
+    val h31: Array[T @CanEqualNull] @CanEqualNull = jc.h3[T]()
+    val h32: Array[T] = jc.h3[T]()
+    val h3m = jc.h3[T]().map(_ == null)
   }
 }