From 80511914713237de894f896da7397965e52134a7 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Fri, 17 Feb 2017 16:38:06 +0100
Subject: Fix #1991: Use classtag where available in unapply

---
 .../src/dotty/tools/dotc/typer/Applications.scala  |  2 +-
 compiler/src/dotty/tools/dotc/typer/Typer.scala    | 33 +++++++++++++---------
 tests/run/i1991.scala                              | 20 +++++++++++++
 3 files changed, 41 insertions(+), 14 deletions(-)
 create mode 100644 tests/run/i1991.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index 42c24ffb7..0ed6ed6b4 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -916,7 +916,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         val result = assignType(cpy.UnApply(tree)(unapplyFn, unapplyImplicits, unapplyPatterns), ownType)
         unapp.println(s"unapply patterns = $unapplyPatterns")
         if ((ownType eq selType) || ownType.isError) result
-        else Typed(result, TypeTree(ownType))
+        else tryWithClassTag(Typed(result, TypeTree(ownType)), selType)
       case tp =>
         val unapplyErr = if (tp.isError) unapplyFn else notAnExtractor(unapplyFn)
         val typedArgsErr = args mapconserve (typed(_, defn.AnyType))
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 2b57cf778..820044b8e 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -523,18 +523,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       def handlePattern: Tree = {
         val tpt1 = typedTpt
         // special case for an abstract type that comes with a class tag
-        tpt1.tpe.dealias match {
-          case tref: TypeRef if !tref.symbol.isClass && !ctx.isAfterTyper =>
-            inferImplicit(defn.ClassTagType.appliedTo(tref),
-               EmptyTree, tpt1.pos)(ctx.retractMode(Mode.Pattern)) match {
-              case SearchSuccess(arg, _, _, _) =>
-                return typed(untpd.Apply(untpd.TypedSplice(arg), tree.expr), pt)
-              case _ =>
-            }
-          case _ =>
-            if (!ctx.isAfterTyper) tpt1.tpe.<:<(pt)(ctx.addMode(Mode.GADTflexible))
-        }
-        ascription(tpt1, isWildcard = true)
+        if (!ctx.isAfterTyper) tpt1.tpe.<:<(pt)(ctx.addMode(Mode.GADTflexible))
+        tryWithClassTag(ascription(tpt1, isWildcard = true), pt)
       }
       cases(
         ifPat = handlePattern,
@@ -543,6 +533,23 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     }
   }
 
+  /** For a typed tree `e: T`, if `T` is an abstract type for which an implicit class tag `ctag`
+   *  exists, rewrite to `ctag(e)`.
+   *  @pre We are in pattern-matching mode (Mode.Pattern)
+   */
+  def tryWithClassTag(tree: Typed, pt: Type)(implicit ctx: Context) = tree.tpt.tpe.dealias match {
+    case tref: TypeRef if !tref.symbol.isClass && !ctx.isAfterTyper =>
+      require(ctx.mode.is(Mode.Pattern))
+      inferImplicit(defn.ClassTagType.appliedTo(tref),
+                    EmptyTree, tree.tpt.pos)(ctx.retractMode(Mode.Pattern)) match {
+        case SearchSuccess(clsTag, _, _, _) =>
+          typed(untpd.Apply(untpd.TypedSplice(clsTag), untpd.TypedSplice(tree.expr)), pt)
+        case _ =>
+          tree
+      }
+    case _ => tree
+  }
+
   def typedNamedArg(tree: untpd.NamedArg, pt: Type)(implicit ctx: Context) = track("typedNamedArg") {
     val arg1 = typed(tree.arg, pt)
     assignType(cpy.NamedArg(tree)(tree.name, arg1), arg1)
@@ -1123,7 +1130,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val body1 = typed(tree.body, pt1)
     typr.println(i"typed bind $tree pt = $pt1 bodytpe = ${body1.tpe}")
     body1 match {
-      case UnApply(fn, Nil, arg :: Nil) if tree.body.isInstanceOf[untpd.Typed] =>
+      case UnApply(fn, Nil, arg :: Nil) if tree.body.isInstanceOf[untpd.Typed] && !body1.tpe.isError =>
         // A typed pattern `x @ (_: T)` with an implicit `ctag: ClassTag[T]`
         // was rewritten to `x @ ctag(_)`.
         // Rewrite further to `ctag(x @ _)`
diff --git a/tests/run/i1991.scala b/tests/run/i1991.scala
new file mode 100644
index 000000000..524a3f311
--- /dev/null
+++ b/tests/run/i1991.scala
@@ -0,0 +1,20 @@
+import scala.reflect.ClassTag
+
+class A[Foo](implicit tag: ClassTag[Foo]) {
+  object ExtractFoo {
+    def unapply(foo: Foo): Boolean = true
+  }
+
+  def isFoo(x: Any) = x match {
+    case ExtractFoo() => true
+    //case foo: Foo => true
+    case _ => false
+  }
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    assert((new A[String]).isFoo("foo")) // OK
+    assert(!(new A[String]).isFoo(42)) // OK in scalac, fails in Dotty
+  }
+}
-- 
cgit v1.2.3