Use Eq.derived as the universal Eq instance

Author: odersky

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

@@ -67,7 +67,7 @@ import collection.mutable.ListBuffer
  */
 object Denotations {
 
-  implicit def eqDenotation: Eq[Denotation, Denotation] = Eq
+  implicit def eqDenotation: Eq[Denotation, Denotation] = Eq.derived
 
   /** A PreDenotation represents a group of single denotations or a single multi-denotation
    *  It is used as an optimization to avoid forming MultiDenotations too eagerly.

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

@@ -25,7 +25,7 @@ object Names {
     def toTermName: TermName
   }
 
-  implicit def eqName: Eq[Name, Name] = Eq
+  implicit def eqName: Eq[Name, Name] = Eq.derived
 
   /** A common superclass of Name and Symbol. After bootstrap, this should be
    *  just the type alias Name | Symbol

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

@@ -406,7 +406,7 @@ trait Symbols { this: Context =>
 
 object Symbols {
 
-  implicit def eqSymbol: Eq[Symbol, Symbol] = Eq
+  implicit def eqSymbol: Eq[Symbol, Symbol] = Eq.derived
 
   /** Tree attachment containing the identifiers in a tree as a sorted array */
   val Ids: Property.Key[Array[String]] = new Property.Key

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

@@ -40,7 +40,7 @@ object Types {
 
   @sharable private[this] var nextId = 0
 
-  implicit def eqType: Eq[Type, Type] = Eq
+  implicit def eqType: Eq[Type, Type] = Eq.derived
 
   /** Main class representing types.
    *

compiler/src/dotty/tools/dotc/util/SourceFile.scala

@@ -190,7 +190,7 @@ class SourceFile(val file: AbstractFile, computeContent: => Array[Char]) extends
   }
 }
 object SourceFile {
-  implicit def eqSource: Eq[SourceFile, SourceFile] = Eq
+  implicit def eqSource: Eq[SourceFile, SourceFile] = Eq.derived
 
   implicit def fromContext(implicit ctx: Context): SourceFile = ctx.source
 

compiler/test-resources/repl/i4184

@@ -2,7 +2,7 @@ scala> object foo { class Foo }
 // defined object foo
 scala> object bar { class Foo }
 // defined object bar
-scala> implicit def eqFoo: Eq[foo.Foo, foo.Foo] = Eq
+scala> implicit def eqFoo: Eq[foo.Foo, foo.Foo] = Eq.derived
 def eqFoo: Eq[foo.Foo, foo.Foo]
 scala> object Bar { new foo.Foo == new bar.Foo }
 1 | object Bar { new foo.Foo == new bar.Foo }

docs/docs/reference/other-new-features/multiversal-equality.md

@@ -29,7 +29,7 @@ would not typecheck if an implicit was declared like this for type `T`
 (or an analogous one for type `S`):
 
 ```scala
-implicit def eqT: Eq[T, T] = Eq
+implicit def eqT: Eq[T, T] = Eq.derived
 ```
 
 This definition effectively says that value of type `T` can (only) be
@@ -55,10 +55,10 @@ definitions below make values of type `A` and type `B` comparable with
 each other, but not comparable to anything else:
 
 ```scala
-implicit def eqA : Eq[A, A] = Eq
-implicit def eqB : Eq[B, B] = Eq
-implicit def eqAB: Eq[A, B] = Eq
-implicit def eqBA: Eq[B, A] = Eq
+implicit def eqA : Eq[A, A] = Eq.derived
+implicit def eqB : Eq[B, B] = Eq.derived
+implicit def eqAB: Eq[A, B] = Eq.derived
+implicit def eqBA: Eq[B, A] = Eq.derived
 ```
 
 (As usual, the names of the implicit definitions don't matter, we have
@@ -75,7 +75,7 @@ over all types that do not themselves have an `Eq` instance.  `eqAny` is
 defined as follows:
 
 ```scala
-def eqAny[L, R]: Eq[L, R] = Eq
+def eqAny[L, R]: Eq[L, R] = Eq.derived
 ```
 
 Even though `eqAny` is not declared implicit, the compiler will still

library/src/scala/Eq.scala

@@ -11,52 +11,52 @@ 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] {
-  def derived: Eq[Any, Any] = Eq
+object Eq {
+  object derived extends Eq[Any, Any]
 
   /** A fall-back "implicit" to compare values of any types.
    *  Even though this method is not declared implicit, the compiler will
    *  compute instances as solutions to `Eq[T, U]` queries if `T <: U` or `U <: T`
    *  or both `T` and `U` are Eq-free. A type `S` is Eq-free if there is no
    *  implicit instance of type `Eq[S, S]`.
    */
-  def eqAny[L, R]: Eq[L, R] = Eq
+  def eqAny[L, R]: Eq[L, R] = derived
 
   // Instances of `Eq` for common types
 
-  implicit def eqNumber   : Eq[Number, Number] = Eq
-  implicit def eqString   : Eq[String, String] = Eq
-  implicit def eqBoolean  : Eq[Boolean, Boolean] = Eq
-  implicit def eqByte     : Eq[Byte, Byte] = Eq
-  implicit def eqShort    : Eq[Short, Short] = Eq
-  implicit def eqChar     : Eq[Char, Char] = Eq
-  implicit def eqInt      : Eq[Int, Int] = Eq
-  implicit def eqLong     : Eq[Long, Long] = Eq
-  implicit def eqFloat    : Eq[Float, Float] = Eq
-  implicit def eqDouble   : Eq[Double, Double] = Eq
-  implicit def eqUnit     : Eq[Unit, Unit] = Eq
+  implicit def eqNumber   : Eq[Number, Number] = derived
+  implicit def eqString   : Eq[String, String] = derived
+  implicit def eqBoolean  : Eq[Boolean, Boolean] = derived
+  implicit def eqByte     : Eq[Byte, Byte] = derived
+  implicit def eqShort    : Eq[Short, Short] = derived
+  implicit def eqChar     : Eq[Char, Char] = derived
+  implicit def eqInt      : Eq[Int, Int] = derived
+  implicit def eqLong     : Eq[Long, Long] = derived
+  implicit def eqFloat    : Eq[Float, Float] = derived
+  implicit def eqDouble   : Eq[Double, Double] = derived
+  implicit def eqUnit     : Eq[Unit, Unit] = derived
 
   // true asymmetry, modeling the (somewhat problematic) nature of equals on Proxies
-  implicit def eqProxy    : Eq[Proxy, Any]     = Eq
-
-  implicit def eqSeq[T, U](implicit eq: Eq[T, U]): Eq[GenSeq[T], GenSeq[U]] = Eq
-  implicit def eqSet[T, U](implicit eq: Eq[T, U]): Eq[Set[T], Set[U]] = Eq
-
-  implicit def eqByteNum  : Eq[Byte, Number]   = Eq
-  implicit def eqNumByte  : Eq[Number, Byte]   = Eq
-  implicit def eqCharNum  : Eq[Char, Number]   = Eq
-  implicit def eqNumChar  : Eq[Number, Char]   = Eq
-  implicit def eqShortNum : Eq[Short, Number]  = Eq
-  implicit def eqNumShort : Eq[Number, Short]  = Eq
-  implicit def eqIntNum   : Eq[Int, Number]    = Eq
-  implicit def eqNumInt   : Eq[Number, Int]    = Eq
-  implicit def eqLongNum  : Eq[Long, Number]   = Eq
-  implicit def eqNumLong  : Eq[Number, Long]   = Eq
-  implicit def eqFloatNum : Eq[Float, Number]  = Eq
-  implicit def eqNumFloat : Eq[Number, Float]  = Eq
-  implicit def eqDoubleNum: Eq[Double, Number] = Eq
-  implicit def eqNumDouble: Eq[Number, Double] = Eq
-
-  implicit def eqSBoolJBool: Eq[Boolean, java.lang.Boolean] = Eq
-  implicit def eqJBoolSBool: Eq[java.lang.Boolean, Boolean] = Eq
+  implicit def eqProxy    : Eq[Proxy, Any]     = derived
+
+  implicit def eqSeq[T, U](implicit eq: Eq[T, U]): Eq[GenSeq[T], GenSeq[U]] = derived
+  implicit def eqSet[T, U](implicit eq: Eq[T, U]): Eq[Set[T], Set[U]] = derived
+
+  implicit def eqByteNum  : Eq[Byte, Number]   = derived
+  implicit def eqNumByte  : Eq[Number, Byte]   = derived
+  implicit def eqCharNum  : Eq[Char, Number]   = derived
+  implicit def eqNumChar  : Eq[Number, Char]   = derived
+  implicit def eqShortNum : Eq[Short, Number]  = derived
+  implicit def eqNumShort : Eq[Number, Short]  = derived
+  implicit def eqIntNum   : Eq[Int, Number]    = derived
+  implicit def eqNumInt   : Eq[Number, Int]    = derived
+  implicit def eqLongNum  : Eq[Long, Number]   = derived
+  implicit def eqNumLong  : Eq[Number, Long]   = derived
+  implicit def eqFloatNum : Eq[Float, Number]  = derived
+  implicit def eqNumFloat : Eq[Number, Float]  = derived
+  implicit def eqDoubleNum: Eq[Double, Number] = derived
+  implicit def eqNumDouble: Eq[Number, Double] = derived
+
+  implicit def eqSBoolJBool: Eq[Boolean, java.lang.Boolean] = derived
+  implicit def eqJBoolSBool: Eq[java.lang.Boolean, Boolean] = derived
 }

tests/neg/EqualityStrawman1.scala

@@ -8,8 +8,10 @@ object EqualityStrawman1 {
   @implicitNotFound("cannot compare value of type ${T} with a value outside its equality class")
   trait Impossible[T]
 
-  object Eq extends Eq[Any]
-
+  object Eq {
+    object derived extends Eq[Any]
+  }
+  
   trait Base {
     def === (other: Any): Boolean = this.equals(other)
     def === [T <: CondEquals](other: T)(implicit ce: Impossible[T]): Boolean = ???
@@ -32,11 +34,11 @@ object EqualityStrawman1 {
   case class Some[+T](x: T) extends Option[T]
   case object None extends Option[Nothing]
 
-  implicit def eqStr: Eq[Str] = Eq
-  //implicit def eqNum: Eq[Num] = Eq
-  implicit def eqOption[T: Eq]: Eq[Option[T]] = Eq
+  implicit def eqStr: Eq[Str] = Eq.derived
+  //implicit def eqNum: Eq[Num] = Eq.derived
+  implicit def eqOption[T: Eq]: Eq[Option[T]] = Eq.derived
 
-  implicit def eqEq[T <: Equals[T]]: Eq[T] = Eq
+  implicit def eqEq[T <: Equals[T]]: Eq[T] = Eq.derived
 
   def main(args: Array[String]): Unit = {
     val x = Str("abc")

tests/neg/derive-eq.scala

@@ -2,7 +2,7 @@
 case class One() derives Eq
 case class Two() derives Eq
 
-implied for Eq[One, Two] = Eq
+implied for Eq[One, Two] = Eq.derived
 
 enum Lst[T] derives Eq {
   case Cons(x: T, xs: Lst[T])