Make eqAny a member of Eq

Was Predef, but that does not work because that way we cannot always
determine whether a class has an Eq instance by an implicit search.
The eqAny in Predef was found by a contextual search, so we never
looked for another Eq by a search of the implicit scope. Making
eqAny a member of Eq avoids this problem.

Author: odersky

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -347,7 +347,6 @@ class Definitions {
 
   def DottyPredefModule(implicit ctx: Context) = DottyPredefModuleRef.symbol
 
-    def Predef_eqAny(implicit ctx: Context) = DottyPredefModule.requiredMethod(nme.eqAny)
     lazy val Predef_ImplicitConverterR = DottyPredefModule.requiredClass("ImplicitConverter").typeRef
     def Predef_ImplicitConverter(implicit ctx: Context) = Predef_ImplicitConverterR.symbol
 
@@ -547,6 +546,9 @@ class Definitions {
 
   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.requiredMethod(nme.eqAny)
 
   lazy val XMLTopScopeModuleRef = ctx.requiredModuleRef("scala.xml.TopScope")
 

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -762,7 +762,7 @@ trait Implicits { self: Typer =>
         // Does there exist an implicit value of type `Eq[tp, tp]`?
         def hasEq(tp: Type): Boolean =
           new ImplicitSearch(defn.EqType.appliedTo(tp, tp), EmptyTree, pos).bestImplicit match {
-            case result: SearchSuccess => result.ref.symbol != defn.Predef_eqAny
+            case result: SearchSuccess => result.ref.symbol != defn.Eq_eqAny
             case result: AmbiguousImplicits => true
             case _ => false
           }
@@ -781,7 +781,7 @@ trait Implicits { self: Typer =>
         }
         else generated1 match {
           case TypeApply(fn, targs @ (arg1 :: arg2 :: Nil))
-          if fn.symbol == defn.Predef_eqAny && !validEqAnyArgs(arg1.tpe, arg2.tpe) =>
+          if fn.symbol == defn.Eq_eqAny && !validEqAnyArgs(arg1.tpe, arg2.tpe) =>
             nonMatchingImplicit(ref, Nil)
           case _ =>
             SearchSuccess(generated1, ref, cand.level, ctx.typerState)

library/src/dotty/DottyPredef.scala

@@ -12,8 +12,6 @@ object DottyPredef {
    *  Eq-free. A type `S` is Eq-free if there is no implicit instance of `Eq[S, S]`.
    *  An implicit search will fail instead of returning an invalid `eqAny` instance.
    */
-  implicit def eqAny[L, R]: Eq[L, R] = Eq
-
   implicit def eqNumber   : Eq[Number, Number] = Eq
   implicit def eqString   : Eq[String, String] = Eq
 

library/src/scala/Eq.scala

@@ -10,5 +10,6 @@ sealed trait Eq[-L, -R]
  *  can also be used as a value that's compatible with
  *  any instance of `Eq`.
  */
-object Eq extends Eq[Any, Any]
-
+object Eq extends Eq[Any, Any] {
+  implicit def eqAny[L, R]: Eq[L, R] = this
+}