Use CanEqual as an alias of Eql

odersky · odersky · commit 51dee4be2199 · 2020-11-23T12:18:44.000+01:00
diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -71,7 +71,7 @@ import collection.mutable.ListBuffer
  */
 object Denotations {
 
-  implicit def eqDenotation: Eql[Denotation, Denotation] = Eql.derived
+  implicit def eqDenotation: CanEqual[Denotation, Denotation] = CanEqual.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.
diff --git a/compiler/src/dotty/tools/dotc/core/Names.scala b/compiler/src/dotty/tools/dotc/core/Names.scala
@@ -32,7 +32,7 @@ object Names {
    *  in a name table. A derived term name adds a tag, and possibly a number
    *  or a further simple name to some other name.
    */
-  abstract class Name extends Designator, Showable derives Eql {
+  abstract class Name extends Designator, Showable derives CanEqual {
 
     /** A type for names of the same kind as this name */
     type ThisName <: Name
diff --git a/compiler/src/dotty/tools/dotc/core/Symbols.scala b/compiler/src/dotty/tools/dotc/core/Symbols.scala
@@ -37,7 +37,7 @@ import config.Printers.typr
 
 object Symbols {
 
-  implicit def eqSymbol: Eql[Symbol, Symbol] = Eql.derived
+  implicit def eqSymbol: CanEqual[Symbol, Symbol] = CanEqual.derived
 
   /** Tree attachment containing the identifiers in a tree as a sorted array */
   val Ids: Property.Key[Array[String]] = new Property.Key
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -46,7 +46,7 @@ object Types {
 
   @sharable private var nextId = 0
 
-  implicit def eqType: Eql[Type, Type] = Eql.derived
+  implicit def eqType: CanEqual[Type, Type] = CanEqual.derived
 
   /** Main class representing types.
    *
diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Language.scala b/compiler/src/dotty/tools/dotc/semanticdb/Language.scala
@@ -2,7 +2,7 @@ package dotty.tools.dotc.semanticdb
 
 import dotty.tools.dotc.semanticdb.internal._
 
-sealed trait Language(val value: Int) extends SemanticdbEnum derives Eql
+sealed trait Language(val value: Int) extends SemanticdbEnum derives CanEqual
 
 object Language {
 
diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Range.scala b/compiler/src/dotty/tools/dotc/semanticdb/Range.scala
@@ -12,7 +12,7 @@ final case class Range(
   startCharacter: Int,
   endLine: Int,
   endCharacter: Int
-) extends SemanticdbMessage[Range] derives Eql {
+) extends SemanticdbMessage[Range] derives CanEqual {
   @sharable
   private var __serializedSizeCachedValue: Int = 0
   private def __computeSerializedValue(): Int = {
diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala
@@ -25,7 +25,7 @@ object Scala3:
 
   private val WILDCARDTypeName = nme.WILDCARD.toTypeName
 
-  enum SymbolKind derives Eql:
+  enum SymbolKind derives CanEqual:
     kind =>
 
     case Val, Var, Setter, Abstract
diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala b/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala
@@ -2,7 +2,7 @@ package dotty.tools.dotc.semanticdb
 
 import dotty.tools.dotc.semanticdb.internal._
 
-sealed trait Schema(val value: Int) extends SemanticdbEnum derives Eql
+sealed trait Schema(val value: Int) extends SemanticdbEnum derives CanEqual
 
 object Schema {
 
diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala b/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala
@@ -7,7 +7,7 @@ object SymbolInformation {
 
   val defaultInstance = SymbolInformation("", Language.UNKNOWN_LANGUAGE, SymbolInformation.Kind.UNKNOWN_KIND, 0, "")
 
-  sealed trait Kind(val value: Int) extends SemanticdbEnum derives Eql {
+  sealed trait Kind(val value: Int) extends SemanticdbEnum derives CanEqual {
     def isUnknownKind: Boolean = this == Kind.UNKNOWN_KIND
     def isLocal: Boolean = this == Kind.LOCAL
     def isField: Boolean = this == Kind.FIELD
@@ -67,7 +67,7 @@ object SymbolInformation {
     }
   }
 
-  sealed trait Property(val value: Int) extends SemanticdbEnum derives Eql {
+  sealed trait Property(val value: Int) extends SemanticdbEnum derives CanEqual {
     def isUnknownProperty: Boolean = this == Property.UNKNOWN_PROPERTY
     def isAbstract: Boolean = this == Property.ABSTRACT
     def isFinal: Boolean = this == Property.FINAL
@@ -131,7 +131,7 @@ final case class SymbolInformation(
   kind: SymbolInformation.Kind,
   properties: Int,
   displayName: String
-) extends SemanticdbMessage[SymbolInformation] derives Eql {
+) extends SemanticdbMessage[SymbolInformation] derives CanEqual {
     @sharable
     private var __serializedSizeCachedValue: Int = 0
     private def __computeSerializedValue(): Int = {
diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala b/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala
@@ -5,7 +5,7 @@ import scala.annotation.internal.sharable
 
 object SymbolOccurrence {
 
-  sealed trait Role(val value: Int) extends SemanticdbEnum derives Eql {
+  sealed trait Role(val value: Int) extends SemanticdbEnum derives CanEqual {
     def isDefinition: Boolean = this == Role.DEFINITION
     def isReference: Boolean = this == Role.REFERENCE
   }
@@ -33,7 +33,7 @@ final case class SymbolOccurrence(
   symbol: String,
   range: Option[Range],
   role: SymbolOccurrence.Role
-) extends SemanticdbMessage[SymbolOccurrence] derives Eql {
+) extends SemanticdbMessage[SymbolOccurrence] derives CanEqual {
   @sharable
   private var __serializedSizeCachedValue: Int = 0
   private def __computeSerializedValue(): Int = {
diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala b/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala
@@ -15,7 +15,7 @@ final case class TextDocument(
   md5: String,
   symbols: Seq[SymbolInformation],
   occurrences: Seq[SymbolOccurrence]
-) extends SemanticdbMessage[TextDocument] derives Eql {
+) extends SemanticdbMessage[TextDocument] derives CanEqual {
   @sharable
   private var __serializedSizeCachedValue: Int = 0
   private def __computeSerializedValue(): Int = {
diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala b/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala
@@ -12,7 +12,7 @@ object TextDocuments {
   }
   val defaultInstance: TextDocuments = TextDocuments(Nil)
 }
-final case class TextDocuments(documents: Seq[TextDocument]) extends SemanticdbMessage[TextDocuments] derives Eql {
+final case class TextDocuments(documents: Seq[TextDocument]) extends SemanticdbMessage[TextDocuments] derives CanEqual {
   @sharable
   private var __serializedSizeCachedValue: Int = 0
   private def __computeSerializedValue(): Int = {
diff --git a/compiler/src/dotty/tools/dotc/util/SourceFile.scala b/compiler/src/dotty/tools/dotc/util/SourceFile.scala
@@ -183,7 +183,7 @@ class SourceFile(val file: AbstractFile, computeContent: => Array[Char]) extends
   override def toString: String = file.toString
 }
 object SourceFile {
-  implicit def eqSource: Eql[SourceFile, SourceFile] = Eql.derived
+  implicit def eqSource: CanEqual[SourceFile, SourceFile] = CanEqual.derived
 
   implicit def fromContext(using Context): SourceFile = ctx.source
 
diff --git a/library/src/scala/Eql.scala b/library/src/scala/Eql.scala
@@ -7,6 +7,10 @@ import scala.collection.{Seq, Set}
 @implicitNotFound("Values of types ${L} and ${R} cannot be compared with == or !=")
 sealed trait Eql[-L, -R]
 
+type CanEqual[L, R] = Eql[L, R]
+
+lazy val CanEqual = Eql
+
 /** Companion object containing a few universally known `Eql` instances.
  *  Eql instances involving primitive types or the Null type are handled directly in
  *  the compiler (see Implicits.synthesizedEql), so they are not included here.
diff --git a/tests/neg/EqualityStrawman1.scala b/tests/neg/EqualityStrawman1.scala
@@ -3,13 +3,13 @@ import annotation.implicitNotFound
 
 object EqualityStrawman1 {
 
-  trait Eql[-T]
+  trait CanEqual[-T]
 
   @implicitNotFound("cannot compare value of type ${T} with a value outside its equality class")
   trait Impossible[T]
 
-  object Eql {
-    object derived extends Eql[Any]
+  object CanEqual {
+    object derived extends CanEqual[Any]
   }
 
   trait Base {
@@ -18,7 +18,7 @@ object EqualityStrawman1 {
   }
 
   trait CondEquals extends Base {
-    def === [T >: this.type <: CondEquals](other: T)(implicit ce: Eql[T]): Boolean = this.equals(other)
+    def === [T >: this.type <: CondEquals](other: T)(implicit ce: CanEqual[T]): Boolean = this.equals(other)
     def === [T](other: T)(implicit ce: Impossible[T]): Boolean = ???
   }
 
@@ -34,11 +34,11 @@ object EqualityStrawman1 {
   case class Some[+T](x: T) extends Option[T]
   case object None extends Option[Nothing]
 
-  implicit def eqStr: Eql[Str] = Eql.derived
-  //implicit def eqNum: Eql[Num] = Eql.derived
-  implicit def eqOption[T: Eql]: Eql[Option[T]] = Eql.derived
+  implicit def eqStr: CanEqual[Str] = CanEqual.derived
+  //implicit def eqNum: CanEqual[Num] = CanEqual.derived
+  implicit def eqOption[T: CanEqual]: CanEqual[Option[T]] = CanEqual.derived
 
-  implicit def eqEq[T <: Equals[T]]: Eql[T] = Eql.derived
+  implicit def eqEq[T <: Equals[T]]: CanEqual[T] = CanEqual.derived
 
   def main(args: Array[String]): Unit = {
     val x = Str("abc")
@@ -59,7 +59,7 @@ object EqualityStrawman1 {
     None === z
 
 
-    def ddistinct[T <: Base: Eql](xs: List[T]): List[T] = xs match {
+    def ddistinct[T <: Base: CanEqual](xs: List[T]): List[T] = xs match {
       case Nil => Nil
       case x :: xs => x :: xs.filterNot(x === _)
     }
diff --git a/tests/neg/derive-eq.scala b/tests/neg/derive-eq.scala
@@ -1,21 +1,20 @@
 
-case class One() derives Eql
-case class Two() derives Eql
+case class One() derives CanEqual
+case class Two() derives CanEqual
 
-given Eql[One, Two] = Eql.derived
+given CanEqual[One, Two] = CanEqual.derived
 
-enum Lst[T] derives Eql {
+enum Lst[T] derives CanEqual {
   case Cons(x: T, xs: Lst[T])
   case Nil()
 }
 
-case class Triple[S, T, U]() derives Eql
-
+case class Triple[S, T, U]() derives CanEqual
 
 object Test extends App {
-  implicitly[Eql[Lst[Lst[One]], Lst[Lst[Two]]]]
-  implicitly[Eql[Triple[One, One, One],
-                Triple[Two, Two, Two]]]
+  implicitly[CanEqual[Lst[Lst[One]], Lst[Lst[Two]]]]
+  implicitly[CanEqual[Triple[One, One, One],
+                      Triple[Two, Two, Two]]]
 
   val x: Triple[List[One], One, Two] = ???
   val y: Triple[List[Two], One, Two] = ???
diff --git a/tests/neg/enums.scala b/tests/neg/enums.scala
@@ -35,7 +35,7 @@ enum Captured[T] {
   case Case3          extends Captured[T] // error: illegal reference to type parameter T from enum case
 }
 
-enum Option[+T] derives Eql {
+enum Option[+T] derives CanEqual {
   case Some[T](x: T) extends Option[T]
   case None
 }
diff --git a/tests/neg/eql.scala b/tests/neg/eql.scala
@@ -1,7 +1,7 @@
 object lst:
   opaque type Lst[+T] = Any
   object Lst:
-    given lstEql[T, U] as Eql[Lst[T], Lst[U]] = Eql.derived
+    given lstCanEqual[T, U] as CanEqual[Lst[T], Lst[U]] = CanEqual.derived
     val Empty: Lst[Nothing] = ???
 end lst
 
diff --git a/tests/neg/equality.scala b/tests/neg/equality.scala
@@ -10,16 +10,16 @@ object equality {
   case class Some[+T](x: T) extends Option[T]
   case object None extends Option[Nothing]
 
-  implicit def eqStr: Eql[Str, Str] = Eql.derived
-  implicit def eqNum: Eql[Num, Num] = Eql.derived
-  implicit def eqOption[T, U](implicit e: Eql[T, U]): Eql[Option[T], Option[U]] = Eql.derived
+  implicit def eqStr: CanEqual[Str, Str] = CanEqual.derived
+  implicit def eqNum: CanEqual[Num, Num] = CanEqual.derived
+  implicit def eqOption[T, U](implicit e: CanEqual[T, U]): CanEqual[Option[T], Option[U]] = CanEqual.derived
 
 /*
-  implicit def eqString: Eql[String, String] = Eql.derived
-  implicit def eqInt: Eql[Int, Int] = Eql.derived
-  implicit def eqNumber: Eql[Number, Number] = Eql.derived
-  implicit def eqIntNumber: Eql[Int, Number] = Eql.derived
-  implicit def eqNumberInt: Eql[Number, Int] = Eql.derived
+  implicit def eqString: CanEqual[String, String] = CanEqual.derived
+  implicit def eqInt: CanEqual[Int, Int] = CanEqual.derived
+  implicit def eqNumber: CanEqual[Number, Number] = CanEqual.derived
+  implicit def eqIntNumber: CanEqual[Int, Number] = CanEqual.derived
+  implicit def eqNumberInt: CanEqual[Number, Int] = CanEqual.derived
 */
   def main(args: Array[String]): Unit = {
     Some(Other(3)) == None
@@ -60,7 +60,7 @@ object equality {
     1 == null    // error
 
 
-    class Fruit derives Eql
+    class Fruit derives CanEqual
 
     class Apple extends Fruit
     class Pear extends Fruit
diff --git a/tests/neg/i3976.scala b/tests/neg/i3976.scala
@@ -1,5 +1,5 @@
 object Test {
-  enum Hoge[F[_]] derives Eql {
+  enum Hoge[F[_]] derives CanEqual {
     case A extends Hoge[List]
     case B extends Hoge[[X] =>> String]
   }
@@ -8,7 +8,7 @@ object Test {
   A == A
   A == (B: Hoge[_])
 
-  A == B // should be error: cannot be compared, needs proper type class drivation of `Eql` to get there.
+  A == B // should be error: cannot be compared, needs proper type class drivation of `CanEqual` to get there.
 
   class C
 
@@ -18,7 +18,7 @@ object Test {
 }
 
 object Test2 {
-  enum Hoge[F[G[_]]] derives Eql {
+  enum Hoge[F[G[_]]] derives CanEqual {
     case A extends Hoge[[F[_]] =>> F[Int]]
     case B extends Hoge[[F[_]] =>> F[String]]
   }
@@ -37,7 +37,7 @@ object Test2 {
 }
 
 object Test3 {
-  enum Hoge[F[G[_]]] derives Eql {
+  enum Hoge[F[G[_]]] derives CanEqual {
     case A extends Hoge[[X] =>> List]   // error: wrong kind
     case B extends Hoge[[X] =>> [Y] =>> String]  // error: wrong kind
   }
diff --git a/tests/neg/i4470b.scala b/tests/neg/i4470b.scala
@@ -1,10 +1,10 @@
 object RepeatedExtendEnum {
 
-  enum Maybe[T] derives Eql { // error
+  enum Maybe[T] derives CanEqual { // error
     case Foo extends Maybe[Int]
   }
 
-  enum Maybe[T] derives Eql { // error
+  enum Maybe[T] derives CanEqual { // error
     case Foo extends Maybe[Int]
   }
 }
diff --git a/tests/neg/i5546.scala b/tests/neg/i5546.scala
@@ -8,11 +8,11 @@ object O {
     val m: Meters = 1.0
     assert(m == 1.0)   // OK
   }
-  implicit def eqM: Eql[Meters, Meters] = Eql.derived
+  implicit def eqM: CanEqual[Meters, Meters] = CanEqual.derived
 
   opaque type Feet = Double
   object Feet { def apply(d: Double): Feet = d }
-  implicit def eqF: Eql[Feet, Feet] = Eql.derived
+  implicit def eqF: CanEqual[Feet, Feet] = CanEqual.derived
 
 }
 object Test {
diff --git a/tests/pending/neg/EqualityStrawman2.scala b/tests/pending/neg/EqualityStrawman2.scala
diff --git a/tests/pos/derive-eq.scala b/tests/pos/derive-eq.scala
diff --git a/tests/pos/multiversal.scala b/tests/pos/multiversal.scala
diff --git a/tests/run/i7287/Enum_1.scala b/tests/run/i7287/Enum_1.scala
diff --git a/tests/sjs-junit/test/org/scalajs/testsuite/compiler/EnumTestScala3.scala b/tests/sjs-junit/test/org/scalajs/testsuite/compiler/EnumTestScala3.scala

Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ object Types {`
`46`	`46`
`47`	`47`	`@sharable private var nextId = 0`
`48`	`48`
`49`		`- implicit def eqType: Eql[Type, Type] = Eql.derived`
	`49`	`+ implicit def eqType: CanEqual[Type, Type] = CanEqual.derived`
`50`	`50`
`51`	`51`	`/** Main class representing types.`
`52`	`52`	`*`