Merge EqClassOf and EqClass

Keep just one: EqClass, which is parameterized, like EqClassOf was.
Unparameterized EqClass can be expressed as EqClass[_].

Author: odersky

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

@@ -56,10 +56,19 @@ class Definitions {
   private def newSyntheticTypeParam(cls: ClassSymbol, scope: MutableScope, paramFlags: FlagSet, suffix: String = "T0") =
     newTypeParam(cls, suffix.toTypeName.expandedName(cls), ExpandedName | paramFlags, scope)
 
-  // NOTE: Ideally we would write `parentConstrs: => Type*` but SIP-24 is only
-  // implemented in Dotty and not in Scala 2.
-  // See <http://docs.scala-lang.org/sips/pending/repeated-byname.html>.
-  private def specialPolyClass(name: TypeName, paramFlags: FlagSet, parentConstrs: => Seq[Type]): ClassSymbol = {
+  /** A class following the template
+   *
+   *      package scala
+   *      class <name>[<paramFlags> $T0] extends <parents>
+   *
+   *  where <parents> = [constr' | constr <- parentConstrs]
+   *        <constr'> = constr[$T0]     of <constr> has a type parameter
+   *                  = constr          otherwise
+   */
+  private def specialPolyClass(name: TypeName, classFlags: FlagSet, paramFlags: FlagSet, parentConstrs: => Seq[Type]): ClassSymbol = {
+    // NOTE: Ideally we would write `parentConstrs: => Type*` but SIP-24 is only
+    // implemented in Dotty and not in Scala 2.
+    // See <http://docs.scala-lang.org/sips/pending/repeated-byname.html>.
     val completer = new LazyType {
       def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
         val cls = denot.asClass.classSymbol
@@ -73,7 +82,7 @@ class Definitions {
         denot.info = ClassInfo(ScalaPackageClass.thisType, cls, parentRefs, paramDecls)
       }
     }
-    newClassSymbol(ScalaPackageClass, name, EmptyFlags, completer)
+    newClassSymbol(ScalaPackageClass, name, classFlags, completer)
   }
 
   private def newMethod(cls: ClassSymbol, name: TermName, info: Type, flags: FlagSet = EmptyFlags): TermSymbol =
@@ -204,8 +213,8 @@ class Definitions {
    *
    *    trait EqClass {
    *      /** Comparison operations between values in the same equality class */
-   *      final def == [T >: this.type <: EqClass](other: T)(implicit ce: Eq[T]): Boolean = this.equals(other)
-   *      final def != [T >: this.type <: EqClass](other: T)(implicit ce: Eq[T]): Boolean = this.equals(other)
+   *      final def == [T >: this.type <: EqClass[_](other: T)(implicit ce: Eq[T]): Boolean = this.equals(other)
+   *      final def != [T >: this.type <: EqClass[_](other: T)(implicit ce: Eq[T]): Boolean = this.equals(other)
    *    }
    *
    *  The reason we define this here rather than as a source file is that these definitions
@@ -215,13 +224,12 @@ class Definitions {
    *    Exception in thread "main" scala.reflect.internal.Types$NoCommonType: lub/glb of incompatible types: => core.this.Names.TypeName and scala.this.Nothing
    */
   lazy val EqClassClass: ClassSymbol = {
-    val ecc = newCompleteClassSymbol(
-      ScalaPackageClass, tpnme.EqClass, PureInterfaceCreationFlags, List(AnyClass.typeRef))
+    val ecc = specialPolyClass(tpnme.EqClass, PureInterfaceCreationFlags, Contravariant, List(AnyClass.typeRef))
     val completer = new LazyType {
       override def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
         denot.info =
           PolyType(tpnme.syntheticTypeParamNames(1))(
-            pt => List(TypeBounds(ecc.thisType, ecc.typeRef)),
+            pt => List(TypeBounds(ecc.thisType, ecc.typeRef.appliedTo(TypeBounds.empty))),
             pt => MethodType(List(PolyParam(pt, 0)),
                    ImplicitMethodType(List(EqType.appliedTo(PolyParam(pt, 0))),
                      BooleanType)))
@@ -393,10 +401,10 @@ class Definitions {
   lazy val BoxedDoubleModule  = ctx.requiredModule("java.lang.Double")
   lazy val BoxedUnitModule    = ctx.requiredModule("java.lang.Void")
 
-  lazy val ByNameParamClass2x = specialPolyClass(tpnme.BYNAME_PARAM_CLASS, Covariant, Seq(AnyType))
-  lazy val EqualsPatternClass = specialPolyClass(tpnme.EQUALS_PATTERN, EmptyFlags, Seq(AnyType))
+  lazy val ByNameParamClass2x = specialPolyClass(tpnme.BYNAME_PARAM_CLASS, EmptyFlags, Covariant, Seq(AnyType))
+  lazy val EqualsPatternClass = specialPolyClass(tpnme.EQUALS_PATTERN, EmptyFlags, EmptyFlags, Seq(AnyType))
 
-  lazy val RepeatedParamClass = specialPolyClass(tpnme.REPEATED_PARAM_CLASS, Covariant, Seq(ObjectType, SeqType))
+  lazy val RepeatedParamClass = specialPolyClass(tpnme.REPEATED_PARAM_CLASS, EmptyFlags, Covariant, Seq(ObjectType, SeqType))
 
   // fundamental classes
   lazy val StringClass                = ctx.requiredClass("java.lang.String")

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

@@ -97,7 +97,7 @@ object Denotations {
    *
    *  @param symbol  The referencing symbol, or NoSymbol is none exists
    */
-  abstract class Denotation(val symbol: Symbol) extends util.DotClass with printing.Showable with EqClassOf[Denotation] {
+  abstract class Denotation(val symbol: Symbol) extends util.DotClass with printing.Showable with EqClass[Denotation] {
 
     /** The type info of the denotation, exists only for non-overloaded denotations */
     def info(implicit ctx: Context): Type

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

@@ -35,7 +35,7 @@ object Names {
    *  3. Names are intended to be encoded strings. @see dotc.util.NameTransformer.
    *     The encoding will be applied when converting a string to a name.
    */
-  abstract class Name extends DotClass with EqClassOf[Name]
+  abstract class Name extends DotClass with EqClass[Name]
     with PreName
     with collection.immutable.Seq[Char]
     with IndexedSeqOptimized[Char, Name] {

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

@@ -365,7 +365,7 @@ object Symbols {
    *  @param coord  The coordinates of the symbol (a position or an index)
    *  @param id     A unique identifier of the symbol (unique per ContextBase)
    */
-  class Symbol private[Symbols] (val coord: Coord, val id: Int) extends DotClass with printing.Showable with EqClassOf[Symbol] {
+  class Symbol private[Symbols] (val coord: Coord, val id: Int) extends DotClass with printing.Showable with EqClass[Symbol] {
 
     type ThisName <: Name
 

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

@@ -70,7 +70,7 @@ object Types {
    *                       +- ErrorType
    *                       +- WildcardType
    */
-  abstract class Type extends DotClass with Hashable with printing.Showable with EqClassOf[Type] {
+  abstract class Type extends DotClass with Hashable with printing.Showable with EqClass[Type] {
 
 // ----- Tests -----------------------------------------------------
 

src/scala/Eq.scala

@@ -12,6 +12,6 @@ object Eq extends Eq[Any] {
   /** An implicit that provides an `Eq` instance for all types `T` that have
    *  a base type `U` such that `U <: EqClass[U]`.
    */
-  implicit def eqEq[U, T <: EqClassOf[U] with U]: Eq[T] = Eq
+  implicit def eqEq[U, T <: EqClass[U] with U]: Eq[T] = Eq
 }
 

src/scala/EqClass.scala

@@ -2,6 +2,36 @@ package scala
 
 /** A class providing a specialized notion of equality, allowing
  *  only values in the same equality class to be compared.
+ *  To be used in one of two ways:
+ *
+ *  1st way: When defining a class or trait `C`, simply write:
+ *
+ *     class C extends ... EqClass[T]
+ *
+ *  This makes `C` the root of a separate equality class. Any subtype
+ *  of `C` can then be compared with any other subtype of `C`, but it cannot
+ *  be compared with types that are not subtypes of `C`.
+ *
+ *  2nd way: Define `C` like this
+ *
+ *     class C extends ... EqClass[_]
+ *
+ *   or, equivalently:
+ *
+ *     class C extends ... EqClass[Nothing]
+ *
+ *  This creates a new equality class for `C`, but makes subtypes of `C` not automatically
+ *  comparable with other subtypes of `C`. Instead, the rules of what is comparable to what can
+ *  be encoded by giving `Eq` implicits in the companion object of `C`. Here is an example
+ *  that makes `Optional` values only be comparable if their element types are comparable:
+ *
+ *      trait Optional[+T] extends EqClass[_]
+ *      case class Some[+T](x: T) extends Optional[T]
+ *      case object None extends Optional[T]
+ *
+ *      object Optional {
+ *        def optEq[T](implicit ee: Eq[T]): Eq[Optional[T]] = Eq
+ *      }
  */
-trait EqClass extends Any
+trait EqClass[-T] extends Any
 

src/scala/EqClassOf.scala

@@ -3,7 +3,7 @@ object equality {
 
   case class Str(str: String) extends EqClass
 
-  case class Num(x: Int) extends EqClassOf[Num]
+  case class Num(x: Int) extends EqClass[Num]
 
   case class Other(x: Int)
 

tests/neg/equality-posttyper.scala

@@ -3,7 +3,7 @@ object equality {
 
   case class Str(str: String) extends EqClass
 
-  case class Num(x: Int) extends EqClassOf[Num]
+  case class Num(x: Int) extends EqClass[Num]
 
   case class Other(x: Int)