handle null in reachability check

Note that we only handle null in reachability check,
while ignore null in exhaustivity check. Otherwise,
the following pattern match will report a warning
about `null`, which is annoying:

    (Some(3): Option[Int]) match {
       case Some(x) =>
       case None    =>
    }

Author: liufengyun

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

@@ -63,7 +63,7 @@ case object Empty extends Space
  * @param decomposed: does the space result from decomposition? Used for pretty print
  *
  */
-case class Typ(tp: Type, decomposed: Boolean) extends Space
+case class Typ(tp: Type, decomposed: Boolean = true) extends Space
 
 /** Space representing an extractor pattern */
 case class Prod(tp: Type, unappTp: Type, unappSym: Symbol, params: List[Space], full: Boolean) extends Space
@@ -315,6 +315,8 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
       else
         Typ(ConstantType(c), false)
     case _: BackquotedIdent => Typ(pat.tpe, false)
+    case Ident(nme.WILDCARD) =>
+      Or(Typ(pat.tpe.stripAnnots, false) :: Typ(ConstantType(Constant(null))) :: Nil)
     case Ident(_) | Select(_, _) =>
       Typ(pat.tpe.stripAnnots, false)
     case Alternative(trees) => Or(trees.map(project(_)))
@@ -374,7 +376,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
 
   /** Is `tp1` a subtype of `tp2`?  */
   def isSubType(tp1: Type, tp2: Type): Boolean = {
-    val res = tp1 <:< tp2
+    val res = tp1 <:< tp2 && (tp1 != ConstantType(Constant(null)) || tp2 == ConstantType(Constant(null)))
     debug.println(s"${tp1.show} <:< ${tp2.show} = $res")
     res
   }
@@ -547,13 +549,6 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
       case tp             => tp.isSingleton
     }
 
-    def superType(tp: Type): Type = tp match {
-      case tp: TypeProxy     => tp.superType
-      case OrType(tp1, tp2)  => OrType(superType(tp1), superType(tp2))
-      case AndType(tp1, tp2) => AndType(superType(tp1), superType(tp2))
-      case _                 => tp
-    }
-
     def recur(tp: Type): Boolean = tp.dealias match {
       case AndType(tp1, tp2) =>
         recur(tp1) && recur(tp2) && {
@@ -574,8 +569,8 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
           noClassConflict &&
             (!isSingleton(tp1) || tp1 <:< tp2) &&
             (!isSingleton(tp2) || tp2 <:< tp1) &&
-            (!bases1.exists(_ is Final) || tp1 <:< superType(tp2)) &&
-            (!bases2.exists(_ is Final) || tp2 <:< superType(tp1))
+            (!bases1.exists(_ is Final) || tp1 <:< tp2) &&
+            (!bases2.exists(_ is Final) || tp2 <:< tp1)
         }
       case OrType(tp1, tp2) =>
         recur(tp1) || recur(tp2)
@@ -894,8 +889,9 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     val checkGADTSAT = shouldCheckExamples(selTyp)
 
     val uncovered =
-      flatten(simplify(minus(Typ(selTyp, true), patternSpace), aggressive = true))
-        .filter(s => s != Empty && (!checkGADTSAT || satisfiable(s)))
+      flatten(simplify(minus(Typ(selTyp, true), patternSpace), aggressive = true)).filter { s =>
+        s != Empty && (!checkGADTSAT || satisfiable(s))
+      }
 
     if (uncovered.nonEmpty)
       ctx.warning(PatternMatchExhaustivity(show(Or(uncovered))), sel.pos)
@@ -908,6 +904,12 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     val Match(sel, cases) = _match
     val selTyp = sel.tpe.widen.dealias
 
+    def targetSpace: Space =
+      if (selTyp.classSymbol.isPrimitiveValueClass)
+        Typ(selTyp, true)
+      else
+        Or(Typ(selTyp, true) :: Typ(ConstantType(Constant(null))) :: Nil)
+
     if (!redundancyCheckable(sel)) return
 
     (0 until cases.length).foreach { i =>
@@ -921,13 +923,20 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
             else Empty
           }.reduce((a, b) => Or(List(a, b)))
 
-      if (cases(i).pat != EmptyTree) { // rethrow case of catch
+      if (cases(i).pat != EmptyTree) { // rethrow case of catch uses EmptyTree
         val curr = project(cases(i).pat)
 
         debug.println(s"---------------reachable? ${show(curr)}")
         debug.println(s"prev: ${show(prevs)}")
 
-        if (isSubspace(intersect(curr, Typ(selTyp, false)), prevs)) {
+        var covered = simplify(intersect(curr, targetSpace))
+        debug.println(s"covered: $covered")
+
+        // `covered == Empty` may happen for primitive types with auto-conversion
+        // see tests/patmat/reader.scala  tests/patmat/byte.scala
+        if (covered == Empty) covered = curr
+
+        if (isSubspace(covered, prevs)) {
           ctx.warning(MatchCaseUnreachable(), cases(i).body.pos)
         }
       }

tests/patmat/andtype-opentype-interaction.check

@@ -2,6 +2,5 @@
 27: Pattern Match Exhaustivity: _: SealedAbstractClass & OpenTrait & OpenTrait2, _: SealedClass & OpenTrait & OpenTrait2, _: SealedTrait & OpenTrait & OpenTrait2, _: AbstractClass & OpenTrait & OpenTrait2, _: Clazz & OpenTrait & OpenTrait2, _: Trait & OpenTrait & OpenTrait2
 31: Pattern Match Exhaustivity: _: SealedTrait & OpenClass, _: Trait & OpenClass
 35: Pattern Match Exhaustivity: _: SealedTrait & OpenTrait & OpenClass, _: Trait & OpenTrait & OpenClass
-40: Match case Unreachable
 43: Pattern Match Exhaustivity: _: SealedTrait & OpenAbstractClass, _: Trait & OpenAbstractClass
 47: Pattern Match Exhaustivity: _: SealedTrait & OpenClass & OpenTrait & OpenClassSubclass, _: Trait & OpenClass & OpenTrait & OpenClassSubclass

tests/patmat/andtype-refinedtype-interaction.check

@@ -1,9 +1,6 @@
 32: Pattern Match Exhaustivity: _: Trait & C1{x: Int}
-37: Match case Unreachable
-43: Match case Unreachable
 48: Pattern Match Exhaustivity: _: Clazz & (C1 | C2 | T1){x: Int} & (C3 | C4 | T2){x: Int}, _: Trait & (C1 | C2 | T1){x: Int} & (C3 | C4 | T2){x: Int}
 54: Pattern Match Exhaustivity: _: Trait & (C1 | C2 | T1){x: Int} & C3{x: Int}
-60: Match case Unreachable
 65: Pattern Match Exhaustivity: _: Trait & (C1 | C2){x: Int} & (C3 | SubC1){x: Int}
 72: Pattern Match Exhaustivity: _: Trait & (T1 & (C1 | SubC2)){x: Int} & (T2 & (C2 | C3 | SubC1)){x: Int} &
   SubSubC1{x: Int}

tests/patmat/byte.check

@@ -0,0 +1 @@
+5: Match case Unreachable

tests/patmat/byte.scala

@@ -2,6 +2,7 @@ class Test {
   def foo(x: Byte) = x match {
     case 23 =>
     case 33 =>
+    case 33 =>
     case _  =>
   }
 }

tests/patmat/i2253.check

@@ -1,5 +1,3 @@
 28: Pattern Match Exhaustivity: HasIntXIntM, HasIntXStringM
 29: Pattern Match Exhaustivity: HasIntXIntM
-29: Match case Unreachable
 30: Pattern Match Exhaustivity: HasIntXIntM
-30: Match case Unreachable

tests/patmat/i4225b.scala

@@ -0,0 +1,12 @@
+object Bar {
+  def unapply(x: String): Some[Int] =
+    Some(0)
+}
+
+object Test {
+  def test(x: String) =
+    x match {
+      case Bar(a) => a
+      case _ => x // this case is reachable, i.e. test(null)
+    }
+}

tests/patmat/null.check

@@ -0,0 +1,2 @@
+6: Match case Unreachable
+18: Match case Unreachable

tests/patmat/null.scala

@@ -0,0 +1,22 @@
+class Test {
+  def foo(x: Option[Int]) = x match {
+    case Some(x) =>
+    case None    =>
+    case null    =>     // don't produce warning here
+    case _       =>
+  }
+
+  def bar(x: Option[String]) = x match {
+    case Some(a: String)        =>
+    case Some(null)     =>
+    case None           =>
+    case y              =>
+  }
+
+  def quux(x: Option[String]) = x match {
+    case Some(a)        =>
+    case Some(null)     =>
+    case None           =>
+    case y              =>
+  }
+}

tests/patmat/reader.check

@@ -0,0 +1 @@
+8: Match case Unreachable