Rename Eq -> Eql

Eq is already used with a slightly different meaning as a unary typeclass,
e.g. cats.Eq.

Author: odersky

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

@@ -734,11 +734,11 @@ class Definitions {
   lazy val TastyReflectionModule: TermSymbol = ctx.requiredModule("scala.tasty.Reflection")
     lazy val TastyReflection_macroContext: TermSymbol = TastyReflectionModule.requiredMethod("macroContext")
 
-  lazy val EqType: TypeRef = ctx.requiredClassRef("scala.Eq")
-  def EqClass(implicit ctx: Context): ClassSymbol = EqType.symbol.asClass
-  def EqModule(implicit ctx: Context): Symbol = EqClass.companionModule
+  lazy val EqlType: TypeRef = ctx.requiredClassRef("scala.Eql")
+  def EqlClass(implicit ctx: Context): ClassSymbol = EqlType.symbol.asClass
+  def EqlModule(implicit ctx: Context): Symbol = EqlClass.companionModule
 
-    def Eq_eqAny(implicit ctx: Context): TermSymbol = EqModule.requiredMethod(nme.eqAny)
+    def Eql_eqlAny(implicit ctx: Context): TermSymbol = EqlModule.requiredMethod(nme.eqlAny)
 
   lazy val NotType: TypeRef = ctx.requiredClassRef("scala.implicits.Not")
   def NotClass(implicit ctx: Context): ClassSymbol = NotType.symbol.asClass

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.derived
+  implicit def eqDenotation: Eql[Denotation, Denotation] = Eql.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.derived
+  implicit def eqName: Eql[Name, Name] = Eql.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/StdNames.scala

@@ -418,7 +418,7 @@ object StdNames {
     val equals_ : N             = "equals"
     val error: N                = "error"
     val eval: N                 = "eval"
-    val eqAny: N                = "eqAny"
+    val eqlAny: N               = "eqlAny"
     val ex: N                   = "ex"
     val experimental: N         = "experimental"
     val f: N                    = "f"

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.derived
+  implicit def eqSymbol: Eql[Symbol, Symbol] = Eql.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.derived
+  implicit def eqType: Eql[Type, Type] = Eql.derived
 
   /** Main class representing types.
    *

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

@@ -699,18 +699,18 @@ trait Implicits { self: Typer =>
       if (ctx.inInlineMethod || enclosingInlineds.nonEmpty) ref(defn.TastyReflection_macroContext)
       else EmptyTree
 
-    /** If `formal` is of the form Eq[T, U], try to synthesize an
-     *  `Eq.eqAny[T, U]` as solution.
+    /** If `formal` is of the form Eql[T, U], try to synthesize an
+     *  `Eql.eqlAny[T, U]` as solution.
      */
     def synthesizedEq(formal: Type)(implicit ctx: Context): Tree = {
 
       /** Is there an `Eql[T, T]` instance, assuming -strictEquality? */
       def hasEq(tp: Type)(implicit ctx: Context): Boolean = {
-        val inst = inferImplicitArg(defn.EqType.appliedTo(tp, tp), span)
+        val inst = inferImplicitArg(defn.EqlType.appliedTo(tp, tp), span)
         !inst.isEmpty && !inst.tpe.isError
       }
 
-      /** Can we assume the eqAny instance for `tp1`, `tp2`?
+      /** Can we assume the eqlAny instance for `tp1`, `tp2`?
        *  This is the case if assumedCanEqual(tp1, tp2), or
        *  one of `tp1`, `tp2` has a reflexive `Eql` instance.
        */
@@ -756,7 +756,7 @@ trait Implicits { self: Typer =>
               ||
               !strictEquality &&
               ctx.test(implicit ctx => validEqAnyArgs(arg1, arg2)))
-            ref(defn.Eq_eqAny).appliedToTypes(args).withSpan(span)
+            ref(defn.Eql_eqlAny).appliedToTypes(args).withSpan(span)
           else EmptyTree
         case _ =>
           EmptyTree
@@ -817,7 +817,7 @@ trait Implicits { self: Typer =>
             trySpecialCase(defn.QuotedTypeClass, synthesizedTypeTag,
               trySpecialCase(defn.GenericClass, synthesizedGeneric,
                 trySpecialCase(defn.TastyReflectionClass, synthesizedTastyContext,
-                  trySpecialCase(defn.EqClass, synthesizedEq,
+                  trySpecialCase(defn.EqlClass, synthesizedEq,
                     trySpecialCase(defn.ValueOfClass, synthesizedValueOf, failed))))))
     }
   }
@@ -963,8 +963,8 @@ trait Implicits { self: Typer =>
   /** Check that equality tests between types `ltp` and `rtp` make sense */
   def checkCanEqual(ltp: Type, rtp: Type, span: Span)(implicit ctx: Context): Unit =
     if (!ctx.isAfterTyper && !assumedCanEqual(ltp, rtp)) {
-      val res = implicitArgTree(defn.EqType.appliedTo(ltp, rtp), span)
-      implicits.println(i"Eq witness found for $ltp / $rtp: $res: ${res.tpe}")
+      val res = implicitArgTree(defn.EqlType.appliedTo(ltp, rtp), span)
+      implicits.println(i"Eql witness found for $ltp / $rtp: $res: ${res.tpe}")
     }
 
   /** Find an implicit parameter or conversion.
@@ -1032,7 +1032,7 @@ trait Implicits { self: Typer =>
       if (argument.isEmpty) f(resultType) else ViewProto(f(argument.tpe.widen), f(resultType))
         // Not clear whether we need to drop the `.widen` here. All tests pass with it in place, though.
 
-    private def isCoherent = pt.isRef(defn.EqClass)
+    private def isCoherent = pt.isRef(defn.EqlClass)
 
     private val cmpContext = nestedContext()
     private val cmpCandidates = (c1: Candidate, c2: Candidate) => compare(c1.ref, c2.ref, c1.level, c2.level)(cmpContext)

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.derived
+  implicit def eqSource: Eql[SourceFile, SourceFile] = Eql.derived
 
   implicit def fromContext(implicit ctx: Context): SourceFile = ctx.source
 

compiler/test-resources/repl/i4184

@@ -2,8 +2,8 @@ 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.derived
-def eqFoo: Eq[foo.Foo, foo.Foo]
+scala> implicit def eqFoo: Eql[foo.Foo, foo.Foo] = Eql.derived
+def eqFoo: Eql[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/enums/desugarEnums.md

@@ -134,15 +134,6 @@ map into case classes or vals.
    where `n` is the ordinal number of the case in the companion object,
    starting from 0.
 
-### Equality
-
-An `enum` type contains a `scala.Eq` instance that restricts values of the `enum` type to
-be compared only to other values of the same enum type. Furtermore, generic
-`enum` types are comparable only if their type arguments are. For instance the
-`Option` enum type will get the following definition in its companion object:
-
-    implicit def eqOption[T, U](implicit ev1: Eq[T, U]): Eq[Option[T], Option[U]] = Eq
-
 ### Translation of Enumerations
 
 Non-generic enums `E` that define one or more singleton cases