turn unchecked type patterns into checked ones

the pattern `(_: T)` is made checkable using (ct: ClassTag[T]).unapply
by rewriting it to `ct(_: T)` (if there's a ClassTag[T] available)

similarly for extractors: if the formal type of the unapply method
is an uncheckable type, wrap in the corresponding classtag extractor (if available)

don't trigger rewrite on non-toplevel unchecked types
(i.e., only look at type constructor part of T when looking for unchecked types)

TODO: find outer match to figure out if we're supposed to be unchecked

would like to give users a chance to opt-out from the wrapping,
but finding the match to which this pattern belongs turned out to be tricky...

1 files changed, 36 insertions, 0 deletions

diff --git a/test/files/run/virtpatmat_typetag.scala b/test/files/run/virtpatmat_typetag.scala
new file mode 100644
index 0000000000..c1b1fd813a
--- /dev/null
+++ b/test/files/run/virtpatmat_typetag.scala
@@ -0,0 +1,36 @@
+import reflect.{ClassTag, classTag}
+
+trait Extractors {
+  type T
+  implicit val tTag: ClassTag[T]
+  object ExtractT {
+    def unapply(x: T) = Some(x)
+  }
+  def apply(a: Any) = a match {
+    case ExtractT(x)  => println(x +" is a "+ implicitly[ClassTag[T]])
+    case _ => println(a+ " is not a "+ implicitly[ClassTag[T]] +"; it's a "+ a.getClass)
+  }
+}
+
+object Test extends App {
+  def typeMatch[T: ClassTag](a: Any) = a match {
+    case x : T => println(x +" is a "+ implicitly[ClassTag[T]])
+    case _ => println(a+ " is not a "+ implicitly[ClassTag[T]] +"; it's a "+ a.getClass)
+  }
+
+  // the same match as typeMatch, but using an extractor
+  def extractorMatch[S: ClassTag](a: Any) =
+    (new Extractors { type T = S; val tTag = classTag[T] })(a)
+
+  typeMatch[Int](1)
+  typeMatch[Integer](1)
+  typeMatch[String](1)
+  typeMatch[Any](true)
+  typeMatch[String]("woele")
+
+  extractorMatch[Int](1)
+  extractorMatch[Integer](1)
+  extractorMatch[String](1)
+  extractorMatch[Any](true)
+  extractorMatch[String]("woele")
+}
\ No newline at end of file