Drop generation of Eq instances for enums

Treat Eq like any other derivable typeclass. This caused
a bit of changes in fuzzing tests.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -537,45 +537,6 @@ object desugar {
     if (isEnum)
       parents1 = parents1 :+ ref(defn.EnumType)
 
-    // The Eq instance for an Enum class. For an enum class
-    //
-    //    enum class C[T1, ..., Tn]
-    //
-    // we generate:
-    //
-    //    implicit def eqInstance[T1$1, ..., Tn$1, T1$2, ..., Tn$2](implicit
-    //      ev1: Eq[T1$1, T1$2], ..., evn: Eq[Tn$1, Tn$2]])
-    //      : Eq[C[T1$, ..., Tn$1], C[T1$2, ..., Tn$2]] = Eq
-    //
-    // Higher-kinded type arguments `Ti` are omitted as evidence parameters.
-    //
-    // FIXME: This is too simplistic. Instead of just generating evidence arguments
-    // for every first-kinded type parameter, we should look instead at the
-    // actual types occurring in cases and derive parameters from these. E.g. in
-    //
-    //    enum HK[F[_]] {
-    //      case C1(x: F[Int]) extends HK[F[Int]]
-    //      case C2(y: F[String]) extends HL[F[Int]]
-    //
-    // we would need evidence parameters for `F[Int]` and `F[String]`
-    // We should generate Eq instances with the techniques
-    // of typeclass derivation once that is available.
-    def eqInstance = {
-      val leftParams = constrTparams.map(derivedTypeParam(_, "$1"))
-      val rightParams = constrTparams.map(derivedTypeParam(_, "$2"))
-      val subInstances =
-        for ((param1, param2) <- leftParams `zip` rightParams if !isHK(param1))
-        yield appliedRef(ref(defn.EqType), List(param1, param2), widenHK = true)
-      DefDef(
-          name = nme.eqInstance,
-          tparams = leftParams ++ rightParams,
-          vparamss = if (subInstances.isEmpty) Nil else List(makeImplicitParameters(subInstances)),
-          tpt = appliedTypeTree(ref(defn.EqType),
-              appliedRef(classTycon, leftParams) :: appliedRef(classTycon, rightParams) :: Nil),
-          rhs = ref(defn.EqModule.termRef)).withFlags(Synthetic | Implicit)
-    }
-    def eqInstances = if (isEnum) eqInstance :: Nil else Nil
-
     // derived type classes of non-module classes go to their companions
     val (clsDerived, companionDerived) =
       if (mods.is(Module)) (impl.derived, Nil) else (Nil, impl.derived)
@@ -594,7 +555,7 @@ object desugar {
       mdefs
     }
 
-    val companionMembers = defaultGetters ::: eqInstances ::: enumCases
+    val companionMembers = defaultGetters ::: enumCases
 
     // The companion object definitions, if a companion is needed, Nil otherwise.
     // companion definitions include:
@@ -644,7 +605,7 @@ object desugar {
         }
         companionDefs(companionParent, applyMeths ::: unapplyMeth :: companionMembers)
       }
-      else if (companionMembers.nonEmpty || companionDerived.nonEmpty)
+      else if (companionMembers.nonEmpty || companionDerived.nonEmpty || isEnum)
         companionDefs(anyRef, companionMembers)
       else if (isValueClass) {
         impl.constr.vparamss match {

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

@@ -1029,7 +1029,7 @@ class Namer { typer: Typer =>
 
       if (impl.derived.nonEmpty) {
         val (derivingClass, derivePos) = original.removeAttachment(desugar.DerivingCompanion) match {
-          case Some(pos) => (cls.companionClass.asClass, pos)
+          case Some(pos) => (cls.companionClass.orElse(cls).asClass, pos)
           case None => (cls, impl.sourcePos.startPos)
         }
         val deriver = new Deriver(derivingClass, derivePos)(localCtx)

tests/neg/derive-eq.scala

@@ -13,7 +13,6 @@ case class Triple[S, T, U] derives Eq
 
 
 object Test extends App {
-  Test1
   implicitly[Eq[Lst[Lst[One]], Lst[Lst[Two]]]]
   implicitly[Eq[Triple[One, One, One],
                 Triple[Two, Two, Two]]]

tests/neg/enums.scala

@@ -24,7 +24,7 @@ enum E4 {
 case class C4() extends E4 // error: cannot extend enum
 case object O4 extends E4 // error: cannot extend enum
 
-enum Option[+T] {
+enum Option[+T] derives Eq {
   case Some(x: T)
   case None
 }

tests/neg/i3976.scala

@@ -1,5 +1,5 @@
 object Test {
-  enum Hoge[F[_]] {
+  enum Hoge[F[_]] derives Eq {
     case A extends Hoge[List]
     case B extends Hoge[[X] => String]
   }
@@ -18,7 +18,7 @@ object Test {
 }
 
 object Test2 {
-  enum Hoge[F[G[_]]] {
+  enum Hoge[F[G[_]]] derives Eq {
     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[_]]] {
+  enum Hoge[F[G[_]]] derives Eq {
     case A extends Hoge[[X] => List]   // error: wrong kind
     case B extends Hoge[[X] => [Y] => String]  // error: wrong kind
   }

tests/neg/i4470a.scala

@@ -1,7 +1,7 @@
 object RepeatedEnum {
 
-  enum Maybe { // error // error
-    case Foo
+  enum Maybe { // error
+    case Foo   // error
   }
 
   enum Maybe { // error

tests/neg/i4470b.scala

@@ -1,10 +1,10 @@
 object RepeatedExtendEnum {
 
-  enum Maybe[T] { // error // error
+  enum Maybe[T] derives Eq { // error // error
     case Foo extends Maybe[Int]
   }
 
-  enum Maybe[T] { // error
+  enum Maybe[T] derives Eq { // error
     case Foo extends Maybe[Int]
   }
 }

tests/neg/i4470c.scala

@@ -1,6 +1,6 @@
 object DuplicatedEnum {
-  enum Maybe[+T] { // error // error
-    case Some(x: T)
+  enum Maybe[+T] { // error
+    case Some(x: T) // error
   }
 
   enum Maybe[+T] { // error

tests/run/derive-eq.scala renamed to tests/pos/derive-eq.scala

@@ -12,12 +12,12 @@ enum Lst[T] derives Eq {
 class Triple[S, T, U] derives Eq
 
 
-object Test extends App {
+object Test {
   implicitly[Eq[Lst[Lst[One]], Lst[Lst[Two]]]]
   implicitly[Eq[Triple[One, One, One],
                 Triple[Two, Two, Two]]]
 
-  val x: Triple[List[One], One, Two] = ???
-  val y: Triple[List[Two], One, Two] = ???
-  assert(x == y)
+  val x: Triple[Lst[One], One, Two] = ???
+  val y: Triple[Lst[Two], One, Two] = ???
+  x == y
 }