Hooks to check that comparisons with == / != make sense

Also, check that pattern matching against idents/selects/literals makes
sense.

The hooks perform an implicit search for an instance of `Eq[L, R]`, where
`L`, `R` are the argument types. So far this always succeeeds because Eq.eqAny
matches all such types. A separate commit will check the returned
search term for validity.

5 files changed, 94 insertions, 46 deletions

diff --git a/src/dotty/tools/dotc/core/Definitions.scala b/src/dotty/tools/dotc/core/Definitions.scala
index 7f59cbed0..b99d0716b 100644
--- a/src/dotty/tools/dotc/core/Definitions.scala
+++ b/src/dotty/tools/dotc/core/Definitions.scala
@@ -424,10 +424,17 @@ class Definitions {
   lazy val LanguageModuleRef          = ctx.requiredModule("dotty.language")
   def LanguageModuleClass(implicit ctx: Context) = LanguageModuleRef.symbol.moduleClass.asClass
   lazy val NonLocalReturnControlType: TypeRef   = ctx.requiredClassRef("scala.runtime.NonLocalReturnControl")
+
   lazy val ClassTagType = ctx.requiredClassRef("scala.reflect.ClassTag")
   def ClassTagClass(implicit ctx: Context) = ClassTagType.symbol.asClass
   def ClassTagModule(implicit ctx: Context) = ClassTagClass.companionModule
 
+  lazy val EqType = ctx.requiredClassRef("scala.Eq")
+  def EqClass(implicit ctx: Context) = EqType.symbol.asClass
+  def EqModule(implicit ctx: Context) = EqClass.companionModule
+
+    def Eq_eqAny(implicit ctx: Context) = EqModule.requiredMethodRef(nme.eqAny)
+
   // Annotation base classes
   lazy val AnnotationType              = ctx.requiredClassRef("scala.annotation.Annotation")
   def AnnotationClass(implicit ctx: Context) = AnnotationType.symbol.asClass
diff --git a/src/dotty/tools/dotc/core/StdNames.scala b/src/dotty/tools/dotc/core/StdNames.scala
index e2add1a52..81f6da0e2 100644
--- a/src/dotty/tools/dotc/core/StdNames.scala
+++ b/src/dotty/tools/dotc/core/StdNames.scala
@@ -394,6 +394,7 @@ object StdNames {
     val equals_ : N             = "equals"
     val error: N                = "error"
     val eval: N                 = "eval"
+    val eqAny: N                = "eqAny"
     val ex: N                   = "ex"
     val experimental: N         = "experimental"
     val f: N                    = "f"
diff --git a/src/dotty/tools/dotc/typer/Applications.scala b/src/dotty/tools/dotc/typer/Applications.scala
index 6ce98606b..2b0cc4033 100644
--- a/src/dotty/tools/dotc/typer/Applications.scala
+++ b/src/dotty/tools/dotc/typer/Applications.scala
@@ -603,7 +603,17 @@ trait Applications extends Compatibility { self: Typer =>
           failedVal
         }
       }
-    else realApply
+    else {
+      val app = realApply
+      app match {
+        case Apply(fn @ Select(left, _), right :: Nil) if fn.hasType =>
+          val op = fn.symbol
+          if (op == defn.Any_== || op == defn.Any_!=)
+            checkCanEqual(left.tpe.widen, right.tpe.widen, app.pos)
+        case _ =>
+      }
+      app
+    }
   }
 
   /** Overridden in ReTyper to handle primitive operations that can be generated after erasure */
diff --git a/src/dotty/tools/dotc/typer/Implicits.scala b/src/dotty/tools/dotc/typer/Implicits.scala
index 940170ceb..ff8e607ed 100644
--- a/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/src/dotty/tools/dotc/typer/Implicits.scala
@@ -23,6 +23,8 @@ import Constants._
 import Applications._
 import ProtoTypes._
 import ErrorReporting._
+import Inferencing.fullyDefinedType
+import Trees._
 import Hashable._
 import config.Config
 import config.Printers._
@@ -415,6 +417,68 @@ trait Implicits { self: Typer =>
       }
   }
 
+  /** 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, pos: Position)(implicit ctx: Context): Tree =
+    inferImplicit(formal, EmptyTree, pos) 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, pos)
+        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)
+            Trees.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`.
+   */
+  def synthesizedClassTag(formal: Type, pos: Position)(implicit ctx: Context): Tree = {
+    if (formal.isRef(defn.ClassTagClass))
+      formal.argTypes match {
+        case arg :: Nil =>
+          val tp = fullyDefinedType(arg, "ClassTag argument", pos)
+          tp.underlyingClassRef(refinementOK = false) match {
+            case tref: TypeRef =>
+              return ref(defn.ClassTagModule)
+                .select(nme.apply)
+                .appliedToType(tp)
+                .appliedTo(clsOf(tref))
+                .withPos(pos)
+            case _ =>
+          }
+        case _ =>
+      }
+    EmptyTree
+  }
+
+  def checkCanEqual(ltp: Type, rtp: Type, pos: Position)(implicit ctx: Context): Unit =
+    if (!ctx.isAfterTyper && !ltp.isError && !rtp.isError)
+      inferImplicitArg(
+        defn.EqType.appliedTo(ltp, rtp),
+        _ => d"Values of types $ltp and $rtp cannot be compared with == or !=",
+        pos)
+
   /** Find an implicit parameter or conversion.
    *  @param pt              The expected type of the parameter or conversion.
    *  @param argument        If an implicit conversion is searched, the argument to which
diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index f7fa318cd..b26ff4509 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/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, tree.pos.endPos)
           }
           if (errors.nonEmpty) {
             // If there are several arguments, some arguments might already
@@ -1609,8 +1592,14 @@ 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 !isVarPattern(tree) => checkCanEqual(pt, wtp, tree.pos)
+            case _ =>
+          }
+          tree
+        }
+        else if (tree.tpe <:< pt) tree
         else if (wtp.isInstanceOf[MethodType]) missingArgs
         else {
           typr.println(i"adapt to subtype ${tree.tpe} !<:< $pt")
@@ -1618,29 +1607,6 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           adaptToSubType(wtp)
         }
     }
-
-    /** If `formal` is of the form ClassTag[T], where `T` is a class type,
-     *  synthesize a class tag for `T`.
-     */
-    def synthesizedClassTag(formal: Type): Tree = {
-      if (formal.isRef(defn.ClassTagClass))
-        formal.argTypes match {
-          case arg :: Nil =>
-            val tp = fullyDefinedType(arg, "ClassTag argument", tree.pos)
-            tp.underlyingClassRef(refinementOK = false) match {
-              case tref: TypeRef =>
-                return ref(defn.ClassTagModule)
-                  .select(nme.apply)
-                  .appliedToType(tp)
-                  .appliedTo(clsOf(tref))
-                  .withPos(tree.pos.endPos)
-              case _ =>
-            }
-          case _ =>
-        }
-      EmptyTree
-    }
-
     /** Adapt an expression of constant type to a different constant type `tpe`. */
     def adaptConstant(tree: Tree, tpe: ConstantType): Tree = {
       def lit = Literal(tpe.value).withPos(tree.pos)