Prune impossible types from exaustivity checker

Author: OlivierBlanvillain

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

@@ -375,7 +375,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
   }
 
   /* Whether the extractor is irrefutable */
-  def irrefutable(unapp: tpd.Tree): Boolean = {
+  def irrefutable(unapp: Tree): Boolean = {
     // TODO: optionless patmat
     unapp.tpe.widen.finalResultType.isRef(scalaSomeClass) ||
       (unapp.symbol.is(Synthetic) && unapp.symbol.owner.linkedClass.is(Case)) ||
@@ -557,11 +557,11 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
   def refine(parent: Type, child: Symbol): Type = {
     if (child.isTerm && child.is(Case, butNot = Module)) return child.termRef // enum vals always match
 
-    val childTp  = if (child.isTerm) child.termRef else child.typeRef
+    val childTp = if (child.isTerm) child.termRef else child.typeRef
 
     val resTp = instantiate(childTp, parent)(ctx.fresh.setNewTyperState())
 
-    if (!resTp.exists)  {
+    if (!resTp.exists) {
       debug.println(s"[refine] unqualified child ousted: ${childTp.show} !< ${parent.show}")
       NoType
     }
@@ -625,7 +625,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     val tvars = tp1.typeParams.map { tparam => newTypeVar(tparam.paramInfo.bounds) }
     val protoTp1 = thisTypeMap(tp1.appliedTo(tvars))
 
-    if (protoTp1 <:< tp2) {
+    val result = if (protoTp1 <:< tp2) {
       if (isFullyDefined(protoTp1, force)) protoTp1
       else instUndetMap(protoTp1)
     }
@@ -640,6 +640,24 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
         NoType
       }
     }
+
+    // The intersection between a singleton type s and another type t is
+    // always empty when s is not a subtype of t. See patmat/i3573.scala
+    val hasEmptyIntersections = new ExistsAccumulator({
+      case AndType(s: SingletonType, t) =>
+        !(s <:< t)
+      case AndType(t, s: SingletonType) =>
+        !(s <:< t)
+      case x =>
+        false
+    })
+
+    if (hasEmptyIntersections(false, result)) {
+      debug.println(s"hasEmptyIntersections($protoTp1) = true")
+      NoType
+    } else {
+      result
+    }
   }
 
   /** Abstract sealed types, or-types, Boolean and Java enums can be decomposed */

tests/patmat/i3574.scala

@@ -0,0 +1,38 @@
+object PathVariantDefns {
+  sealed trait AtomBase {
+    sealed trait Atom
+    case class Zero(value: String) extends Atom
+  }
+
+  trait Atom1 extends AtomBase {
+    case class One(value: String) extends Atom
+  }
+
+  trait Atom2 extends AtomBase {
+    case class Two(value: String) extends Atom
+  }
+
+  object Atoms01 extends AtomBase with Atom1 {
+    def f = {
+      val a: Atom = null
+      a match {
+        case Zero(x) => ???
+        case One(x)  => ???
+        // match may not be exhaustive.
+        // It would fail on: PathVariantDefns.Atom2 & PathVariantDefns.Atoms01.type(PathVariantDefns.Atoms01).Two(_)
+      }
+    }
+  }
+
+  object Atoms02 extends AtomBase with Atom2 {
+    def f = {
+      val a: Atom = null
+      a match {
+        case Zero(x) => ???
+        case Two(x)  => ???
+        // match may not be exhaustive.
+        // It would fail on: PathVariantDefns.Atom1 & PathVariantDefns.Atoms02.type(PathVariantDefns.Atoms02).One(_)
+      }
+    }
+  }
+}