Better support type-heavy pattern matches

Author: liufengyun

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

@@ -345,9 +345,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
       val res = TypeComparer.provablyDisjoint(tp1, tp2)
 
       if (res) Empty
-      else if (tp1.isSingleton) Typ(tp1, true)
-      else if (tp2.isSingleton) Typ(tp2, true)
-      else Typ(AndType(tp1, tp2), true)
+      else Typ(AndType(tp1, tp2), decomposed = true)
     }
   }
 
@@ -594,11 +592,24 @@ class SpaceEngine(using Context) extends SpaceLogic {
   def decompose(tp: Type): List[Space] =
     tp.dealias match {
       case AndType(tp1, tp2) =>
-        intersect(Typ(tp1, false), Typ(tp2, false)) match {
-          case Or(spaces) => spaces.toList
-          case Empty => Nil
-          case space => List(space)
-        }
+        def decomposeComponent(tpA: Type, tpB: Type) =
+          decompose(tpA).asInstanceOf[List[Typ]].flatMap {
+            case Typ(tp, _) =>
+              if tp <:< tpB then
+                Typ(tp, decomposed = true) :: Nil
+              else if tpB <:< tp then
+                Typ(tpB, decomposed = true) :: Nil
+              else
+                intersectUnrelatedAtomicTypes(tp, tpB) match
+                case Empty => Nil
+                case space => List(space)
+          }
+
+        if canDecompose(tp1) then
+          decomposeComponent(tp1, tp2)
+        else
+          decomposeComponent(tp2, tp1)
+
       case OrType(tp1, tp2) => List(Typ(tp1, true), Typ(tp2, true))
       case tp if tp.isRef(defn.BooleanClass) =>
         List(

tests/patmat/i12475.scala

@@ -0,0 +1,20 @@
+sealed trait Ty {
+  type T
+}
+
+class TUnit() extends Ty {
+  type T = Unit
+}
+
+case object TUnit extends TUnit()
+
+final case class TFun(dom: Ty, cod: Ty) extends Ty {
+  type T = dom.T => cod.T
+}
+
+def default(ty: Ty): ty.T = (ty: ty.type & Ty) match {
+  case a: (ty.type & TUnit) => (): a.T
+  case a: (ty.type & TFun) =>
+    val f = { (x: a.dom.T) => default(a.cod) }
+    f: a.T
+}