add test set for exhaustivity and redundancy check

Author: liufengyun

tests/patmat/NonAbstractSealed.check

@@ -0,0 +1,5 @@
+./tests/patmat/NonAbstractSealed.scala:6: warning: match may not be exhaustive.
+It would fail on the following input: _: A
+  (null: A) match {
+            ^
+one warning found

tests/patmat/NonAbstractSealed.scala

@@ -0,0 +1,10 @@
+sealed class A
+class B extends A
+class C extends A
+
+object Test {
+  (null: A) match {
+    case t: B =>
+    case t: C =>
+  }
+}

tests/patmat/TwoTrait.scala

@@ -0,0 +1,12 @@
+object Test {
+  sealed trait A
+  sealed trait B
+
+  abstract sealed class Parent
+  class Foo extends Parent with A with B
+  class Bar extends Parent with B with A
+
+  (null: A) match {
+    case _: B =>
+  }
+}

tests/patmat/aladdin1055/A.scala

@@ -0,0 +1,6 @@
+object A {
+  sealed trait T { def f: Int }
+  class TT extends T { def f = 0 }
+
+  def foo = new T { def f = 1 } // local subclass of sealed trait T
+}

tests/patmat/aladdin1055/Test_1.scala.ignore

@@ -0,0 +1,5 @@
+object Test {
+  def foo(t: A.T) = t match {
+    case a: A.TT => 0
+  }
+}

tests/patmat/aladdin1055/expected.check.ignore

@@ -0,0 +1,5 @@
+./tests/patmat/aladdin1055/Test_1.scala:2: warning: match may not be exhaustive.
+It would fail on the following input: (_ : this.<local child>)
+  def foo(t: A.T) = t match {
+                    ^
+one warning found

tests/patmat/enum/Day.java

@@ -0,0 +1,4 @@
+public enum Day {
+  SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
+  THURSDAY, FRIDAY, SATURDAY
+}

tests/patmat/enum/expected.check

@@ -0,0 +1,9 @@
+./tests/patmat/enum/patmat-enum.scala:4: warning: match may not be exhaustive.
+It would fail on the following input: SATURDAY, FRIDAY, THURSDAY, SUNDAY
+  day match {
+      ^
+./tests/patmat/enum/patmat-enum.scala:15: warning: match may not be exhaustive.
+It would fail on the following input: SATURDAY, FRIDAY, THURSDAY
+  day match {
+      ^
+two warnings found

tests/patmat/enum/patmat-enum.scala

@@ -0,0 +1,21 @@
+object Test1 {
+  val day: Day = ???
+
+  day match {
+    case Day.MONDAY => true
+    case Day.TUESDAY => true
+    case Day.WEDNESDAY => true
+  }
+}
+
+object Test2 {
+  import Day._
+  val day: Day = ???
+
+  day match {
+    case MONDAY => true
+    case TUESDAY => true
+    case WEDNESDAY => true
+    case SUNDAY => true
+  }
+}

tests/patmat/exhausting.check

@@ -0,0 +1,25 @@
+./tests/patmat/exhausting.scala:21: warning: match may not be exhaustive.
+It would fail on the following input: List(_), List(_, _, _)
+  def fail1[T](xs: List[T]) = xs match {
+                                 ^
+./tests/patmat/exhausting.scala:27: warning: match may not be exhaustive.
+It would fail on the following input: Nil
+  def fail2[T](xs: List[T]) = xs match {
+                                 ^
+./tests/patmat/exhausting.scala:32: warning: match may not be exhaustive.
+It would fail on the following input: List(_, _)
+  def fail3a(xs: List[Int]) = xs match {
+                                 ^
+./tests/patmat/exhausting.scala:39: warning: match may not be exhaustive.
+It would fail on the following input: Bar3
+  def fail3[T](x: Foo[T]) = x match {
+                              ^
+./tests/patmat/exhausting.scala:44: warning: match may not be exhaustive.
+It would fail on the following input: (Bar2, Bar2)
+  def fail4[T <: AnyRef](xx: (Foo[T], Foo[T])) = xx match {
+                                                    ^
+./tests/patmat/exhausting.scala:53: warning: match may not be exhaustive.
+It would fail on the following input: (Bar2, Bar2), (Bar2, Bar1), (Bar1, Bar3), (Bar1, Bar2)
+  def fail5[T](xx: (Foo[T], Foo[T])) = xx match {
+                                          ^
+6 warnings found

tests/patmat/exhausting.scala

@@ -0,0 +1,58 @@
+object Test {
+  sealed abstract class Foo[T]
+  case object Bar1 extends Foo[Int]
+  case object Bar2 extends Foo[String]
+  case object Bar3 extends Foo[Any]
+
+  def ex1[T](xs: List[T]) = xs match {
+    case ys: List[_]  => "ok"
+  }
+  def ex2[T](xx: (Foo[T], Foo[T])) = xx match {
+    case (Bar1, Bar1) => ()
+    case (_, Bar1) => ()
+    case (_, Bar3) => ()
+    case (_, Bar2) => ()
+  }
+  def ex3[T](xx: (Foo[T], Foo[T])) = xx match {
+    case (_: Foo[_], _: Foo[_]) => ()
+  }
+
+  // fails for: ::(_, Nil), ::(_, ::(_, ::(_, _))), ...
+  def fail1[T](xs: List[T]) = xs match {
+    case Nil            => "ok"
+    case x :: y :: Nil  => "ok"
+  }
+
+  // fails for: Nil
+  def fail2[T](xs: List[T]) = xs match {
+    case _ :: _ => "ok"
+  }
+
+  // fails for: ::(<not in (2, 1)>, _)
+  def fail3a(xs: List[Int]) = xs match {
+    case 1 :: _ =>
+    case 2 :: _ =>
+    case Nil =>
+  }
+
+  // fails for: Bar3
+  def fail3[T](x: Foo[T]) = x match {
+    case Bar1   => "ok"
+    case Bar2   => "ok"
+  }
+  // fails for: (Bar2, Bar2)
+  def fail4[T <: AnyRef](xx: (Foo[T], Foo[T])) = xx match {
+    case (Bar1, Bar1) => ()
+    case (Bar2, Bar3) => ()
+    case (Bar3, _) => ()
+  }
+  // fails for: (Bar1, Bar2)
+  // fails for: (Bar1, Bar3)
+  // fails for: (Bar2, Bar1)
+  // fails for: (Bar2, Bar2)
+  def fail5[T](xx: (Foo[T], Foo[T])) = xx match {
+    case (Bar1, Bar1) => ()
+    case (Bar2, Bar3) => ()
+    case (Bar3, _) => ()
+  }
+}

tests/patmat/exhaustive_heuristics.scala

@@ -0,0 +1,26 @@
+// tests exhaustivity doesn't give warnings (due to its heuristic rewrites kicking in or it backing off)
+object Test {
+  // List() => Nil
+  List(1) match {
+    case List() =>
+    case x :: xs =>
+  }
+
+  // we don't look into guards
+  val turnOffChecks = true
+  List(1) match {
+    case _ if turnOffChecks =>
+  }
+
+  // we back off when there are any user-defined extractors
+  // in fact this is exhaustive, but we pretend we don't know since List's unapplySeq is not special to the compiler
+  // to compensate our ignorance, we back off
+  // well, in truth, we do rewrite List() to Nil, but otherwise we do nothing
+  // the full rewrite List(a, b) to a :: b :: Nil, for example is planned (but not sure it's a good idea)
+  List(true, false) match {
+    case List(_, _, _:_*) =>
+    case List(node, _:_*)  =>
+    case Nil =>
+  }
+
+}

tests/patmat/for.scala

@@ -0,0 +1,5 @@
+object Test {
+  def foo[A, B](l: List[(A, B)]): List[A] = {
+    for ((a, b) <- l) yield a
+  }
+}

tests/patmat/gadt.check

@@ -0,0 +1,17 @@
+./tests/patmat/gadt.scala:13: warning: match may not be exhaustive.
+It would fail on the following input: IntLit(_)
+  def foo1b(x: Expr[Int]) = x match {
+                              ^
+./tests/patmat/gadt.scala:22: warning: match may not be exhaustive.
+It would fail on the following input: Or(_, _)
+  def foo2b(x: Expr[Boolean]) = x match {
+                                  ^
+./tests/patmat/gadt.scala:45: warning: match may not be exhaustive.
+It would fail on the following input: BooleanLit(_), IntLit(_)
+  def foo4b(x: Expr[_]) = x match {
+                            ^
+./tests/patmat/gadt.scala:55: warning: match may not be exhaustive.
+It would fail on the following input: Sum(_, _)
+  def foo5b[T <: Int](x: Expr[T]) = x match {
+                                      ^
+four warnings found

tests/patmat/gadt.scala

@@ -0,0 +1,58 @@
+object Test {
+  sealed trait Expr[T]
+  case class IntLit(i: Int) extends Expr[Int]
+  case class BooleanLit(b: Boolean) extends Expr[Boolean]
+  case class Sum(l: Expr[Int], r: Expr[Int]) extends Expr[Int]
+  case class Or(l: Expr[Boolean], r: Expr[Boolean]) extends Expr[Boolean]
+
+  def foo1a(x: Expr[Int]) = x match {
+    case _: IntLit => true
+    case _: Sum => true
+  }
+
+  def foo1b(x: Expr[Int]) = x match {
+    case _: Sum => true
+  }
+
+  def foo2a(x: Expr[Boolean]) = x match {
+    case _: BooleanLit => true
+    case _: Or => true
+  }
+
+  def foo2b(x: Expr[Boolean]) = x match {
+    case _: BooleanLit => true
+  }
+
+  def foo3a(x: Expr[Boolean]) = x match {
+    case _: BooleanLit => true
+    case _: Or => true
+    // case _: Sum => true
+  }
+
+  def foo3b(x: Expr[Int]) = x match {
+    case _: IntLit => true
+    case _: Sum => true
+    // case _: Or => true
+  }
+
+  def foo4a(x: Expr[_]) = x match {
+    case _: IntLit => true
+    case _: Sum => true
+    case _: BooleanLit => true
+    case _: Or => true
+  }
+
+  def foo4b(x: Expr[_]) = x match {
+    case _: Sum => true
+    case _: Or => true
+  }
+
+  def foo5a[T <: Int](x: Expr[T]) = x match {
+    case _: IntLit => true
+    case _: Sum => true
+  }
+
+  def foo5b[T <: Int](x: Expr[T]) = x match {
+    case _: IntLit => true
+  }
+}

tests/patmat/gadt2.scala.ignore

@@ -0,0 +1,14 @@
+sealed trait Nat[+T]
+case class Zero() extends Nat[Nothing]
+case class Succ[T]() extends Nat[T]
+
+sealed trait Vect[+N <: Nat[_], +T]
+case class VN[T]() extends Vect[Zero, T]
+case class VC[T, N <: Nat[_]](x: T, xs: Vect[N, T]) extends Vect[Succ[N], T]
+
+object Test {
+  def foo[N <: Nat[_], A, B](v1: Vect[N, A], v2: Vect[N, B]) = (v1, v2) match {
+    case (VN(), VN()) => 1
+    case (VC(x, xs), VC(y, ys)) => 2
+  }
+}

tests/patmat/gadt3.scala.ignore

@@ -0,0 +1,10 @@
+sealed trait Expr[T]
+case class IntExpr(x: Int) extends Expr[Int]
+case class BooleanExpr(b: Boolean) extends Expr[Boolean]
+
+object Test {
+  def foo[T](x: Expr[T], y: Expr[T]) = (x, y) match {
+    case (IntExpr(_), IntExpr(_)) =>
+    case (BooleanExpr(_), BooleanExpr(_)) =>
+  }
+}

tests/patmat/i947.check

@@ -0,0 +1,4 @@
+./tests/patmat/i947.scala:10: warning: unreachable code
+      case ys: List[d18383] => false
+                           ^
+one warning found

tests/patmat/i947.scala

@@ -0,0 +1,16 @@
+object Test {
+
+  class c {
+
+    private var x: Int = 0
+
+    override def equals(other: Any) = other match {
+      case o: c => x == o.x
+      case xs: List[c] => false
+      case ys: List[d18383] => false
+      case _ => false
+    }
+
+
+  }
+}