Rename Eql to CanEqual in internal compiler code

Author: odersky

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

@@ -840,10 +840,10 @@ class Definitions {
 
   @tu lazy val TastyReflectionClass: ClassSymbol = requiredClass("scala.tasty.Reflection")
 
-  @tu lazy val EqlClass: ClassSymbol = getClassIfDefined("scala.Eql").orElse(requiredClass("scala.CanEqual")).asClass
-    def Eql_eqlAny(using Context): TermSymbol =
-      val methodName = if EqlClass.name == tpnme.Eql then nme.eqlAny else nme.canEqualAny
-      EqlClass.companionModule.requiredMethod(methodName)
+  @tu lazy val CanEqualClass: ClassSymbol = getClassIfDefined("scala.Eql").orElse(requiredClass("scala.CanEqual")).asClass
+    def CanEqual_canEqualAny(using Context): TermSymbol =
+      val methodName = if CanEqualClass.name == tpnme.Eql then nme.eqlAny else nme.canEqualAny
+      CanEqualClass.companionModule.requiredMethod(methodName)
 
   @tu lazy val TypeBoxClass: ClassSymbol = requiredClass("scala.runtime.TypeBox")
     @tu lazy val TypeBox_CAP: TypeSymbol = TypeBoxClass.requiredType(tpnme.CAP)

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

@@ -67,9 +67,9 @@ trait Deriving {
      *          the deriving ADT
      *      (b) a single parameter type class with a parameter of kind * and an ADT with
      *          one or more type parameter of kind *
-     *      (c) the Eql type class
+     *      (c) the CanEqual type class
      *
-     *      See detailed descriptions in deriveSingleParameter and deriveEql below.
+     *      See detailed descriptions in deriveSingleParameter and deriveCanEqual below.
      *
      *  If it passes the checks, enter a type class instance for it in the current scope.
      *
@@ -145,7 +145,7 @@ trait Deriving {
         //
         //          given derived$TC[a, b, c] given TC[a], TC[b], TC[c]: TC[a, b, c]
         //
-        //     This, like the derivation for Eql, is a special case of the
+        //     This, like the derivation for CanEqual, is a special case of the
         //     earlier more general multi-parameter type class model for which
         //     the heuristic is typically a good one.
 
@@ -185,8 +185,8 @@ trait Deriving {
           cannotBeUnified
       }
 
-      def deriveEql: Unit = {
-        // Specific derives rules for the Eql type class ... (c) above
+      def deriveCanEqual: Unit = {
+        // Specific derives rules for the CanEqual type class ... (c) above
         //
         // This has been extracted from the earlier more general multi-parameter
         // type class model. Modulo the assumptions below, the implied semantics
@@ -196,26 +196,26 @@ trait Deriving {
         // 1. Type params of the deriving class correspond to all and only
         // elements of the deriving class which are relevant to equality (but:
         // type params could be phantom, or the deriving class might have an
-        // element of a non-Eql type non-parametrically).
+        // element of a non-CanEqual type non-parametrically).
         //
         // 2. Type params of kinds other than * can be assumed to be irrelevant to
         // the derivation (but: eg. Foo[F[_]](fi: F[Int])).
         //
         // Are they reasonable? They cover some important cases (eg. Tuples of all
-        // arities). derives Eql is opt-in, so if the semantics don't match those
+        // arities). derives CanEqual is opt-in, so if the semantics don't match those
         // appropriate for the deriving class the author of that class can provide
         // their own instance in the normal way. That being so, the question turns
         // on whether there are enough types which fit these semantics for the
         // feature to pay its way.
 
         // Procedure:
         // We construct a two column matrix of the deriving class type parameters
-        // and the Eql type class parameters.
+        // and the CanEqual type class parameters.
         //
         // Rows: parameters of the deriving class
-        // Columns: parameters of the Eql type class (L/R)
+        // Columns: parameters of the CanEqual type class (L/R)
         //
-        // Running example: type class: class Eql[L, R], deriving class: class A[T, U, V]
+        // Running example: type class: class CanEqual[L, R], deriving class: class A[T, U, V]
         // clsParamss =
         //     T_L  T_R
         //     U_L  U_R
@@ -225,15 +225,15 @@ trait Deriving {
             tparam.copy(name = s"${tparam.name}_$$_${tcparam.name}".toTypeName)
               .asInstanceOf[TypeSymbol])
         }
-        // Retain only rows with L/R params of kind * which Eql can be applied to.
+        // Retain only rows with L/R params of kind * which CanEqual can be applied to.
         // No pairwise evidence will be required for params of other kinds.
         val firstKindedParamss = clsParamss.filter {
           case param :: _ => !param.info.isLambdaSub
           case _ => false
         }
 
         // The types of the required evidence parameters. In the running example:
-        // Eql[T_L, T_R], Eql[U_L, U_R], Eql[V_L, V_R]
+        // CanEqual[T_L, T_R], CanEqual[U_L, U_R], CanEqual[V_L, V_R]
         val evidenceParamInfos =
           for (row <- firstKindedParamss)
           yield row.map(_.typeRef)
@@ -244,12 +244,12 @@ trait Deriving {
           for (n <- List.range(0, typeClassArity))
           yield cls.typeRef.appliedTo(clsParamss.map(row => row(n).typeRef))
 
-        // Eql[A[T_L, U_L, V_L], A[T_R, U_R, V_R]]
+        // CanEqual[A[T_L, U_L, V_L], A[T_R, U_R, V_R]]
         addInstance(clsParamss.flatten, evidenceParamInfos, instanceTypes)
       }
 
       if (typeClassArity == 1) deriveSingleParameter
-      else if (typeClass == defn.EqlClass) deriveEql
+      else if (typeClass == defn.CanEqualClass) deriveCanEqual
       else if (typeClassArity == 0)
         report.error(i"type ${typeClass.name} in derives clause of ${cls.name} has no type parameters", derived.srcPos)
       else

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

@@ -883,7 +883,7 @@ trait Implicits:
               else s"parameter $paramName" } of $methodStr"
     }
 
-  /** An Eql[T, U] instance is assumed
+  /** A CanEqual[T, U] instance is assumed
    *   - if one of T, U is an error type, or
    *   - if one of T, U is a subtype of the lifted version of the other,
    *     unless strict equality is set.
@@ -913,8 +913,8 @@ trait Implicits:
   /** Check that equality tests between types `ltp` and `rtp` make sense */
   def checkCanEqual(ltp: Type, rtp: Type, span: Span)(using Context): Unit =
     if (!ctx.isAfterTyper && !assumedCanEqual(ltp, rtp)) {
-      val res = implicitArgTree(defn.EqlClass.typeRef.appliedTo(ltp, rtp), span)
-      implicits.println(i"Eql witness found for $ltp / $rtp: $res: ${res.tpe}")
+      val res = implicitArgTree(defn.CanEqualClass.typeRef.appliedTo(ltp, rtp), span)
+      implicits.println(i"CanEqual witness found for $ltp / $rtp: $res: ${res.tpe}")
     }
 
   /** Find an implicit parameter or conversion.
@@ -1047,7 +1047,7 @@ trait Implicits:
     private def nestedContext() =
       ctx.fresh.setMode(ctx.mode &~ Mode.ImplicitsEnabled)
 
-    private def isCoherent = pt.isRef(defn.EqlClass)
+    private def isCoherent = pt.isRef(defn.CanEqualClass)
 
     val wideProto = pt.widenExpr
 

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

@@ -77,27 +77,27 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
     }
   end synthesizedTypeTest
 
-  /** If `formal` is of the form Eql[T, U], try to synthesize an
-    *  `Eql.eqlAny[T, U]` as solution.
+  /** If `formal` is of the form CanEqual[T, U], try to synthesize an
+    *  `CanEqual.canEqualAny[T, U]` as solution.
     */
-  val synthesizedEql: SpecialHandler = (formal, span) =>
+  val synthesizedCanEqual: SpecialHandler = (formal, span) =>
 
-    /** Is there an `Eql[T, T]` instance, assuming -strictEquality? */
+    /** Is there an `CanEqual[T, T]` instance, assuming -strictEquality? */
     def hasEq(tp: Type)(using Context): Boolean =
-      val inst = typer.inferImplicitArg(defn.EqlClass.typeRef.appliedTo(tp, tp), span)
+      val inst = typer.inferImplicitArg(defn.CanEqualClass.typeRef.appliedTo(tp, tp), span)
       !inst.isEmpty && !inst.tpe.isError
 
-    /** Can we assume the eqlAny instance for `tp1`, `tp2`?
+    /** Can we assume the canEqualAny instance for `tp1`, `tp2`?
       *  This is the case if assumedCanEqual(tp1, tp2), or
-      *  one of `tp1`, `tp2` has a reflexive `Eql` instance.
+      *  one of `tp1`, `tp2` has a reflexive `CanEqual` instance.
       */
     def validEqAnyArgs(tp1: Type, tp2: Type)(using Context) =
       typer.assumedCanEqual(tp1, tp2)
        || withMode(Mode.StrictEquality) {
             !hasEq(tp1) && !hasEq(tp2)
           }
 
-    /** Is an `Eql[cls1, cls2]` instance assumed for predefined classes `cls1`, cls2`? */
+    /** Is an `CanEqual[cls1, cls2]` instance assumed for predefined classes `cls1`, cls2`? */
     def canComparePredefinedClasses(cls1: ClassSymbol, cls2: ClassSymbol): Boolean =
 
       def cmpWithBoxed(cls1: ClassSymbol, cls2: ClassSymbol) =
@@ -129,8 +129,8 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
         false
     end canComparePredefinedClasses
 
-    /** Some simulated `Eql` instances for predefined types. It's more efficient
-      *  to do this directly instead of setting up a lot of `Eql` instances to
+    /** Some simulated `CanEqual` instances for predefined types. It's more efficient
+      *  to do this directly instead of setting up a lot of `CanEqual` instances to
       *  interpret.
       */
     def canComparePredefined(tp1: Type, tp2: Type) =
@@ -143,10 +143,10 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
         List(arg1, arg2).foreach(fullyDefinedType(_, "eq argument", span))
         if canComparePredefined(arg1, arg2)
             || !Implicits.strictEquality && explore(validEqAnyArgs(arg1, arg2))
-        then ref(defn.Eql_eqlAny).appliedToTypes(args).withSpan(span)
+        then ref(defn.CanEqual_canEqualAny).appliedToTypes(args).withSpan(span)
         else EmptyTree
       case _ => EmptyTree
-  end synthesizedEql
+  end synthesizedCanEqual
 
   /** Creates a tree that will produce a ValueOf instance for the requested type.
    * An EmptyTree is returned if materialization fails.
@@ -363,7 +363,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
   val specialHandlers = List(
     defn.ClassTagClass        -> synthesizedClassTag,
     defn.TypeTestClass        -> synthesizedTypeTest,
-    defn.EqlClass             -> synthesizedEql,
+    defn.CanEqualClass        -> synthesizedCanEqual,
     defn.ValueOfClass         -> synthesizedValueOf,
     defn.Mirror_ProductClass  -> synthesizedProductMirror,
     defn.Mirror_SumClass      -> synthesizedSumMirror,