Pattern matcher: extractors become name-based.

An extractor is no longer required to return Option[T], and
can instead return anything which directly contains methods
with these signatures:

  def isEmpty: Boolean
  def get: T

If the type of get contains methods with the names of
product selectors (_1, _2, etc.) then the type and arity
of the extraction is inferred from the type of get. If
it does not contain _1, then it is a single value
extractor analogous like Option[T].

This has significant benefits and opens new territory:

  - an AnyVal based Option-like class can be used which
    leverages null as None, and no allocations are necessary
  - for primitive types the benefit is squared (see below)
  - the performance difference between case classes and
    extractors should now be largely eliminated
  - this in turn allows us to recapture great swaths of
    memory which are currently squandered (e.g. every
    TypeRef has fields for pre and args, even though these
    are more than half the time NoPrefix and Nil)

Here is a primitive example:

  final class OptInt(val x: Int) extends AnyVal {
    def get: Int = x
    def isEmpty = x == Int.MinValue // or whatever is appropriate
  }
  // This boxes TWICE: Int => Integer => Some(Integer)
  def unapply(x: Int): Option[Int]
  // This boxes NONCE
  def unapply(x: Int): OptInt

As a multi-value example, after I contribute some methods to TypeRef:

  def isEmpty = false
  def get     = this
  def _1      = pre
  def _2      = sym
  def _3      = args

Then it's extractor becomes

  def unapply(x: TypeRef) = x

Which, it need hardly be said, involves no allocations.

1 files changed, 21 insertions, 15 deletions

diff --git a/test/files/neg/t4425b.check b/test/files/neg/t4425b.check
index e43c489586..3af3027da1 100644
--- a/test/files/neg/t4425b.check
+++ b/test/files/neg/t4425b.check
@@ -22,34 +22,40 @@ t4425b.scala:10: error: object X is not a case class constructor, nor does it ha
 Note: def unapply(x: String)(y: String): Nothing exists in object X, but it cannot be used as an extractor due to its second non-implicit parameter list
     println((X: Any) match { case X(_, _) => "ok" ; case _ => "fail" })
                                   ^
-t4425b.scala:18: error: result type Nothing of unapply defined in method unapply in object X does not conform to Option[_] or Boolean
+t4425b.scala:18: error: wrong number of patterns for object X offering <notype>: expected 1, found 2
     println(      "" match { case _ X _   => "ok" ; case _ => "fail" })
                                     ^
-t4425b.scala:19: error: result type Nothing of unapply defined in method unapply in object X does not conform to Option[_] or Boolean
+t4425b.scala:19: error: wrong number of patterns for object X offering <notype>: expected 1, found 2
     println((X: Any) match { case _ X _   => "ok" ; case _ => "fail" })
                                     ^
-t4425b.scala:20: error: result type Nothing of unapply defined in method unapply in object X does not conform to Option[_] or Boolean
-    println(      "" match { case X(_)    => "ok" ; case _ => "fail" })
-                                   ^
-t4425b.scala:21: error: result type Nothing of unapply defined in method unapply in object X does not conform to Option[_] or Boolean
-    println((X: Any) match { case X(_)    => "ok" ; case _ => "fail" })
-                                   ^
-t4425b.scala:22: error: result type Nothing of unapply defined in method unapply in object X does not conform to Option[_] or Boolean
+t4425b.scala:22: error: wrong number of patterns for object X offering <notype>: expected 1, found 2
+    println(      "" match { case X(_, _) => "ok" ; case _ => "fail" })
+                                  ^
+t4425b.scala:22: error: wrong number of patterns for object X offering <notype>: expected 1, found 2
     println(      "" match { case X(_, _) => "ok" ; case _ => "fail" })
                                    ^
-t4425b.scala:23: error: result type Nothing of unapply defined in method unapply in object X does not conform to Option[_] or Boolean
+t4425b.scala:23: error: wrong number of patterns for object X offering <notype>: expected 1, found 2
+    println((X: Any) match { case X(_, _) => "ok" ; case _ => "fail" })
+                                  ^
+t4425b.scala:23: error: wrong number of patterns for object X offering <notype>: expected 1, found 2
     println((X: Any) match { case X(_, _) => "ok" ; case _ => "fail" })
                                    ^
-t4425b.scala:31: error: wrong number of arguments for object X
+t4425b.scala:31: error: wrong number of patterns for object X offering Nothing: expected 1, found 2
     println(      "" match { case _ X _   => "ok" ; case _ => "fail" })
                                     ^
-t4425b.scala:32: error: wrong number of arguments for object X
+t4425b.scala:32: error: wrong number of patterns for object X offering Nothing: expected 1, found 2
     println((X: Any) match { case _ X _   => "ok" ; case _ => "fail" })
                                     ^
-t4425b.scala:35: error: wrong number of arguments for object X
+t4425b.scala:35: error: wrong number of patterns for object X offering Nothing: expected 1, found 2
+    println(      "" match { case X(_, _) => "ok" ; case _ => "fail" })
+                                  ^
+t4425b.scala:35: error: wrong number of patterns for object X offering Nothing: expected 1, found 2
     println(      "" match { case X(_, _) => "ok" ; case _ => "fail" })
                                    ^
-t4425b.scala:36: error: wrong number of arguments for object X
+t4425b.scala:36: error: wrong number of patterns for object X offering Nothing: expected 1, found 2
+    println((X: Any) match { case X(_, _) => "ok" ; case _ => "fail" })
+                                  ^
+t4425b.scala:36: error: wrong number of patterns for object X offering Nothing: expected 1, found 2
     println((X: Any) match { case X(_, _) => "ok" ; case _ => "fail" })
                                    ^
-16 errors found
+18 errors found