Massively simplified the exhaustiveness checker...

Massively simplified the exhaustiveness checker with no measurable loss
of fidelity. I might be the only one who can be unsurprised by such a
bloody diff: anyone else would rightly say "how on earth..." No review.

3 files changed, 65 insertions, 0 deletions

diff --git a/test/files/neg/exhausting.check b/test/files/neg/exhausting.check
new file mode 100644
index 0000000000..6383a6eaca
--- /dev/null
+++ b/test/files/neg/exhausting.check
@@ -0,0 +1,24 @@
+exhausting.scala:20: error: match is not exhaustive!
+missing combination              *           Nil
+
+  def fail1[T](xs: List[T]) = xs match {
+      ^
+exhausting.scala:24: error: match is not exhaustive!
+missing combination            Nil
+
+  def fail2[T](xs: List[T]) = xs match {
+                              ^
+exhausting.scala:27: error: match is not exhaustive!
+missing combination           Bar3
+
+  def fail3[T](x: Foo[T]) = x match {
+                            ^
+exhausting.scala:31: error: match is not exhaustive!
+missing combination           Bar1          Bar2
+missing combination           Bar1          Bar3
+missing combination           Bar2          Bar1
+missing combination           Bar2          Bar2
+
+  def fail4[T](xx: (Foo[T], Foo[T])) = xx match {
+      ^
+four errors found
diff --git a/test/files/neg/exhausting.flags b/test/files/neg/exhausting.flags
new file mode 100644
index 0000000000..e8fb65d50c
--- /dev/null
+++ b/test/files/neg/exhausting.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
\ No newline at end of file
diff --git a/test/files/neg/exhausting.scala b/test/files/neg/exhausting.scala
new file mode 100644
index 0000000000..8b1ea817e4
--- /dev/null
+++ b/test/files/neg/exhausting.scala
@@ -0,0 +1,40 @@
+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[_]) => ()
+  }
+
+  def fail1[T](xs: List[T]) = xs match {
+    case Nil            => "ok"
+    case x :: y :: Nil  => "ok"
+  }
+  def fail2[T](xs: List[T]) = xs match {
+    case _ :: _ => "ok"
+  }
+  def fail3[T](x: Foo[T]) = x match {
+    case Bar1   => "ok"
+    case Bar2   => "ok"
+  }
+  def fail4[T](xx: (Foo[T], Foo[T])) = xx match {
+    case (Bar1, Bar1) => ()
+    case (Bar2, Bar3) => ()
+    case (Bar3, _) => ()
+  }
+
+  def main(args: Array[String]): Unit = {
+
+  }
+}