Add exhaustivity check tests

Author: liufengyun

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -1020,6 +1020,12 @@ object Types {
       case _ => this
     }
 
+    /** Widen singleton type modulo constant types */
+    final def widenNonConstant(implicit ctx: Context): Type = this match {
+      case _: ConstantType => this
+      case _ => widen
+    }
+
     /** Widen type if it is unstable (i.e. an ExprType, or TermRef to unstable symbol */
     final def widenIfUnstable(implicit ctx: Context): Type = stripTypeVar match {
       case tp: ExprType => tp.resultType.widenIfUnstable

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

@@ -725,7 +725,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
 
   def checkExhaustivity(_match: Match): Unit = {
     val Match(sel, cases) = _match
-    val selTyp = sel.tpe.widen.dealias
+    val selTyp = sel.tpe.widenNonConstant.dealias
 
     if (!exhaustivityCheckable(sel)) return
 
@@ -756,7 +756,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
 
   def checkRedundancy(_match: Match): Unit = {
     val Match(sel, cases) = _match
-    val selTyp = sel.tpe.widen.dealias
+    val selTyp = sel.tpe.widenNonConstant.dealias
 
     if (!redundancyCheckable(sel)) return
 

tests/patmat/t11283.scala

@@ -0,0 +1,17 @@
+sealed trait Color
+case object Red extends Color
+case object Blue extends Color
+case object Green extends Color
+
+class Test {
+
+  val R: Red.type = Red
+  val B: Blue.type = Blue
+  val G: Green.type = Green
+
+  def go(c: Color): Int = c match {
+    case R => 0
+    case G => 1
+    case B => 2
+  }
+}

tests/patmat/t11457.scala

@@ -0,0 +1,13 @@
+sealed abstract class Foo(val a: String)
+
+object Foo {
+  def unapply(foo: Foo): Some[String] =
+    Some(foo.a)
+}
+
+class Issue11457 {
+  val root: PartialFunction[Foo, Boolean] = {
+    case Foo("a") => true
+    case Foo("b") => false
+  }
+}

tests/patmat/t11603.scala

@@ -0,0 +1,5 @@
+class C {
+  def m(x: true) = x match {
+    case true => println("the one true path")
+  }
+}

tests/patmat/t11620.check

@@ -0,0 +1 @@
+36: Pattern Match Exhaustivity: B(A2(_, _))

tests/patmat/t11620.scala

@@ -0,0 +1,38 @@
+sealed trait A[+T]
+ case class A1[+T](t : T       ) extends A[T]
+ case class A2[+T](t1: T, t2: T) extends A[T]
+
+sealed trait B[+T] {
+  type AA[+U] <: A[U]
+  def a: AA[T]
+}
+object B {
+  type Aux[+_A[+_], +T] = B[T] { type AA[+U] <: _A[U] }
+  object Aux {
+    def unapply[_A[+U] <: A[U], T](b: Aux[_A, T]): Some[_A[T]] = Some(b.a)
+  }
+
+  def apply[_A[+U] <: A[U], T](_a: _A[T]): Aux[_A, T] =
+    new B[T] { type AA[+U] = _A[U] ; val a: _A[T] = _a }
+
+  def unapply[T](b: B[T]): Some[b.AA[T]] = Some(b.a)
+}
+
+def foo[T](b: B[T]) = b match {
+  case B(A1(t)) ⇒ t
+  case B(A2(t, _)) ⇒ t
+}
+
+def foo2[_A[+U] <: A[U], T](b: B.Aux[_A, T]) = b match {
+  case B.Aux(a @ A1(_   )) ⇒ a.t
+  case B.Aux(a @ A2(_, _)) ⇒ a.t1  // 👎 (false-positive): unreachable code
+}
+
+def foo3[_A[+U] <: A[U], T](b: B.Aux[_A, T]) = b match {
+  case B.Aux(a: A1[T]) ⇒ a.t
+  case B.Aux(a: A2[T]) ⇒ a.t1  // 👎 (false-positive): unreachable code
+}
+
+def foo4[T](b: B[T]) = b match {
+  case B(A1(t)) ⇒ t  // 👎 (false-negative): incomplete match
+}

tests/patmat/t9809.check

@@ -0,0 +1,2 @@
+3: Pattern Match Exhaustivity: (_, _)
+7: Pattern Match Exhaustivity: (_, _)

tests/patmat/t9809.scala

@@ -0,0 +1,9 @@
+object Example {
+  val op1: (Any, Any) => Unit = {
+    case (_, b: Int) =>
+  }
+
+  val op2: (Unit, Any) => Unit = {
+    case (_, b: Int) =>
+  }
+}