Improve atomic type intersection

Handle:
- nested and-types
- refined types
- type aliasing

Add line end trimming to patmat tests to work around an issue
where lines end with spaces.

Author: abgruszecki

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

@@ -246,18 +246,70 @@ trait SpaceLogic {
   }
 }
 
+object SpaceEngine {
+  private sealed trait Implementability
+  private object ClassOrTrait extends Implementability
+  private case class SubclassOf(classSyms: List[Symbol]) extends Implementability
+  private object Unimplementable extends Implementability
+}
+
 /** Scala implementation of space logic */
 class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
+  import SpaceEngine._
   import tpd._
 
-  override def intersectUnrelatedAtomicTypes(tp1: Type, tp2: Type) = {
-    def isOpen(tp: Type) =
-      !tp.classSymbol.is(Sealed | Final) && !tp.termSymbol.is(Module)
+  /** Checks if `tp` can be implemented by a new class/trait.
+   *
+   * - doesn't handle member collisions (assumes they don't happen)
+   * - expects that neither Any nor Object reach it
+   *   (this is currently true due to both isSubType and and/or type simplification)
+   */
+  private def implementability(tp: Type): Implementability = tp.dealias match {
+    case AndType(tp1, tp2) =>
+      (implementability(tp1), implementability(tp2)) match {
+        case (Unimplementable, _) | (_, Unimplementable) => Unimplementable
+        case (SubclassOf(classSyms1), SubclassOf(classSyms2)) =>
+          (for {
+            sym1 <- classSyms1
+            sym2 <- classSyms2
+            result <-
+              if (sym1 isSubClass sym2) List(sym1)
+              else if (sym2 isSubClass sym1) List(sym2)
+              else Nil
+          } yield result) match {
+            case Nil => Unimplementable
+            case lst => SubclassOf(lst)
+          }
+        case (ClassOrTrait, ClassOrTrait) => ClassOrTrait
+        case (SubclassOf(clss), _) => SubclassOf(clss)
+        case (_, SubclassOf(clss)) => SubclassOf(clss)
+      }
+    case OrType(tp1, tp2) =>
+      (implementability(tp1), implementability(tp2)) match {
+        case (ClassOrTrait, _) | (_, ClassOrTrait) => ClassOrTrait
+        case (SubclassOf(classSyms1), SubclassOf(classSyms2)) =>
+          SubclassOf(classSyms1 ::: classSyms2)
+        case (SubclassOf(classSyms), _) => SubclassOf(classSyms)
+        case (_, SubclassOf(classSyms)) => SubclassOf(classSyms)
+        case _ => Unimplementable
+      }
+    case tp: RefinedType => implementability(tp.parent)
+    case other =>
+      val classSym = other.classSymbol
+      val isOpen =
+        !classSym.is(Sealed | Final) && !other.termSymbol.is(Module)
+
+      if (isOpen) {
+        if (classSym is Trait) ClassOrTrait else SubclassOf(List(classSym))
+      } else Unimplementable
+  }
 
-    if ((tp1.classSymbol.is(Trait) || tp2.classSymbol.is(Trait))
-        && isOpen(tp1) && isOpen(tp2))
-      Typ(AndType(tp1, tp2), true)
-    else Empty
+  override def intersectUnrelatedAtomicTypes(tp1: Type, tp2: Type) = {
+    val and = AndType(tp1, tp2)
+    implementability(and) match  {
+      case Unimplementable => Empty
+      case _ => Typ(and, true)
+    }
   }
 
   /** Return the space that represents the pattern `pat`

compiler/test/dotty/tools/dotc/transform/PatmatExhaustivityTest.scala

@@ -28,11 +28,11 @@ class PatmatExhaustivityTest {
         e.printStackTrace()
     }
 
-    val actual = stringBuffer.toString.trim
+    val actual = stringBuffer.toString.trim.replaceAll("\\s+\n", "\n")
     val checkFilePath = file.getAbsolutePath.stripSuffix(".scala") + ".check"
     val checkContent =
       if (new File(checkFilePath).exists)
-        fromFile(checkFilePath).getLines.mkString("\n").trim
+        fromFile(checkFilePath).getLines.map(_.replaceAll("\\s+$", "")).mkString("\n").trim
       else ""
 
     (file, checkContent, actual)
@@ -55,11 +55,11 @@ class PatmatExhaustivityTest {
         e.printStackTrace()
     }
 
-    val actual = stringBuffer.toString.trim
+    val actual = stringBuffer.toString.trim.replaceAll("\\s+\n", "\n")
     val checkFilePath = file.getPath + File.separator + "expected.check"
     val checkContent =
       if (new File(checkFilePath).exists)
-        fromFile(checkFilePath).getLines.mkString("\n").trim
+        fromFile(checkFilePath).getLines.map(_.replaceAll("\\s+$", "")).mkString("\n").trim
       else ""
 
     (file, checkContent, actual)

tests/patmat/aliasing.check

@@ -0,0 +1,3 @@
+14: Pattern Match Exhaustivity: _: Clazz & Test.Alias1, _: Trait & Test.Alias1
+19: Pattern Match Exhaustivity: _: Trait & Test.Alias2
+23: Pattern Match Exhaustivity: _: Trait & (Test.Alias2 & OpenTrait2){x: Int}

tests/patmat/aliasing.scala

@@ -0,0 +1,26 @@
+sealed trait T
+trait Trait extends T
+class Clazz extends T
+object Obj extends T
+
+trait OpenTrait
+trait OpenTrait2
+class OpenClass
+
+trait Unrelated
+
+object Test {
+  type Alias1 = OpenTrait
+  def traitAndClass(s: T & Alias1) = s match {
+    case _: Unrelated => ;
+  }
+
+  type Alias2 = OpenTrait & OpenClass
+  def classOnly(s: T & Alias2) = s match {
+    case _: Unrelated => ;
+  }
+
+  def classOnlyRefined(s: T & (Alias2 & OpenTrait2) { val x: Int }) = s match {
+    case _: Unrelated => ;
+  }
+}

tests/patmat/andtype-opentype-interaction.check

@@ -1,3 +1,6 @@
-19: Pattern Match Exhaustivity: _: AbstractClass & OpenTrait, _: Clazz & OpenTrait, _: Trait & OpenTrait
-23: Pattern Match Exhaustivity: _: Trait & OpenClass
-27: Pattern Match Exhaustivity: _: Trait & OpenAbstractClass
+23: Pattern Match Exhaustivity: _: AbstractClass & OpenTrait, _: Clazz & OpenTrait, _: Trait & OpenTrait
+27: Pattern Match Exhaustivity: _: AbstractClass & OpenTrait & OpenTrait2, _: Clazz & OpenTrait & OpenTrait2, _: Trait & OpenTrait & OpenTrait2
+31: Pattern Match Exhaustivity: _: Trait & OpenClass
+35: Pattern Match Exhaustivity: _: Trait & OpenTrait & OpenClass
+43: Pattern Match Exhaustivity: _: Trait & OpenAbstractClass
+47: Pattern Match Exhaustivity: _: Trait & OpenTrait & OpenClassSubclass

tests/patmat/andtype-opentype-interaction.scala

@@ -11,20 +11,40 @@ object Obj extends T
 
 trait OpenTrait
 class OpenClass
+class OpenClassSubclass extends OpenClass
 abstract class OpenAbstractClass
 
 trait Unrelated
 
+trait OpenTrait2
+class OpenClass2
+
 object Test {
-  def m1(s: T & OpenTrait) = s match {
+  def m1a(s: T & OpenTrait) = s match {
+    case _: Unrelated => ;
+  }
+
+  def m1b(s: T & OpenTrait & OpenTrait2) = s match {
     case _: Unrelated => ;
   }
 
   def m2(s: T & OpenClass) = s match {
     case _: Unrelated => ;
   }
 
+  def m2b(s: T & OpenTrait & OpenClass) = s match {
+    case _: Unrelated => ;
+  }
+
+  def m2c(s: (T & OpenClass) & (OpenTrait & OpenClass2)) = s match {
+    case _: Unrelated => ;
+  }
+
   def m3(s: T & OpenAbstractClass) = s match {
     case _: Unrelated => ;
   }
+
+  def m4(s: (T & OpenClass) & (OpenTrait & OpenClassSubclass)) = s match {
+    case _: Unrelated => ;
+  }
 }

tests/patmat/andtype-refinedtype-interaction.check

@@ -0,0 +1,10 @@
+32: Pattern Match Exhaustivity: _: Trait & C1{x: Int}
+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}
+65: Pattern Match Exhaustivity: _: Trait & (C1 | C2){x: Int} & (C3 | SubC1){x: Int}
+72: Pattern Match Exhaustivity: _: Trait & (T1 & C1 | T1 & SubC2){x: Int} &
+  (T2 & C2 | T2 & C3 | T2 & SubC1){x: Int}
+ & SubSubC1{x: Int}
+79: Pattern Match Exhaustivity: _: Trait & (T1 & C1 | T1 & SubC2){x: Int} &
+  (T2 & C2 | T2 & C3 | T2 & SubC1){x: Int}
+ & SubSubC2{x: Int}

tests/patmat/andtype-refinedtype-interaction.scala

@@ -0,0 +1,82 @@
+sealed trait S
+trait Trait extends S
+class Clazz extends S
+object Obj extends S
+
+trait T1
+trait T2
+
+class C1
+class C2
+class C3
+class C4
+
+class SubC1 extends C1
+class SubSubC1 extends SubC1
+class SubC2 extends C2
+class SubSubC2 extends SubC2
+
+trait Unrelated
+
+object Test {
+  /*
+  Note: error message on this suggests Obj to be unmatched as well.
+  This isn't a bug in atomic type intersection, but a consequence
+  of approximating all types to be a subtype of a structural type.
+
+  def basic1(s: S & { val x: Int }) = s match {
+    case _: Unrelated => ;
+  }
+  */
+
+  def basic2(s: S & C1 { val x: Int }) = s match {
+    case _: Unrelated => ;
+  }
+
+  def doubleInheritance1(s: S & C1 { val x: Int } & C2) = s match {
+    case _: Unrelated => ;
+  }
+
+  def doubleInheritance2(s: S & C1 { val x: Int }
+                              & C2 { val x: Int }) =
+    s match {
+      case _: Unrelated => ;
+    }
+
+  def classOrTrait(s: S & (C1 | (C2 | T1)) { val x: Int }
+                        & (C3 | (C4 | T2)) { val x: Int }) =
+    s match {
+      case _: Unrelated => ;
+    }
+
+  def traitOnly(s: S & (C1 | (C2 | T1)) { val x: Int }
+                     & C3 { val x: Int }) =
+    s match {
+      case _: Unrelated => ;
+    }
+
+  def nestedDoubleInheritance(s: S & (C1 & C2) { val x: Int }) =
+    s match {
+      case _: Unrelated => ;
+    }
+
+  def subclassingA(s: S & (C1 | C2) { val x: Int }
+                        & (C3 | SubC1) { val x: Int }) =
+    s match {
+      case _: Unrelated => ;
+    }
+
+  def subclassingB(s: S & (T1 & (C1 | SubC2)) { val x: Int }
+                        & (T2 & (C2 | C3 | SubC1)) { val x: Int }
+                        & SubSubC1 { val x: Int }) =
+    s match {
+      case _: Unrelated => ;
+    }
+
+  def subclassingC(s: S & (T1 & (C1 | SubC2)) { val x: Int }
+                        & (T2 & (C2 | C3 | SubC1)) { val x: Int }
+                        & SubSubC2 { val x: Int }) =
+    s match {
+      case _: Unrelated => ;
+    }
+}