Fix SAM type check; fix null conversion to AnyRef and eq select

Author: noti0na1

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

@@ -46,13 +46,7 @@ object NullOpsDecorator {
       object RemoveNulls extends TypeMap {
         override def apply(tp: Type): Type =
           val mapped = mapOver(tp.widenTermRefExpr.stripNull)
-          tp match {
-            case tr: TermRef =>
-              if tp eq mapped then tp
-              else AndType(tr, mapped)
-            case _ =>
-              mapped
-          }
+          if tp eq mapped then tp else mapped
       }
       val rem = RemoveNulls(self)
       if rem ne self then rem else self

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

@@ -559,7 +559,14 @@ class Typer extends Namer
       val qual1 = qual.tpe match {
         case OrNull(tpe1) if config.Feature.enabled(nme.unsafeNulls) =>
           qual.cast(AndType(qual.tpe, tpe1))
-        case _ => qual
+        case tp =>
+          if ctx.explicitNulls &&
+            tp.isNullType &&
+            config.Feature.enabled(nme.unsafeNulls) &&
+            (tree.name == nme.eq || tree.name == nme.ne) then
+            // Allow selecting `eq` and `ne` on `Null` specially
+            qual.cast(defn.ObjectType)
+          else qual
       }
       typedSelect(tree, pt, qual1).computeNullable()
 
@@ -1257,8 +1264,9 @@ class Typer extends Namer
             val pt1 = if ctx.explicitNulls then pt.stripNull else pt
             pt1 match {
               case SAMType(sam)
-              if !defn.isFunctionType(pt1) && mt <:< sam ||
-                JavaNullInterop.convertUnsafeNulls && mt.isUnsafeConvertable(sam) =>
+              if !defn.isFunctionType(pt1) && (
+                mt <:< sam ||
+                JavaNullInterop.convertUnsafeNulls && mt.stripAllNulls <:< sam.stripAllNulls) =>
                 // SAMs of the form C[?] where C is a class cannot be conversion targets.
                 // The resulting class `class $anon extends C[?] {...}` would be illegal,
                 // since type arguments to `C`'s super constructor cannot be constructed.
@@ -3439,7 +3447,7 @@ class Typer extends Namer
             case SAMType(sam)
             if wtp <:< sam.toFunctionType() ||
               (JavaNullInterop.convertUnsafeNulls &&
-                wtp.isUnsafeConvertable(sam.toFunctionType())) =>
+                wtp.stripAllNulls <:< sam.toFunctionType().stripAllNulls) =>
               // was ... && isFullyDefined(pt, ForceDegree.flipBottom)
               // but this prevents case blocks from implementing polymorphic partial functions,
               // since we do not know the result parameter a priori. Have to wait until the
@@ -3508,10 +3516,12 @@ class Typer extends Namer
         }
       }
 
+      val treeTpe = tree.tpe
+
       def tryUnsafeNullConver(fail: => Tree)(using Context): Tree =
         // If explicitNulls and unsafeNulls are enabled, and
         if ctx.mode.is(Mode.UnsafeNullConversion) && pt.isValueType &&
-          tree.tpe.isUnsafeConvertable(pt)
+          treeTpe.isUnsafeConvertable(pt)
         then tree.cast(pt)
         else fail
 
@@ -3533,17 +3543,23 @@ class Typer extends Namer
       inContext(searchCtx) {
         if ctx.mode.is(Mode.ImplicitsEnabled) && tree.typeOpt.isValueType then
           if pt.isRef(defn.AnyValClass) || pt.isRef(defn.ObjectClass) then
-            report.error(em"the result of an implicit conversion must be more specific than $pt", tree.srcPos)
-          def normalSearch =
-            searchTree(tree)(failure => tryUnsafeNullConver(cannotFind(failure)))
-          tree.tpe match {
-            case OrNull(tpe1) if ctx.mode.is(Mode.UnsafeNullConversion) =>
-              // If the type of the tree is nullable, and unsafeNullConversion is enabled,
-              // then we search the tree without the `Null` type first.
-              // If this fails, we search the original tree.
-              searchTree(tree.cast(tpe1)) { _ => normalSearch }
-            case _ =>
-              normalSearch
+            // We want to allow `null` to `AnyRef` if UnsafeNullConversion is enabled
+            if !(ctx.explicitNulls &&
+              treeTpe.isUnsafeConvertable(pt) &&
+              ctx.mode.is(Mode.UnsafeNullConversion)) then
+              report.error(em"the result of an implicit conversion must be more specific than $pt", tree.srcPos)
+            tree.cast(pt)
+          else
+            def normalSearch =
+              searchTree(tree)(failure => tryUnsafeNullConver(cannotFind(failure)))
+            treeTpe match {
+              case OrNull(tpe1) if ctx.mode.is(Mode.UnsafeNullConversion) =>
+                // If the type of the tree is nullable, and unsafeNullConversion is enabled,
+                // then we search the tree without the `Null` type first.
+                // If this fails, we search the original tree.
+                searchTree(tree.cast(tpe1)) { _ => normalSearch }
+              case _ =>
+                normalSearch
           }
         else tryUnsafeNullConver(recover(NoMatchingImplicits))
       }

docs/docs/reference/other-new-features/explicit-nulls.md

@@ -443,6 +443,8 @@ Users can import `scala.language.unsafeNulls` to create such scopes, or use `-la
 3. convert `T1` to `T2` if `T1.stripAllNulls <:< T2.stripAllNulls` or `T1` is `Null` and `T2` has null value after erasure
 4. allow equality check between `T` and `T | Null`
 
+Addtionally, `null` can be used as `AnyRef` (`Object`), which means you can select `.eq` or `.toString` on it.
+
 The intention of this `unsafeNulls` is to give users a better migration path for explicit nulls. Projects for Scala 2 or regular dotty can try this by adding `-Yexplicit-nulls -language:unsafeNulls` to the compile options. A small number of manual modifications are expected (for example, some code relies on the fact of `Null <:< AnyRef`). To migrate to full explicit nulls in the future, `-language:unsafeNulls` can be dropped and add `import scala.language.unsafeNulls` only when needed.
 
 ```scala

tests/explicit-nulls/neg/eq.scala renamed to tests/explicit-nulls/neg/equal1.scala

@@ -0,0 +1,4 @@
+def f = {
+  val smap: Map[String, String] = ???
+  val ss = smap.map { case (n, v) => (n, n + v) }
+}

tests/explicit-nulls/neg/eq2.scala renamed to tests/explicit-nulls/neg/equal2.scala

@@ -0,0 +1,16 @@
+val s1: String = ???
+val s2: String  | Null = ???
+
+def f = {
+  s1 eq s2 // error
+  s2 eq s1 // error
+
+  s1 ne s2 // error
+  s2 ne s1 // error
+
+  s1 eq null // error
+  s2 eq null // error
+
+  null eq s1 // error
+  null eq s2 // error
+}