Make space intersection of two open types non-empty

Author: abgruszecki

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

@@ -74,6 +74,15 @@ trait SpaceLogic {
   /** Is `tp1` the same type as `tp2`? */
   def isEqualType(tp1: Type, tp2: Type): Boolean
 
+  /** Can `tp` be arbitrarily subtyped by any other open type? */
+  def isOpen(tp: Type): Boolean
+
+  /** Construct a space which contains values from both `tp1` and `tp2`.
+   *
+   * Both types are expected to be open in the [[isOpen]] sense.
+   */
+  def commonOpenTypeSpace(tp1: Type, tp2: Type): Space
+
   /** Is the type `tp` decomposable? i.e. all values of the type can be covered
    *  by its decomposed types.
    *
@@ -171,6 +180,7 @@ trait SpaceLogic {
         else if (isSubType(tp2, tp1)) b
         else if (canDecompose(tp1)) tryDecompose1(tp1)
         else if (canDecompose(tp2)) tryDecompose2(tp2)
+        else if (isOpen(tp1) && isOpen(tp2)) commonOpenTypeSpace(tp1, tp2)
         else Empty
       case (Typ(tp1, _), Kon(tp2, ss)) =>
         if (isSubType(tp2, tp1)) b
@@ -243,6 +253,11 @@ trait SpaceLogic {
 class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
   import tpd._
 
+  override def isOpen(tp: Type) =
+    !tp.classSymbol.is(Sealed | Final) && !tp.termSymbol.is(Module)
+
+  override def commonOpenTypeSpace(tp1: Type, tp2: Type) = Typ(AndType(tp1, tp2), true)
+
   /** Return the space that represents the pattern `pat`
    *
    *  If roundUp is true, approximate extractors to its type,

tests/patmat/andtype-opentype-interaction.check

@@ -0,0 +1,3 @@
+19: Pattern Match Exhaustivity: _: AbstractClass & OpenTrait, _: Clazz & OpenTrait, _: Trait & OpenTrait
+23: Pattern Match Exhaustivity: _: AbstractClass & OpenClass, _: Clazz & OpenClass, _: Trait & OpenClass
+27: Pattern Match Exhaustivity: _: AbstractClass & OpenAbstractClass, _: Clazz & OpenAbstractClass, _: Trait & OpenAbstractClass

tests/patmat/andtype-opentype-interaction.scala

@@ -0,0 +1,30 @@
+sealed trait T
+trait Trait extends T
+class Clazz extends T
+abstract class AbstractClass extends T
+// none of the below can be extended
+sealed trait SealedTrait extends T
+final class FinalClass extends T
+sealed class SealedClass extends T
+sealed abstract class SealedAbstractClass extends T
+object Obj extends T
+
+trait OpenTrait
+class OpenClass
+abstract class OpenAbstractClass
+
+trait Unrelated
+
+object Test {
+  def m1(s: T & OpenTrait) = s match {
+    case _: Unrelated => ;
+  }
+
+  def m2(s: T & OpenClass) = s match {
+    case _: Unrelated => ;
+  }
+
+  def m3(s: T & OpenAbstractClass) = s match {
+    case _: Unrelated => ;
+  }
+}

tests/patmat/nontrivial-andtype.check

@@ -0,0 +1 @@
+16: Pattern Match Exhaustivity: D, _: C, B(), _: A

tests/patmat/nontrivial-andtype.scala

@@ -0,0 +1,19 @@
+object Test {
+  sealed trait Marker
+  trait M1 extends Marker
+  sealed trait Marker2 extends Marker
+  sealed trait M2 extends Marker2
+
+  sealed trait T
+  trait A extends T with M2
+  sealed trait T2 extends T
+  case class B() extends T2 with Marker
+  class C extends T2 with M1
+  case object D extends T2 with Marker
+
+  trait Unrelated
+
+  def m1(s: T & Marker) = s match {
+    case _: Unrelated => ;
+  }
+}