Fix space in unsafe nulls

Author: noti0na1

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

@@ -813,7 +813,7 @@ object SymDenotations {
     /** Is this symbol a class of which `null` is a value? */
     final def isNullableClass(using Context): Boolean =
       if ctx.mode.is(Mode.SafeNulls) && !ctx.phase.erasedTypes
-      then symbol == defn.NullClass || symbol == defn.AnyClass
+      then symbol == defn.NullClass || symbol == defn.AnyClass || symbol == defn.MatchableClass
       else isNullableClassAfterErasure
 
     /** Is this symbol a class of which `null` is a value after erasure?

compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala

@@ -13,6 +13,7 @@ import SymUtils._
 import Flags._, Constants._
 import Decorators._
 import NameKinds.{PatMatStdBinderName, PatMatAltsName, PatMatResultName}
+import typer.Nullables
 import config.Printers.patmatch
 import reporting._
 import dotty.tools.dotc.ast._
@@ -40,8 +41,12 @@ class PatternMatcher extends MiniPhase {
         case rt => tree.tpe
       val translated = new Translator(matchType, this).translateMatch(tree)
 
+      val engineCtx =
+        if tree.hasAttachment(Nullables.UnsafeNullsMatch)
+        then ctx.retractMode(Mode.SafeNulls) else ctx
+
       // check exhaustivity and unreachability
-      val engine = new patmat.SpaceEngine
+      val engine = new patmat.SpaceEngine()(using engineCtx)
       engine.checkExhaustivity(tree)
       engine.checkRedundancy(tree)
 

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -331,16 +331,13 @@ class SpaceEngine(using Context) extends SpaceLogic {
 
   override def intersectUnrelatedAtomicTypes(tp1: Type, tp2: Type): Space = trace(s"atomic intersection: ${AndType(tp1, tp2).show}", debug) {
     // Precondition: !isSubType(tp1, tp2) && !isSubType(tp2, tp1).
-    if (!ctx.explicitNulls && (tp1.isNullType || tp2.isNullType)) {
+    if !ctx.mode.is(Mode.SafeNulls) && (tp1.isNullType || tp2.isNullType) then
       // Since projections of types don't include null, intersection with null is empty.
       Empty
-    }
-    else {
+    else
       val res = TypeComparer.provablyDisjoint(tp1, tp2)
-
-      if (res) Empty
+      if res then Empty
       else Typ(AndType(tp1, tp2), decomposed = true)
-    }
   }
 
   /** Return the space that represents the pattern `pat` */
@@ -532,7 +529,8 @@ class SpaceEngine(using Context) extends SpaceLogic {
 
   /** Is `tp1` a subtype of `tp2`?  */
   def isSubType(tp1: Type, tp2: Type): Boolean = trace(i"$tp1 <:< $tp2", debug, show = true) {
-    if tp1 == constantNullType && !ctx.explicitNulls then tp2 == constantNullType
+    if tp1 == constantNullType && !ctx.mode.is(Mode.SafeNulls)
+    then tp2 == constantNullType
     else adaptType(tp1, tp2) <:< tp2
   }
 

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

@@ -20,6 +20,13 @@ import ast.Trees.mods
 object Nullables:
   import ast.tpd._
 
+  /** An attachment that represents a match tree is created under Unsafe Nulls.
+   *  This is used to pass Unsafe Nulls information to PatternMatcher Phase,
+   *  so we don't get Match case Unreachable Warning when using `case null => ???`
+   *  on non-nullable type.
+   */
+  val UnsafeNullsMatch = Property.StickyKey[Unit]
+
   inline def unsafeNullsEnabled(using Context): Boolean =
     ctx.explicitNulls && !ctx.mode.is(Mode.SafeNulls)
 

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

@@ -1484,7 +1484,7 @@ class Typer extends Namer
   }
 
   def typedMatch(tree: untpd.Match, pt: Type)(using Context): Tree =
-    tree.selector match {
+    val tree1 = tree.selector match {
       case EmptyTree =>
         if (tree.isInline) {
           checkInInlineContext("summonFrom", tree.srcPos)
@@ -1581,6 +1581,9 @@ class Typer extends Namer
             result
         }
     }
+    if Nullables.unsafeNullsEnabled then
+      tree1.putAttachment(Nullables.UnsafeNullsMatch, ())
+    tree1
 
   /** Special typing of Match tree when the expected type is a MatchType,
    *  and the patterns of the Match tree and the MatchType correspond.

tests/explicit-nulls/unsafe-common/unsafe-match-null.scala

@@ -0,0 +1,12 @@
+def test1 =
+  val s: String = ???
+  s match
+    case _: String =>
+    // under unsafeNulls, we should not get Match case Unreachable Warning
+    case null => // error
+
+def test2 =
+  val s: String | Null = ???
+  s match
+    case _: String =>
+    case null =>