SI-9029 Fix regression in extractor patterns

The unified treatment of classical and named-based pattern matching
does not correctly handle the generalization of "tuple capture".

By "tuple capture", I mean:

```
scala> object Extractor { def unapply(a: Any): Option[(Int, String)] = Some((1, "2")) }
defined object Extractor

scala> "" match { case Extractor(x: Int, y: String) => }

scala> "" match { case Extractor(xy : (Int, String)) => }
warning: there was one deprecation warning; re-run with -deprecation for details

scala> :warnings
<console>:9: warning: object Extractor expects 2 patterns to hold (Int, String) but crushing into 2-tuple to fit single pattern (SI-6675)
              "" match { case Extractor(xy : (Int, String)) => }
                              ^
```

Name based pattern matching, new in Scala 2.11, allows one to
deconstruct the elements that structurally resembles `ProductN`:

```
scala> class P2(val _1: Int, val _2: String)
defined class P2

scala> object Extractor { def unapply(a: Any): Option[P2] = Some(new P2(1, "2")) }
defined object Extractor

scala> "" match { case Extractor(x: Int, y: String) => }
```

However, attempting to extract the `P2` in its entirety leads to
an internal error:

```
scala> "" match { case Extractor(p2: P2) => }
<console>:10: warning: fruitless type test: a value of type (Int, String) cannot also be a P2
              "" match { case Extractor(p2: P2) => }
                                            ^
<console>:10: error: error during expansion of this match (this is a scalac bug).
The underlying error was: type mismatch;
 found   : P2
 required: (Int, String)
              "" match { case Extractor(p2: P2) => }
                 ^
```

Note that this match was legal and warning free in 2.10.

This commit avoids the hard-coded assumption that the "tuple capture"
results in a `TupleN`, and instead keeps track of the product-ish
type from which we extracted the element types. I have also opted not
to limit the deprecation warning to `TupleN` extractors.

2 files changed, 36 insertions, 16 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/patmat/PatternExpander.scala b/src/compiler/scala/tools/nsc/transform/patmat/PatternExpander.scala
index e84ccbf754..1916050dd8 100644
--- a/src/compiler/scala/tools/nsc/transform/patmat/PatternExpander.scala
+++ b/src/compiler/scala/tools/nsc/transform/patmat/PatternExpander.scala
@@ -86,9 +86,25 @@ trait PatternExpander[Pattern, Type] {
    *  @param  fixed     The non-sequence types which are extracted
    *  @param  repeated  The sequence type which is extracted
    */
-  final case class Extractor(whole: Type, fixed: List[Type], repeated: Repeated) {
+  final case class Extractor(whole: Type, fixed: List[Type], repeated: Repeated, typeOfSinglePattern: Type) {
     require(whole != NoType, s"expandTypes($whole, $fixed, $repeated)")
 
+    /** A pattern with arity-1 that doesn't match the arity of the Product-like result of the `get` method,
+      * will match that result in its entirety. Example:
+      *
+      * {{{
+      * warning: there was one deprecation warning; re-run with -deprecation for details
+      * scala> object Extractor { def unapply(a: Any): Option[(Int, String)] = Some((1, "2")) }
+      * defined object Extractor
+      *
+      * scala> "" match { case Extractor(x: Int, y: String) => }
+      *
+      * scala> "" match { case Extractor(xy : (Int, String)) => }
+      * warning: there was one deprecation warning; re-run with -deprecation for details
+      * }}}
+      * */
+    def asSinglePattern: Extractor = copy(fixed = List(typeOfSinglePattern))
+
     def productArity = fixed.length
     def hasSeq       = repeated.exists
     def elementType  = repeated.elementType
diff --git a/src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala b/src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala
index b1783dc81f..55d4366a46 100644
--- a/src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala
+++ b/src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala
@@ -43,8 +43,9 @@ trait ScalacPatternExpanders {
           orElse definitions.elementType(ArrayClass, seq)
       )
     }
-    def newExtractor(whole: Type, fixed: List[Type], repeated: Repeated): Extractor =
-      logResult(s"newExtractor($whole, $fixed, $repeated")(Extractor(whole, fixed, repeated))
+    def newExtractor(whole: Type, fixed: List[Type], repeated: Repeated, typeOfSinglePattern: Type): Extractor =
+      logResult(s"newExtractor($whole, $fixed, $repeated, $typeOfSinglePattern")(Extractor(whole, fixed, repeated, typeOfSinglePattern))
+    def newExtractor(whole: Type, fixed: List[Type], repeated: Repeated): Extractor = newExtractor(whole, fixed, repeated, tupleType(fixed))
 
     // Turn Seq[A] into Repeated(Seq[A], A, A*)
     def repeatedFromSeq(seqType: Type): Repeated = {
@@ -74,16 +75,17 @@ trait ScalacPatternExpanders {
      *  it was unapplySeq, so we have to funnel that information in separately.
      */
     def unapplyMethodTypes(whole: Type, result: Type, isSeq: Boolean): Extractor = {
-      val expanded = (
-        if (result =:= BooleanTpe) Nil
-        else typeOfMemberNamedGet(result) match {
+      if (result =:= BooleanTpe) newExtractor(whole, Nil, NoRepeated)
+      else {
+        val getResult = typeOfMemberNamedGet(result)
+        val expanded = getResult match {
           case rawGet if !hasSelectors(rawGet) => rawGet :: Nil
           case rawGet                          => typesOfSelectors(rawGet)
         }
-      )
-      expanded match {
-        case init :+ last if isSeq => newExtractor(whole, init, repeatedFromSeq(last))
-        case tps                   => newExtractor(whole, tps, NoRepeated)
+        expanded match {
+          case init :+ last if isSeq => newExtractor(whole, init, repeatedFromSeq(last), getResult)
+          case tps                   => newExtractor(whole, tps, NoRepeated, getResult)
+        }
       }
     }
   }
@@ -142,12 +144,14 @@ trait ScalacPatternExpanders {
       def acceptMessage   = if (extractor.isErroneous) "" else s" to hold ${extractor.offeringString}"
       val requiresTupling = isUnapply && patterns.totalArity == 1 && productArity > 1
 
-      if (requiresTupling && effectivePatternArity(args) == 1) {
-        val sym = sel.symbol.owner
-        currentRun.reporting.deprecationWarning(sel.pos, sym, s"${sym} expects $productArity patterns$acceptMessage but crushing into $productArity-tuple to fit single pattern (SI-6675)")
-      }
-
-      val normalizedExtractor = if (requiresTupling) tupleExtractor(extractor) else extractor
+      val normalizedExtractor = if (requiresTupling) {
+        val tupled = extractor.asSinglePattern
+        if (effectivePatternArity(args) == 1 && isTupleType(extractor.typeOfSinglePattern)) {
+          val sym = sel.symbol.owner
+          currentRun.reporting.deprecationWarning(sel.pos, sym, s"${sym} expects $productArity patterns$acceptMessage but crushing into $productArity-tuple to fit single pattern (SI-6675)")
+        }
+        tupled
+      } else extractor
       validateAligned(context, fn, Aligned(patterns, normalizedExtractor))
     }