Fix #4661: Missing unreachable case warnings

Author: abeln

compiler/src/dotty/tools/dotc/tastyreflect/CaseDefOpsImpl.scala

@@ -11,11 +11,7 @@ trait CaseDefOpsImpl extends scala.tasty.reflect.CaseDefOps with TastyCoreImpl w
   }
 
   object CaseDef extends CaseDefExtractor {
-    def unapply(x: CaseDef): Option[(Pattern, Option[Term], Term)] = x match {
-      case x: tpd.CaseDef =>
-        Some(x.pat, optional(x.guard), x.body)
-      case _ => None
-    }
+    def unapply(x: CaseDef): Some[(Pattern, Option[Term], Term)] = Some(x.pat, optional(x.guard), x.body)
   }
 
 }

compiler/src/dotty/tools/dotc/tastyreflect/ConstantOpsImpl.scala

@@ -13,17 +13,11 @@ trait ConstantOpsImpl extends scala.tasty.reflect.ConstantOps with TastyCoreImpl
   object Constant extends ConstantModule {
 
     object Unit extends UnitExtractor {
-      def unapply(x: Constant): Boolean = x match {
-        case x: Constants.Constant => x.tag == Constants.UnitTag
-        case _ => false
-      }
+      def unapply(x: Constant): Boolean = x.tag == Constants.UnitTag
     }
 
     object Null extends NullExtractor {
-      def unapply(x: Constant): Boolean =  x match {
-        case x: Constants.Constant => x.tag == Constants.NullTag
-        case _ => false
-      }
+      def unapply(x: Constant): Boolean = x.tag == Constants.NullTag
     }
 
     object Boolean extends BooleanExtractor {

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

@@ -292,18 +292,23 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
   private val nullType             = ConstantType(Constant(null))
   private val nullSpace            = Typ(nullType)
 
-  override def intersectUnrelatedAtomicTypes(tp1: Type, tp2: Type): Space = {
-    val and = AndType(tp1, tp2)
-    // Precondition: !(tp1 <:< tp2) && !(tp2 <:< tp1)
-    // Then, no leaf of the and-type tree `and` is a subtype of `and`.
-    val res = inhabited(and)
-
-    debug.println(s"atomic intersection: ${and.show} = ${res}")
-
-    if (!res) Empty
-    else if (tp1.isSingleton) Typ(tp1, true)
-    else if (tp2.isSingleton) Typ(tp2, true)
-    else Typ(and, true)
+  override def intersectUnrelatedAtomicTypes(tp1: Type, tp2: Type) = {
+    // Precondition: !isSubType(tp1, tp2) && !isSubType(tp2, tp1)
+    if (tp1 == nullType || tp2 == nullType) {
+      // Since projections of types don't include null, intersection with null is empty.
+      Empty
+    } else {
+      val and = AndType(tp1, tp2)
+      // Then, no leaf of the and-type tree `and` is a subtype of `and`.
+      val res = inhabited(and)
+
+      debug.println(s"atomic intersection: ${and.show} = ${res}")
+
+      if (!res) Empty
+      else if (tp1.isSingleton) Typ(tp1, true)
+      else if (tp2.isSingleton) Typ(tp2, true)
+      else Typ(and, true)
+    }
   }
 
   /** Whether the extractor is irrefutable */

tests/patmat/i4880a.check

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

tests/patmat/t4661.check

@@ -0,0 +1,15 @@
+9: Match case Unreachable
+10: Match case Unreachable
+11: Match case Unreachable
+26: Match case Unreachable
+27: Match case Unreachable
+28: Match case Unreachable
+33: Match case Unreachable
+36: Match case Unreachable
+37: Match case Unreachable
+38: Match case Unreachable
+39: Match case Unreachable
+40: Only null matched
+46: Match case Unreachable
+52: Match case Unreachable
+59: Only null matched

tests/patmat/t4661.scala

@@ -0,0 +1,61 @@
+trait Foo
+class One extends Foo
+class Two extends Foo
+class Three extends Foo
+
+object Test {
+  def test(f: Foo) = f match {
+    case f: Foo =>
+    case f: One =>   // unreachable
+    case f: Two =>   // unreachable
+    case f: Three => // unreachable
+  }
+}
+
+trait Prefix {
+  sealed trait Bar
+  class BarOne extends Bar
+  class BarTwo extends Bar
+  class BarThree extends Bar
+}
+
+class TestPrefix(val p: Prefix) {
+  import p._
+  def test(b: Bar) = b match {
+    case b: Bar =>
+    case b: BarOne =>   // unreachable
+    case b: BarTwo =>   // unreachable
+    case b: BarThree => // unreachable
+  }
+
+  def test2(b: Bar) = b match {
+    case b: Prefix#BarOne =>
+    case b: BarOne =>  // unreachable
+    case b: Prefix#BarTwo =>
+    case b: Prefix#BarThree =>
+    case b: BarTwo =>     // unreachable
+    case b: BarThree =>   // unreachable
+    case b: Bar =>        // unreachable
+    case b: Prefix#Bar => // unreachable
+    case _ => // only null matches
+  }
+
+  def test3(b: Prefix#Bar) = b match {
+    case b: Bar =>
+    case b: Prefix#BarOne =>
+    case b: BarOne => // unreachable
+    case _ =>
+  }
+
+  def test4(b: Bar) = b match {
+    case b: Bar =>
+    case b:Prefix#Bar => // unreachable
+  }
+
+  def test5(b: Bar) = b match {
+    case b: Prefix#BarOne =>
+    case b: Prefix#BarTwo =>
+    case b: Prefix#BarThree =>
+    case _ => // only null matches
+  }
+}