Work on the pattern matcher.

patches for #3887 and #3888, but I determined that I could achieve the
same effect by deleting a bunch of code, so I did. This left only a few
lines in TransMatch, so I eliminated it, which led me to remember that
many places still reference non-existent phase transmatch, so those were
updated. Notes:

 * This swaps equality tests on stable identifier patterns.  They
 have never conformed to the spec (as noted long ago in ticket #785)
 which says "The pattern matches any value v such that r == v" whereas
 until now the test being performed was v == r.

 * An issue was introduced with specialization in that the implementation
 of "isTupleType" in Definitions relied upon sym == TupleClass(elems.length).
 This test is untrue for specialized tuples, causing mysterious behavior
 because only some tuples are specialized.  There is now "isTupleTypeOrSubtype"
 although it seems likely the former implementation is unnecessary.
 The issue is sidestepped if one uses "getProductArgs" to retrieve the element
 types because it sifts through the base types for the Product symbol.

Closes #3887 and #3888, review by dmharrah.

5 files changed, 78 insertions, 1 deletions

diff --git a/test/files/neg/patmatexhaust.check b/test/files/neg/patmatexhaust.check
index ca769300c0..83c4279b0a 100644
--- a/test/files/neg/patmatexhaust.check
+++ b/test/files/neg/patmatexhaust.check
@@ -13,7 +13,7 @@ missing combination           Kult          Kult
 missing combination           Qult          Qult
 
     def ma3(x:Mult) = (x,x) match { // not exhaustive
-                       ^
+        ^
 patmatexhaust.scala:49: warning: match is not exhaustive!
 missing combination             Gp
 missing combination             Gu
diff --git a/test/files/run/t3887.scala b/test/files/run/t3887.scala
new file mode 100644
index 0000000000..16ce983efc
--- /dev/null
+++ b/test/files/run/t3887.scala
@@ -0,0 +1,16 @@
+object Test {
+    def main(args: Array[String]) {
+        assert( matchPair(1) )
+        assert( !matchPair(2) )
+    }
+
+    def matchPair(i: Int) = {
+        (i, "abc") match {
+            case this.option1 => true
+            case _ => false
+        }
+    }
+
+    val option1: (Int, String) = (1, "abc")
+
+}
diff --git a/test/files/run/t3888.scala b/test/files/run/t3888.scala
new file mode 100644
index 0000000000..ecdf87e925
--- /dev/null
+++ b/test/files/run/t3888.scala
@@ -0,0 +1,26 @@
+object Test {
+
+  val T1 = new P
+  private[this] val T2 = T1
+
+  def m1 =
+    (1, 2) match {
+      case T1 => true
+      case _ => false
+    }
+
+  def m2 =
+    (1, 2) match {
+      case T2 => true
+      case _ => false
+    }
+
+  def main(args: Array[String]) = {
+    assert( m1 )
+    assert( m2 )
+  }
+}
+
+class P extends Pair(1, 1) {
+  override def equals(x: Any) = true
+}
\ No newline at end of file
diff --git a/test/files/run/tuple-match.check b/test/files/run/tuple-match.check
new file mode 100644
index 0000000000..0c1ea0005b
--- /dev/null
+++ b/test/files/run/tuple-match.check
@@ -0,0 +1,8 @@
+4, #3
+4, #2
+4, #4
+3, #2
+2, #2
+1, #1
+FOUR
+THREE
diff --git a/test/files/run/tuple-match.scala b/test/files/run/tuple-match.scala
new file mode 100644
index 0000000000..fcaefbff5b
--- /dev/null
+++ b/test/files/run/tuple-match.scala
@@ -0,0 +1,27 @@
+object Test {
+  val FOUR = (-1, -2, -3, "bingo donkey vegas")
+  val THREE = (-1, -2, -3)
+
+  def f(x: Any) = x match {
+    case FOUR         => "FOUR"
+    case (_, _, 3, _) => "4, #3"
+    case (_, 2, _, _) => "4, #2"
+    case (_, 2, _)    => "3, #2"
+    case Tuple1(1)    => "1, #1"
+    case (_, _, _, 4) => "4, #4"
+    case THREE        => "THREE"
+    case (_, 2)       => "2, #2"
+    case _            => "default"
+  }
+
+  def main(args: Array[String]): Unit = {
+    println(f((1, 2, 3, 4)))
+    println(f((1, 2, 30, 4)))
+    println(f((1, 20, 30, 4)))
+    println(f((1, 2, 3)))
+    println(f((1, 2)))
+    println(f(Tuple1(1)))
+    println(f((-1, -2, -3, "bingo donkey vegas")))
+    println(f((-1, -2, -3)))
+  }
+}