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

@@ -126,19 +126,19 @@ object DesugarEnums {
    *
    *   private def $new(_$ordinal: Int, $name: String) = new E with scala.runtime.EnumValue {
    *     def $ordinal = $tag
-   *     override def toString = $name
+   *     override def productPrefix = $name     // if does not derive from `java.lang.Enum`
+   *     override def productPrefix = this.name // if derives from `java.lang.Enum`
    *     $values.register(this)
    *   }
    */
   private def enumValueCreator(using Context) = {
     val ordinalDef = ordinalMeth(Ident(nme.ordinalDollar_))
-    val toStringDef = toStringMeth(Ident(nme.nameDollar))
     val creator = New(Template(
       constr = emptyConstructor,
       parents = enumClassRef :: scalaRuntimeDot(tpnme.EnumValue) :: Nil,
       derived = Nil,
       self = EmptyValDef,
-      body = List(ordinalDef, toStringDef) ++ registerCall
+      body = List(ordinalDef, productPrefixDynamic) ++ registerCall
     ).withAttachment(ExtendsSingletonMirror, ()))
     DefDef(nme.DOLLAR_NEW, Nil,
         List(List(param(nme.ordinalDollar_, defn.IntType), param(nme.nameDollar, defn.StringType))),
@@ -267,14 +267,22 @@ object DesugarEnums {
   def ordinalMeth(body: Tree)(using Context): DefDef =
     DefDef(nme.ordinalDollar, 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)))
+
+  def productPrefixDynamic(using Context): DefDef =
+    val body =
+      if ctx.owner.linkedClass.derivesFrom(defn.JavaEnumClass) then
+        Select(This(Ident(tpnme.EMPTY)), nme.name)
+      else
+        Ident(nme.nameDollar)
+    productPrefixMeth(body)
 
   /** Expand a module definition representing a parameterless enum case */
   def expandEnumModule(name: TermName, impl: Template, mods: Modifiers, span: Span)(using Context): Tree = {
@@ -285,10 +293,10 @@ object DesugarEnums {
     else {
       val (tag, scaffolding) = nextOrdinal(CaseKind.Object)
       val ordinalDef = ordinalMethLit(tag)
-      val toStringDef = toStringMethLit(name.toString)
+      val productPrefixDef = productPrefixLit(name.toString)
       val impl1 = cpy.Template(impl)(
         parents = impl.parents :+ scalaRuntimeDot(tpnme.EnumValue),
-        body = List(ordinalDef, toStringDef) ++ registerCall)
+        body = List(ordinalDef, productPrefixDef) ++ 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/Definitions.scala

@@ -651,6 +651,7 @@ class Definitions {
     @tu lazy val Enum_ordinal: Symbol = EnumClass.requiredMethod(nme.ordinal)
 
   @tu lazy val EnumValuesClass: ClassSymbol = requiredClass("scala.runtime.EnumValues")
+  @tu lazy val EnumValueClass: ClassSymbol = requiredClass("scala.runtime.EnumValue")
   @tu lazy val ProductClass: ClassSymbol = requiredClass("scala.Product")
     @tu lazy val Product_canEqual          : Symbol = ProductClass.requiredMethod(nme.canEqual_)
     @tu lazy val Product_productArity      : Symbol = ProductClass.requiredMethod(nme.productArity)

compiler/src/dotty/tools/dotc/transform/CompleteJavaEnums.scala

@@ -117,13 +117,18 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
    *       class $anon extends E(...) {
    *          ...
    *          def ordinal = N
-   *          def toString = S
+   *          def productPrefix = this.name // if a simple enum case
+   *          def productPrefix = "S"       // if a value enum case
    *          ...
    *       }
    *
    *     After the transform it is expanded to
    *
-   *       class $anon extends E(..., N, S) {
+   *       class $anon extends E(..., N, "S") { // for value enum cases
+   *         "same as before"
+   *       }
+   *
+   *       class $anon extends E(..., N, $name) { // for simple enum cases, where `$name` comes from the `$new` method
    *         "same as before"
    *       }
    */
@@ -144,7 +149,12 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
         templ.body.collect {
           case mdef: DefDef if mdef.name == name => mdef.rhs
         }.head
-      val args = List(rhsOf(nme.toString_), rhsOf(nme.ordinalDollar))
+      def nameArg =
+        if cls.owner.name eq nme.DOLLAR_NEW then // productPrefix calls .name so we need to find the argument from $new
+          ref(cls.owner.paramSymss.flatten.find(p => p.isTerm && p.name == nme.nameDollar).map(_.termRef).get)
+        else
+          rhsOf(nme.productPrefix)
+      val args = List(nameArg, rhsOf(nme.ordinalDollar))
       cpy.Template(templ)(
         parents = addEnumConstrArgs(cls.owner.owner.linkedClass, templ.parents, args))
     }

compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala

@@ -58,6 +58,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
   private var myCaseSymbols: List[Symbol] = Nil
   private var myCaseModuleSymbols: List[Symbol] = Nil
   private var myEnumCaseSymbols: List[Symbol] = Nil
+  private var myEnumValueSymbols: List[Symbol] = Nil
 
   private def initSymbols(using Context) =
     if (myValueSymbols.isEmpty) {
@@ -67,12 +68,14 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
         defn.Product_productElementName)
       myCaseModuleSymbols = myCaseSymbols.filter(_ ne defn.Any_equals)
       myEnumCaseSymbols = List(defn.Enum_ordinal)
+      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 enumCaseSymbols(using Context): List[Symbol] = { initSymbols; myEnumCaseSymbols }
+  def enumValueSymbols(using Context): List[Symbol] = { initSymbols; myEnumValueSymbols }
 
   private def existingDef(sym: Symbol, clazz: ClassSymbol)(using Context): Symbol = {
     val existing = sym.matchingMember(clazz.thisType)
@@ -92,13 +95,15 @@ 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 isEnumValue = isEnumCase && clazz.derivesFrom(defn.EnumValueClass)
+    val isNonJavaEnumValue = isEnumValue && !clazz.derivesFrom(defn.JavaEnumClass)
 
     val symbolsToSynthesize: List[Symbol] =
       if (clazz.is(Case))
         if (clazz.is(Module)) caseModuleSymbols
         else if (isEnumCase) caseSymbols ++ enumCaseSymbols
         else caseSymbols
-      else if (isEnumCase) enumCaseSymbols
+      else if (isEnumCase) enumCaseSymbols ++ (if isNonJavaEnumValue then enumValueSymbols else Nil)
       else if (isDerivedValueClass(clazz)) valueSymbols
       else Nil
 
@@ -118,10 +123,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,45 @@
+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)
+
+@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}")