Fix #9011: Make single enum values inherit from Product

Author: odersky

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

@@ -124,7 +124,7 @@ object DesugarEnums {
 
   /** A creation method for a value of enum type `E`, which is defined as follows:
    *
-   *   private def $new(_$ordinal: Int, $name: String) = new E {
+   *   private def $new(_$ordinal: Int, $name: String) = new E with EnumValue {
    *     def $ordinal = $tag
    *     override def toString = $name
    *     $values.register(this)
@@ -135,7 +135,7 @@ object DesugarEnums {
     val toStringDef = toStringMeth(Ident(nme.nameDollar))
     val creator = New(Template(
       constr = emptyConstructor,
-      parents = enumClassRef :: Nil,
+      parents = enumClassRef :: scalaDot(str.EnumValue.toTypeName) :: Nil,
       derived = Nil,
       self = EmptyValDef,
       body = List(ordinalDef, toStringDef) ++ registerCall
@@ -286,7 +286,9 @@ object DesugarEnums {
       val (tag, scaffolding) = nextOrdinal(CaseKind.Object)
       val ordinalDef = ordinalMethLit(tag)
       val toStringDef = toStringMethLit(name.toString)
-      val impl1 = cpy.Template(impl)(body = List(ordinalDef, toStringDef) ++ registerCall)
+      val impl1 = cpy.Template(impl)(
+        parents = impl.parents :+ scalaDot(str.EnumValue.toTypeName),
+        body = List(ordinalDef, toStringDef) ++ registerCall)
         .withAttachment(ExtendsSingletonMirror, ())
       val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods.withAddedFlags(EnumValue, span))
       flatTree(scaffolding ::: vdef :: Nil).withSpan(span)

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

@@ -33,6 +33,7 @@ object StdNames {
 
     final val MODULE_INSTANCE_FIELD      = "MODULE$"
 
+    final val EnumValue                  = "EnumValue"
     final val Function                   = "Function"
     final val ErasedFunction             = "ErasedFunction"
     final val ContextFunction            = "ContextFunction"

library/src/scala/EnumValue.scala

@@ -0,0 +1,10 @@
+package scala
+
+trait EnumValue extends Product:
+  override def canEqual(that: Any) = true
+  override def productArity: Int = 0
+  override def productPrefix: String = toString
+  override def productElement(n: Int): Any =
+    throw IndexOutOfBoundsException(n.toString())
+  override def productElementName(n: Int): String =
+    throw IndexOutOfBoundsException(n.toString())

tests/run/i9011.scala

@@ -0,0 +1,57 @@
+enum Opt[+T] derives Eq:
+  case Sm(t: T)
+  case Nn
+
+import scala.deriving._
+import scala.compiletime.{erasedValue, summonInline}
+
+trait Eq[T] {
+  def eqv(x: T, y: T): Boolean
+}
+
+object Eq {
+  given Eq[Int] {
+    def eqv(x: Int, y: Int) = x == y
+  }
+
+  inline def summonAll[T <: Tuple]: List[Eq[_]] = inline erasedValue[T] match {
+    case _: Unit => Nil
+    case _: (t *: ts) => summonInline[Eq[t]] :: summonAll[ts]
+  }
+
+  def check(elem: Eq[_])(x: Any, y: Any): Boolean =
+    elem.asInstanceOf[Eq[Any]].eqv(x, y)
+
+  def iterator[T](p: T) = p.asInstanceOf[Product].productIterator
+
+  def eqSum[T](s: Mirror.SumOf[T], elems: List[Eq[_]]): Eq[T] =
+    new Eq[T] {
+      def eqv(x: T, y: T): Boolean = {
+        val ordx = s.ordinal(x)
+        (s.ordinal(y) == ordx) && check(elems(ordx))(x, y)
+      }
+    }
+
+  def eqProduct[T](p: Mirror.ProductOf[T], elems: List[Eq[_]]): Eq[T] =
+    new Eq[T] {
+      def eqv(x: T, y: T): Boolean =
+        iterator(x).zip(iterator(y)).zip(elems.iterator).forall {
+          case ((x, y), elem) => check(elem)(x, y)
+        }
+    }
+
+  inline given derived[T](using m: Mirror.Of[T]) as Eq[T] = {
+    val elemInstances = summonAll[m.MirroredElemTypes]
+    inline m match {
+      case s: Mirror.SumOf[T]     => eqSum(s, elemInstances)
+      case p: Mirror.ProductOf[T] => eqProduct(p, elemInstances)
+    }
+  }
+}
+
+object Test extends App {
+  import Opt._
+  val eqoi = summon[Eq[Opt[Int]]]
+  assert(eqoi.eqv(Sm(23), Sm(23)))
+  assert(eqoi.eqv(Nn, Nn))
+}