SI-7897, SI-6675 improves name-based patmat

This emerges from a recent attempt to eliminate pattern matcher
related duplication and to bake the scalac-independent logic
out of it. I had in mind something a lot cleaner, but it was
a whole lot of work to get it here and I can take it no further.

Key file to admire is PatternExpander.scala, which should
provide a basis for some separation of concerns.

The bugs addressed are a CCE involving Tuple1 and an imprecise
warning regarding multiple pattern crushing.

Editorial: auto-tupling unapply results was a terrible idea which
should never have escaped from the crib. It is tantamount to
purposely throwing type safety down the toilet in the very place
where people need type safety the most. See SI-6111 and SI-6675 for
some other comments.

1 files changed, 36 insertions, 6 deletions

diff --git a/test/files/run/name-based-patmat.scala b/test/files/run/name-based-patmat.scala
index 2c429c141f..8e20940100 100644
--- a/test/files/run/name-based-patmat.scala
+++ b/test/files/run/name-based-patmat.scala
@@ -1,5 +1,33 @@
 final class MiniSome[T](val get: T) extends AnyVal { def isEmpty = false }
 
+package p0 {
+  class Single(val x: Any) extends AnyRef with Product1[String] {
+    private def s = "" + x
+    override def canEqual(x: Any) = this eq x.asInstanceOf[AnyRef]
+    def isEmpty = false
+    def get = this
+    def _1 = s + " only"
+
+    override def toString = s"Single(${_1})"
+  }
+
+  object Single {
+    def unapply(x: Any): Single = new Single(x)
+  }
+
+  class SingleNoProduct(val x: Any) extends AnyRef {
+    private def s = "" + x
+    def isEmpty = false
+    def get = s + " only, no product"
+
+    override def toString = s"SingleNoProduct($get)"
+  }
+
+  object SingleNoProduct {
+    def unapply(x: Any): SingleNoProduct = new SingleNoProduct(x)
+  }
+}
+
 package p1 {
   class Triple(val x: Any) extends AnyRef with Product3[String, String, String] {
     private def s = "" + x
@@ -49,14 +77,16 @@ package p3 {
 }
 
 object Test {
-
-  // def f(x: Any) = x match {
-  //   case p1.Foo(x, y, z) => println((x, y, z))
-  //   case x               => println(x)
-  // }
-
   def main(args: Array[String]): Unit = {
     "catdog" match {
+      case p0.Single(x) => println(s"`${x._1}` has ${x._1.length} chars")
+      case x            => println("fail: " + x)
+    }
+    "catdog" match {
+      case p0.SingleNoProduct(x) => println(s"`$x` has ${x.length} chars")
+      case x                     => println("fail: " + x)
+    }
+    "catdog" match {
       case p1.Triple(x, y, z) => List(x, y, z) foreach println
       case x                  => println("fail: " + x)
     }