Handle exhaustivity and reachability checking of matches with sub cases

Author: EugeneFlesselle

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -625,6 +625,8 @@ object Trees {
   case class CaseDef[+T <: Untyped] private[ast] (pat: Tree[T], guard: Tree[T], body: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends Tree[T] {
     type ThisTree[+T <: Untyped] = CaseDef[T]
+    /** Should this case be considered partial for exhaustivity and unreachability checking */
+    def maybePartial(using Context): Boolean = !guard.isEmpty || body.isInstanceOf[SubMatch[T]]
   }
 
   /** label[tpt]: { expr } */

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

@@ -883,7 +883,7 @@ object SpaceEngine {
     val targetSpace = trace(i"targetSpace($selTyp)")(project(selTyp))
 
     val patternSpace = Or(m.cases.foldLeft(List.empty[Space]) { (acc, x) =>
-      val space = if x.guard.isEmpty then trace(i"project(${x.pat})")(project(x.pat)) else Empty
+      val space = if x.maybePartial then Empty else trace(i"project(${x.pat})")(project(x.pat))
       space :: acc
     })
 
@@ -925,7 +925,7 @@ object SpaceEngine {
     @tailrec def recur(cases: List[CaseDef], prevs: List[Space], deferred: List[Tree]): Unit =
       cases match
         case Nil =>
-        case CaseDef(pat, guard, _) :: rest =>
+        case (c @ CaseDef(pat, _, _)) :: rest =>
           val curr = trace(i"project($pat)")(projectPat(pat))
           val covered = trace("covered")(simplify(intersect(curr, targetSpace)))
           val prev = trace("prev")(simplify(Or(prevs)))
@@ -951,8 +951,8 @@ object SpaceEngine {
                 hadNullOnly = true
                 report.warning(MatchCaseOnlyNullWarning(), pat.srcPos)
 
-            // in redundancy check, take guard as false in order to soundly approximate
-            val newPrev = if guard.isEmpty then covered :: prevs else prevs
+            // in redundancy check, take guard as false (or potential sub cases as partial) for a sound approximation
+            val newPrev = if c.maybePartial then prevs else covered :: prevs
             recur(rest, newPrev, Nil)
 
     recur(m.cases, Nil, Nil)

tests/warn/sub-cases-exhaustivity.check

@@ -0,0 +1,20 @@
+-- [E029] Pattern Match Exhaustivity Warning: tests/warn/sub-cases-exhaustivity.scala:15:2 -----------------------------
+15 |  e match // warn: match may not be exhaustive: It would fail on pattern case: E.A(_) | E.B(_)
+   |  ^
+   |  match may not be exhaustive.
+   |
+   |  It would fail on pattern case: E.A(_), E.B(_)
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E029] Pattern Match Exhaustivity Warning: tests/warn/sub-cases-exhaustivity.scala:24:2 -----------------------------
+24 |  e match // warn: match may not be exhaustive: It would fail on pattern case: E.B(_)
+   |  ^
+   |  match may not be exhaustive.
+   |
+   |  It would fail on pattern case: E.B(_)
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E030] Match case Unreachable Warning: tests/warn/sub-cases-exhaustivity.scala:32:9 ---------------------------------
+32 |    case A(_) => 3 // warn: unreacheable
+   |         ^^^^
+   |         Unreachable case

tests/warn/sub-cases-exhaustivity.scala

@@ -0,0 +1,33 @@
+import scala.language.experimental.matchWithSubCases
+
+enum E:
+  case A(e: E)
+  case B(e: E)
+  case C
+
+  def f: E = ???
+end E
+import E.*
+
+object Test:
+  val e: E = ???
+
+  e match // warn: match may not be exhaustive: It would fail on pattern case: E.A(_) | E.B(_)
+    case A(e1) with e1.f match
+      case B(_) => 11
+      case C => 12
+    case B(e1) with e1.f match
+      case C => 21
+      case A(_) => 22
+    case C => 3
+
+  e match // warn: match may not be exhaustive: It would fail on pattern case: E.B(_)
+    case A(e1) with e1.f match
+      case B(_) => 11
+      case C => 12
+    case B(e1) with e1.f match
+      case C => 21
+      case A(_) => 22
+    case A(_) => 3 // nowarn: should not be reported as unreachable
+    case A(_) => 3 // warn: unreacheable
+    case C => 4