Refactor flatten to be lazy

- show at most 6 unmatched cases

Author: liufengyun

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -822,14 +822,16 @@ import transform.SymUtils._
            |"""
   }
 
-  class PatternMatchExhaustivity(uncoveredFn: => String)(using Context)
+  class PatternMatchExhaustivity(uncoveredFn: => String, hasMore: Boolean)(using Context)
   extends Message(PatternMatchExhaustivityID) {
     def kind = "Pattern Match Exhaustivity"
     lazy val uncovered = uncoveredFn
     def msg =
+      val addendum = if hasMore then "(More unmatched cases are elided)" else ""
       em"""|${hl("match")} may not be exhaustive.
            |
-           |It would fail on pattern case: $uncovered"""
+           |It would fail on pattern case: $uncovered
+           |$addendum"""
 
 
     def explain =

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

@@ -150,19 +150,23 @@ trait SpaceLogic {
   })
 
   /** Flatten space to get rid of `Or` for pretty print */
-  def flatten(space: Space)(using Context): List[Space] = space match {
+  def flatten(space: Space)(using Context): Seq[Space] = space match {
     case Prod(tp, fun, spaces, full) =>
-      spaces.map(flatten) match {
-        case Nil => Prod(tp, fun, Nil, full) :: Nil
-        case ss  =>
-          ss.foldLeft(List[Prod]()) { (acc, flat) =>
-            if (acc.isEmpty) flat.map(s => Prod(tp, fun, s :: Nil, full))
-            else for (Prod(tp, fun, ss, full) <- acc; s <- flat) yield Prod(tp, fun, ss :+ s, full)
-          }
+      val ss = LazyList(spaces: _*).map(flatten)
+      val template = Prod(tp, fun, Nil, full)
+      ss.foldLeft(LazyList(template)) { (acc, flat) =>
+        for
+          Prod(tp, fun, ss, full) <- acc;
+          s <- flat
+        yield
+          Prod(tp, fun, ss :+ s, full)
       }
+
     case Or(spaces) =>
-      spaces.flatMap(flatten _)
-    case _ => List(space)
+      LazyList(spaces: _*).flatMap(flatten)
+
+    case _ =>
+      List(space)
   }
 
   /** Is `a` a subspace of `b`? Equivalent to `a - b == Empty`, but faster */
@@ -838,8 +842,10 @@ class SpaceEngine(using Context) extends SpaceLogic {
         s != Empty && (!checkGADTSAT || satisfiable(s))
       }
 
-    if (uncovered.nonEmpty)
-      report.warning(PatternMatchExhaustivity(show(uncovered)), sel.srcPos)
+
+    if uncovered.nonEmpty then
+      val hasMore = uncovered.lengthCompare(6) > 0
+      report.warning(PatternMatchExhaustivity(show(uncovered.take(6)), hasMore), sel.srcPos)
   }
 
   private def redundancyCheckable(sel: Tree): Boolean =

tests/patmat/i8922c.check

@@ -1 +1 @@
-26: Pattern Match Exhaustivity: (_, _, _)
+26: Pattern Match Exhaustivity: (true, _: String, _), (true, _: Double, _), (true, true, _), (true, false, _), (true, (), _), (false, _: String, _)