fix #7227: allow custom toString on enum

productPrefix is now overriden using the enum constant's name and
used in the by-name lookup in EnumValues.

java based enum values are optimised so that productPrefix will
forward to .name in the simple enum case, avoiding an extra field

Author: bishabosha

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

@@ -125,18 +125,21 @@ 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 with scala.runtime.EnumValue {
-   *     def ordinal = _$ordinal       // if `E` does not derive from jl.Enum
-   *     override def toString = $name // if `E` does not derive from jl.Enum
+   *     def ordinal = _$ordinal                // if `E` does not derive from jl.Enum
+   *     override def productPrefix = $name     // if `E` does not derive from `java.lang.Enum`
+   *     override def productPrefix = this.name // if `E` derives from `java.lang.Enum`
    *     $values.register(this)
    *   }
    */
   private def enumValueCreator(using Context) = {
     val fieldMethods =
-        if isJavaEnum then Nil
-        else
-          val ordinalDef  = ordinalMeth(Ident(nme.ordinalDollar_))
-          val toStringDef = toStringMeth(Ident(nme.nameDollar))
-          List(ordinalDef, toStringDef)
+      if isJavaEnum then
+        val productPrefixDef = productPrefixMeth(Select(This(Ident(tpnme.EMPTY)), nme.name))
+        productPrefixDef :: Nil
+      else
+        val ordinalDef       = ordinalMeth(Ident(nme.ordinalDollar_))
+        val productPrefixDef = productPrefixMeth(Ident(nme.nameDollar))
+        ordinalDef :: productPrefixDef :: Nil
     val creator = New(Template(
       constr = emptyConstructor,
       parents = enumClassRef :: scalaRuntimeDot(tpnme.EnumValue) :: Nil,
@@ -273,14 +276,14 @@ object DesugarEnums {
   def ordinalMeth(body: Tree)(using Context): DefDef =
     DefDef(nme.ordinal, Nil, Nil, TypeTree(defn.IntType), body)
 
-  def toStringMeth(body: Tree)(using Context): DefDef =
-    DefDef(nme.toString_, Nil, Nil, TypeTree(defn.StringType), body).withFlags(Override)
+  def productPrefixMeth(body: Tree)(using Context): DefDef =
+    DefDef(nme.productPrefix, Nil, Nil, TypeTree(defn.StringType), body).withFlags(Override)
 
   def ordinalMethLit(ord: Int)(using Context): DefDef =
     ordinalMeth(Literal(Constant(ord)))
 
-  def toStringMethLit(name: String)(using Context): DefDef =
-    toStringMeth(Literal(Constant(name)))
+  def productPrefixLit(name: String)(using Context): DefDef =
+    productPrefixMeth(Literal(Constant(name)))
 
   /** Expand a module definition representing a parameterless enum case */
   def expandEnumModule(name: TermName, impl: Template, mods: Modifiers, span: Span)(using Context): Tree = {
@@ -290,15 +293,11 @@ object DesugarEnums {
       expandSimpleEnumCase(name, mods, span)
     else {
       val (tag, scaffolding) = nextOrdinal(CaseKind.Object)
-      val fieldMethods =
-        if isJavaEnum then Nil
-        else
-          val ordinalDef  = ordinalMethLit(tag)
-          val toStringDef = toStringMethLit(name.toString)
-          List(ordinalDef, toStringDef)
+      val productPrefixDef   = productPrefixLit(name.toString)
+      val ordinalDef         = if isJavaEnum then Nil else ordinalMethLit(tag) :: Nil
       val impl1 = cpy.Template(impl)(
         parents = impl.parents :+ scalaRuntimeDot(tpnme.EnumValue),
-        body = fieldMethods ::: registerCall :: Nil)
+        body = ordinalDef ::: productPrefixDef :: registerCall :: Nil)
         .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/transform/SyntheticMembers.scala

@@ -57,6 +57,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
   private var myValueSymbols: List[Symbol] = Nil
   private var myCaseSymbols: List[Symbol] = Nil
   private var myCaseModuleSymbols: List[Symbol] = Nil
+  private var myEnumValueSymbols: List[Symbol] = Nil
 
   private def initSymbols(using Context) =
     if (myValueSymbols.isEmpty) {
@@ -65,11 +66,13 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
         defn.Product_productArity, defn.Product_productPrefix, defn.Product_productElement,
         defn.Product_productElementName)
       myCaseModuleSymbols = myCaseSymbols.filter(_ ne defn.Any_equals)
+      myEnumValueSymbols = List(defn.Any_toString)
     }
 
   def valueSymbols(using Context): List[Symbol] = { initSymbols; myValueSymbols }
   def caseSymbols(using Context): List[Symbol] = { initSymbols; myCaseSymbols }
   def caseModuleSymbols(using Context): List[Symbol] = { initSymbols; myCaseModuleSymbols }
+  def enumValueSymbols(using Context): List[Symbol] = { initSymbols; myEnumValueSymbols }
 
   private def existingDef(sym: Symbol, clazz: ClassSymbol)(using Context): Symbol = {
     val existing = sym.matchingMember(clazz.thisType)
@@ -89,11 +92,17 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
       if (isDerivedValueClass(clazz)) clazz.paramAccessors.take(1) // Tail parameters can only be `erased`
       else clazz.caseAccessors
     val isEnumCase = clazz.derivesFrom(defn.EnumClass) && clazz != defn.EnumClass
+    val isNonJavaEnumValue =
+      isEnumCase
+      && clazz.isAnonymousClass
+      && clazz.classParents.head.classSymbol.is(Enum)
+      && !clazz.derivesFrom(defn.JavaEnumClass)
 
     val symbolsToSynthesize: List[Symbol] =
       if (clazz.is(Case))
         if (clazz.is(Module)) caseModuleSymbols
         else caseSymbols
+      else if (isNonJavaEnumValue) enumValueSymbols
       else if (isDerivedValueClass(clazz)) valueSymbols
       else Nil
 
@@ -113,10 +122,18 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
       def ownName: Tree =
         Literal(Constant(clazz.name.stripModuleClassSuffix.toString))
 
+      def callProductPrefix: Tree =
+        Select(This(clazz), nme.productPrefix).ensureApplied
+
+      def toStringBody(vrefss: List[List[Tree]]): Tree =
+        if (clazz.is(ModuleClass)) ownName
+        else if (isNonJavaEnumValue) callProductPrefix
+        else forwardToRuntime(vrefss.head)
+
       def syntheticRHS(vrefss: List[List[Tree]])(using Context): Tree = synthetic.name match {
         case nme.hashCode_ if isDerivedValueClass(clazz) => valueHashCodeBody
         case nme.hashCode_ => chooseHashcode
-        case nme.toString_ => if (clazz.is(ModuleClass)) ownName else forwardToRuntime(vrefss.head)
+        case nme.toString_ => toStringBody(vrefss)
         case nme.equals_ => equalsBody(vrefss.head.head)
         case nme.canEqual_ => canEqualBody(vrefss.head.head)
         case nme.productArity => Literal(Constant(accessors.length))

library/src/scala/runtime/EnumValues.scala

@@ -14,7 +14,8 @@ class EnumValues[E <: Enum] {
 
   def fromInt: Map[Int, E] = myMap
   def fromName: Map[String, E] = {
-    if (fromNameCache == null) fromNameCache = myMap.values.map(v => v.toString -> v).toMap
+    // TODO remove cast when scala.Enum is bootstrapped
+    if (fromNameCache == null) fromNameCache = myMap.values.map(v => v.asInstanceOf[Product].productPrefix -> v).toMap
     fromNameCache
   }
   def values: Iterable[E] = myMap.values

tests/run/enum-custom-toString.scala

@@ -0,0 +1,58 @@
+enum ES:
+  case A
+  override def toString: String = "overridden"
+
+enum EJ extends java.lang.Enum[EJ]:
+  case B
+  override def toString: String = "overridden"
+
+trait Mixin:
+  override def toString: String = "overridden"
+
+enum EM extends Mixin:
+  case C
+
+enum ET[T] extends java.lang.Enum[ET[_]]:
+  case D extends ET[Unit]
+  override def toString: String = "overridden"
+
+enum EZ:
+  case E(arg: Int)
+  override def toString: String = "overridden"
+
+enum EC: // control case
+  case F
+  case G(arg: Int)
+
+abstract class Tag[T] extends Enum
+object Tag:
+  private final class IntTagImpl extends Tag[Int] with runtime.EnumValue:
+    def ordinal = 0
+    override def hashCode = 123
+  final val IntTag: Tag[Int] = IntTagImpl()
+
+@main def Test =
+  assert(ES.A.toString == "overridden",    s"ES.A.toString = ${ES.A.toString}")
+  assert(ES.A.productPrefix == "A",        s"ES.A.productPrefix = ${ES.A.productPrefix}")
+  assert(ES.valueOf("A") == ES.A,          s"ES.valueOf(A) = ${ES.valueOf("A")}")
+  assert(EJ.B.toString == "overridden",    s"EJ.B.toString = ${EJ.B.toString}")
+  assert(EJ.B.productPrefix == "B",        s"EJ.B.productPrefix = ${EJ.B.productPrefix}")
+  assert(EJ.valueOf("B") == EJ.B,          s"EJ.valueOf(B) = ${EJ.valueOf("B")}")
+  assert(EM.C.toString == "overridden",    s"EM.C.toString = ${EM.C.toString}")
+  assert(EM.C.productPrefix == "C",        s"EM.C.productPrefix = ${EM.C.productPrefix}")
+  assert(EM.valueOf("C") == EM.C,          s"EM.valueOf(C) = ${EM.valueOf("C")}")
+  assert(ET.D.toString == "overridden",    s"ET.D.toString = ${ET.D.toString}")
+  assert(ET.D.productPrefix == "D",        s"ET.D.productPrefix = ${ET.D.productPrefix}")
+  assert(EZ.E(0).toString == "overridden", s"EZ.E(0).toString = ${EZ.E(0).toString}")
+  assert(EZ.E(0).productPrefix == "E",     s"EZ.E(0).productPrefix = ${EZ.E(0).productPrefix}")
+  assert(EC.F.toString == "F",             s"EC.F.toString = ${EC.F.toString}")
+  assert(EC.F.productPrefix == "F",        s"EC.F.productPrefix = ${EC.F.productPrefix}")
+  assert(EC.valueOf("F") == EC.F,          s"EC.valueOf(F) = ${EC.valueOf("F")}")
+  assert(EC.G(0).toString == "G(0)",       s"EC.G(0).toString = ${EC.G(0).toString}")
+  assert(EC.G(0).productPrefix == "G",     s"EC.G(0).productPrefix = ${EC.G(0).productPrefix}")
+
+  assert(
+    assertion = Tag.IntTag.toString == s"${Tag.IntTag.getClass.getName}@${Integer.toHexString(123)}",
+    message   = s"Tag.IntTag.toString = ${Tag.IntTag.toString}"
+  )
+  assert(Tag.IntTag.productPrefix == Tag.IntTag.toString, s"Tag.IntTag.productPrefix = ${Tag.IntTag.productPrefix}")