Check that pattern matches make sense wrt equality

Author: odersky

src/dotty/tools/dotc/typer/Typer.scala

@@ -1540,26 +1540,9 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
             tree.withType(wtp.resultType)
           }
           val args = (wtp.paramNames, wtp.paramTypes).zipped map { (pname, formal) =>
-            def where = d"parameter $pname of $methodStr"
-            inferImplicit(formal, EmptyTree, tree.pos.endPos) match {
-              case SearchSuccess(arg, _, _) =>
-                arg
-              case ambi: AmbiguousImplicits =>
-                implicitArgError(s"ambiguous implicits: ${ambi.explanation} of $where")
-              case failure: SearchFailure =>
-                val arg = synthesizedClassTag(formal)
-                if (!arg.isEmpty) arg
-                else {
-                  var msg = d"no implicit argument of type $formal found for $where" + failure.postscript
-                  for (notFound <- formal.typeSymbol.getAnnotation(defn.ImplicitNotFoundAnnot);
-                       Literal(Constant(raw: String)) <- notFound.argument(0))
-                    msg = err.implicitNotFoundString(
-                        raw,
-                        formal.typeSymbol.typeParams.map(_.name.unexpandedName.toString),
-                        formal.argInfos)
-                  implicitArgError(msg)
-                }
-            }
+            def implicitArgError(msg: String => String) =
+              errors += (() => msg(d"parameter $pname of $methodStr"))
+            inferImplicitArg(formal, implicitArgError)
           }
           if (errors.nonEmpty) {
             // If there are several arguments, some arguments might already
@@ -1609,8 +1592,19 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         else
           missingArgs
       case _ =>
-        if (tree.tpe <:< pt) tree
-        else if (ctx.mode is Mode.Pattern) tree // no subtype check for pattern
+        if (ctx.mode is Mode.Pattern) {
+          tree match {
+            case _: RefTree | _: Literal
+            if !ctx.isAfterTyper && !isVarPattern(tree) && pt.derivesFrom(defn.EqClassClass) =>
+                def implicitArgError(msg: String => String) =
+                  ctx.error(msg("pattern match"), tree.pos.endPos)
+                val commonEq = defn.EqType.appliedTo(pt | wtp)
+                inferImplicitArg(commonEq, implicitArgError)(ctx.retractMode(Mode.Pattern))
+            case _ =>
+          }
+          tree
+        }
+        else if (tree.tpe <:< pt) tree
         else if (wtp.isInstanceOf[MethodType]) missingArgs
         else {
           typr.println(i"adapt to subtype ${tree.tpe} !<:< $pt")
@@ -1619,6 +1613,39 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         }
     }
 
+    /** Find an implicit argument for parameter `formal`.
+     *  @param error  An error handler that gets an error message parameter
+     *                which is itself parameterized by another string,
+     *                indicating where the implicit parameter is needed
+     */
+    def inferImplicitArg(formal: Type, error: (String => String) => Unit)(implicit ctx: Context): Tree =
+      inferImplicit(formal, EmptyTree, tree.pos.endPos) match {
+        case SearchSuccess(arg, _, _) =>
+          arg
+        case ambi: AmbiguousImplicits =>
+          error(where => s"ambiguous implicits: ${ambi.explanation} of $where")
+          EmptyTree
+        case failure: SearchFailure =>
+          val arg = synthesizedClassTag(formal)
+          if (!arg.isEmpty) arg
+          else {
+            var msgFn = (where: String) =>
+              d"no implicit argument of type $formal found for $where" + failure.postscript
+            for {
+              notFound <- formal.typeSymbol.getAnnotation(defn.ImplicitNotFoundAnnot)
+              Literal(Constant(raw: String)) <- notFound.argument(0)
+            } {
+              msgFn = where =>
+                err.implicitNotFoundString(
+                  raw,
+                  formal.typeSymbol.typeParams.map(_.name.unexpandedName.toString),
+                  formal.argInfos)
+            }
+            error(msgFn)
+            EmptyTree
+          }
+      }
+
     /** If `formal` is of the form ClassTag[T], where `T` is a class type,
      *  synthesize a class tag for `T`.
      */