Always override enumLabel in each enum case.

As a rule, even class cases override it to be consistent with
singleton cases which must have a value matching the identifier.

this also moves runtime.EnumValues into src-bootstrapped so that
fromName can directly call .enumLabel

This commit also removes the forced override of productPrefix in
EnumValue and individial cases, this allows the user
to customise productPrefix as with typical case classes.
An override of productPrefix will be generated in SyntheticMembers
to forward to enumLabel if a class parent does not define one.

Author: bishabosha

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

@@ -586,7 +586,9 @@ object desugar {
         yield syntheticProperty(selName, caseParams(i).tpt,
           Select(This(EmptyTypeIdent), caseParams(i).name))
 
-      def ordinalMeths = if (isEnumCase) ordinalMethLit(nextOrdinal(CaseKind.Class)._1) :: Nil else Nil
+      def enumMeths =
+        if (isEnumCase) ordinalMethLit(nextOrdinal(CaseKind.Class)._1) :: enumLabelLit(className.toString) :: Nil
+        else Nil
       def copyMeths = {
         val hasRepeatedParam = constrVparamss.exists(_.exists {
           case ValDef(_, tpt, _) => isRepeated(tpt)
@@ -605,7 +607,7 @@ object desugar {
       }
 
       if (isCaseClass)
-        copyMeths ::: ordinalMeths ::: productElemMeths
+        copyMeths ::: enumMeths ::: productElemMeths
       else Nil
     }
 

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

@@ -125,9 +125,9 @@ 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 productPrefix = $name     // if `E` does not derive from `java.lang.Enum`
-   *     override def productPrefix = this.name // if `E` derives from `java.lang.Enum`
+   *     override def ordinal = _$ordinal   // if `E` does not derive from `java.lang.Enum`
+   *     override def enumLabel = $name     // if `E` does not derive from `java.lang.Enum`
+   *     override def enumLabel = this.name // if `E` derives from `java.lang.Enum`
    *     $values.register(this)
    *   }
    */
@@ -145,7 +145,7 @@ object DesugarEnums {
       parents = enumClassRef :: scalaRuntimeDot(tpnme.EnumValue) :: Nil,
       derived = Nil,
       self = EmptyValDef,
-      body = fieldMethods ::: productPrefixMeth :: registerCall :: Nil
+      body = fieldMethods ::: registerCall :: Nil
     ).withAttachment(ExtendsSingletonMirror, ()))
     DefDef(nme.DOLLAR_NEW, Nil,
         List(List(param(nme.ordinalDollar_, defn.IntType), param(nme.nameDollar, defn.StringType))),
@@ -274,16 +274,11 @@ object DesugarEnums {
   private def isJavaEnum(using Context): Boolean = ctx.owner.linkedClass.derivesFrom(defn.JavaEnumClass)
 
   def ordinalMeth(body: Tree)(using Context): DefDef =
-    DefDef(nme.ordinal, Nil, Nil, TypeTree(defn.IntType), body)
+    DefDef(nme.ordinal, Nil, Nil, TypeTree(defn.IntType), body).withFlags(Override)
 
   def enumLabelMeth(body: Tree)(using Context): DefDef =
     DefDef(nme.enumLabel, Nil, Nil, TypeTree(defn.StringType), body).withFlags(Override)
 
-  def productPrefixMeth(using Context): DefDef =
-    // TODO: once `scala.Enum` is rebootstrapped and `.valueOf` is implemented in terms of `enumLabel` we can make
-    // `productPrefix` overrideable in SyntheticMembers
-    DefDef(nme.productPrefix, Nil, Nil, TypeTree(defn.StringType), Select(This(EmptyTypeIdent), nme.enumLabel)).withFlags(Override)
-
   def ordinalMethLit(ord: Int)(using Context): DefDef =
     ordinalMeth(Literal(Constant(ord)))
 
@@ -302,7 +297,7 @@ object DesugarEnums {
       val enumLabelDef = enumLabelLit(name.toString)
       val impl1 = cpy.Template(impl)(
         parents = impl.parents :+ scalaRuntimeDot(tpnme.EnumValue),
-        body = ordinalDef ::: enumLabelDef :: productPrefixMeth :: registerCall :: Nil
+        body = ordinalDef ::: enumLabelDef :: 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/core/Definitions.scala

@@ -648,8 +648,6 @@ class Definitions {
   @tu lazy val NoneModule: Symbol = requiredModule("scala.None")
 
   @tu lazy val EnumClass: ClassSymbol = requiredClass("scala.Enum")
-    @tu lazy val Enum_ordinal: Symbol = EnumClass.requiredMethod(nme.ordinal)
-    @tu lazy val Enum_enumLabel: Symbol = EnumClass.requiredMethod(nme.enumLabel)
 
   @tu lazy val EnumValuesClass: ClassSymbol = requiredClass("scala.runtime.EnumValues")
 

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

@@ -57,7 +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 myEnumCaseClassSymbols: List[Symbol] = Nil
+  private var myEnumValueSymbols: List[Symbol] = Nil
   private var myNonJavaEnumValueSymbols: List[Symbol] = Nil
 
   private def initSymbols(using Context) =
@@ -67,14 +67,14 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
         defn.Product_productArity, defn.Product_productPrefix, defn.Product_productElement,
         defn.Product_productElementName)
       myCaseModuleSymbols = myCaseSymbols.filter(_ ne defn.Any_equals)
-      myEnumCaseClassSymbols = List(defn.Enum_enumLabel)
-      myNonJavaEnumValueSymbols = List(defn.Any_toString)
+      myEnumValueSymbols = List(defn.Product_productPrefix)
+      myNonJavaEnumValueSymbols = myEnumValueSymbols :+ 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 enumCaseClassSymbols(using Context): List[Symbol] = { initSymbols; myEnumCaseClassSymbols }
+  def enumValueSymbols(using Context): List[Symbol] = { initSymbols; myEnumValueSymbols }
   def nonJavaEnumValueSymbols(using Context): List[Symbol] = { initSymbols; myNonJavaEnumValueSymbols }
 
   private def existingDef(sym: Symbol, clazz: ClassSymbol)(using Context): Symbol = {
@@ -101,9 +101,9 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     val symbolsToSynthesize: List[Symbol] =
       if (clazz.is(Case))
         if (clazz.is(Module)) caseModuleSymbols
-        else if (isEnumCase) caseSymbols ++ enumCaseClassSymbols
         else caseSymbols
       else if (isNonJavaEnumValue) nonJavaEnumValueSymbols
+      else if (isEnumValue) enumValueSymbols
       else if (isDerivedValueClass(clazz)) valueSymbols
       else Nil
 
@@ -138,7 +138,8 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
         case nme.equals_ => equalsBody(vrefss.head.head)
         case nme.canEqual_ => canEqualBody(vrefss.head.head)
         case nme.productArity => Literal(Constant(accessors.length))
-        case nme.productPrefix | nme.enumLabel => ownName
+        case nme.productPrefix if isEnumValue => callEnumLabel
+        case nme.productPrefix => ownName
         case nme.productElement => productElementBody(accessors.length, vrefss.head.head)
         case nme.productElementName => productElementNameBody(accessors.length, vrefss.head.head)
       }

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

@@ -1130,6 +1130,7 @@ trait Checking {
 
   end checkEnumParent
 
+
   /** Check that all references coming from enum cases in an enum companion object
    *  are legal.
    *  @param  cdef     the enum companion object class

docs/docs/reference/enums/desugarEnums.md

@@ -174,8 +174,8 @@ If `E` contains at least one simple case, its companion object will define in ad
      follows.
      ```scala
      private def $new(_$ordinal: Int, $name: String) = new E with runtime.EnumValue {
-       def ordinal = _$ordinal
-       def enumLabel = $name
+       override def ordinal = _$ordinal
+       override def enumLabel = $name
        override def productPrefix = enumLabel // if not overridden in `E`
        override def toString = enumLabel      // if not overridden in `E`
        $values.register(this) // register enum value so that `valueOf` and `values` can return it.

docs/docs/reference/enums/enums.md

@@ -110,7 +110,7 @@ For a more in-depth example of using Scala 3 enums from Java, see [this test](ht
 ### Implementation
 
 Enums are represented as `sealed` classes that extend the `scala.Enum` trait.
-This trait defines a two public methods, `ordinal` and `enumLabel`:
+This trait defines two public methods, `ordinal` and `enumLabel`:
 
 ```scala
 package scala
@@ -132,8 +132,8 @@ For instance, the `Venus` value above would be defined like this:
 ```scala
 val Venus: Planet =
   new Planet(4.869E24, 6051800.0) {
-    def ordinal: Int = 1
-    def enumLabel: String = "Venus"
+    override def ordinal: Int = 1
+    override def enumLabel: String = "Venus"
     override def productPrefix: String = enumLabel
     override def toString: String = enumLabel
     // internal code to register value

library/src/scala/runtime/EnumValues.scala renamed to library/src-bootstrapped/scala/runtime/EnumValues.scala

@@ -14,7 +14,7 @@ class EnumValues[E <: Enum] {
 
   def fromInt: Map[Int, E] = myMap
   def fromName: Map[String, E] = {
-    if (fromNameCache == null) fromNameCache = myMap.values.map(v => v.productPrefix -> v).toMap
+    if (fromNameCache == null) fromNameCache = myMap.values.map(v => v.enumLabel -> v).toMap
     fromNameCache
   }
   def values: Iterable[E] = myMap.values

library/src-non-bootstrapped/scala/runtime/EnumValues.scala

@@ -0,0 +1,21 @@
+package scala.runtime
+
+import scala.collection.immutable.TreeMap
+
+class EnumValues[E <: Enum] {
+  private[this] var myMap: Map[Int, E] = TreeMap.empty
+  private[this] var fromNameCache: Map[String, E] = null
+
+  def register(v: E) = {
+    require(!myMap.contains(v.ordinal))
+    myMap = myMap.updated(v.ordinal, v)
+    fromNameCache = null
+  }
+
+  def fromInt: Map[Int, E] = myMap
+  def fromName: Map[String, E] = {
+    if (fromNameCache == null) fromNameCache = myMap.values.map(v => v.toString -> v).toMap
+    fromNameCache
+  }
+  def values: Iterable[E] = myMap.values
+}

library/src/scala/runtime/EnumValue.scala

@@ -3,7 +3,6 @@ package scala.runtime
 super trait EnumValue extends Product, Serializable:
   override def canEqual(that: Any) = this eq that.asInstanceOf[AnyRef]
   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 =

tests/neg/enumsLabelDef.scala

@@ -1,6 +1,7 @@
 enum Labelled {
+
   case A // error: cannot override final member method enumLabel in class Labelled
-  case B(arg: Int) // ok: enumLabel has same behaviour here as productPrefix
+  case B(arg: Int) // error: cannot override final member method enumLabel in class Labelled
 
-  override final def enumLabel: String = "nolabel"
+  final def enumLabel: String = "nolabel"
 }

tests/run/enum-custom-toString.scala

@@ -6,7 +6,9 @@ enum EJ extends java.lang.Enum[EJ]:
   case B
   override def toString: String = "overridden"
 
-trait Mixin:
+trait Mixin extends Enum:
+  override def enumLabel: String = "nolabel"
+  override def productPrefix: String = "noprefix"
   override def toString: String = "overridden"
 
 enum EM extends Mixin:
@@ -27,21 +29,13 @@ enum EC: // control case
 enum EO:
   case H
   case I(arg: Int)
-  // TODO: allow `productPrefix` to be overridden in singleton enum values - until `scala.Enum` is bootstrapped with
-  // `enumLabel`, `runtime.EnumValues` uses `productPrefix` for by-name lookup.
   override def productPrefix: String = "noprefix"
+  override def toString: String = "overridden"
 end EO
 
-enum EL {
-  case J
-  case K(arg: Int)
-  override def enumLabel: String = "nolabel" // will always be overridden by simple cases
-}
-
-enum EQ[T] {
-  case L extends EQ[Int]
-  override def enumLabel: String = "nolabel" // will always be overridden by value cases
-}
+enum EQ:
+  case J           extends EQ with Mixin
+  case K(arg: Int) extends EQ with Mixin
 
 abstract class Tag[T] extends Enum
 object Tag:
@@ -61,8 +55,8 @@ object Tag:
   assert(EJ.B.enumLabel == "B",               s"EJ.B.enumLabel = ${EJ.B.enumLabel}")
   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.C.enumLabel == "C",               s"EM.C.enumLabel = ${EM.C.enumLabel}")
+  assert(EM.C.productPrefix == "noprefix",    s"EM.C.productPrefix = ${EM.C.productPrefix}")
+  assert(EM.C.enumLabel == "C",               s"EM.C.enumLabel = ${EM.C.enumLabel}") // enumLabel override is useless
   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}")
@@ -77,27 +71,23 @@ object Tag:
   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(EC.G(0).enumLabel == "G",            s"EC.G(0).enumLabel = ${EC.G(0).enumLabel}")
-  assert(EO.H.toString == "H",                s"EO.H.toString = ${EO.H.toString}")
-  assert(EO.H.productPrefix == "H",           s"EO.H.productPrefix = ${EO.H.productPrefix}") // TODO: enable override
+  assert(EO.H.toString == "overridden",       s"EO.H.toString = ${EO.H.toString}")
+  assert(EO.H.productPrefix == "noprefix",    s"EO.H.productPrefix = ${EO.H.productPrefix}")
   assert(EO.H.enumLabel == "H",               s"EO.H.enumLabel = ${EO.H.enumLabel}")
   assert(EO.valueOf("H") == EO.H,             s"EO.valueOf(H) = ${EO.valueOf("H")}")
-  assert(EO.I(0).toString == "noprefix(0)",   s"EO.I(0).toString = ${EO.I(0).toString}")
+  assert(EO.I(0).toString == "overridden",    s"EO.I(0).toString = ${EO.I(0).toString}")
   assert(EO.I(0).productPrefix == "noprefix", s"EO.I(0).productPrefix = ${EO.I(0).productPrefix}")
   assert(EO.I(0).enumLabel == "I",            s"EO.I(0).enumLabel = ${EO.I(0).enumLabel}")
-  assert(EL.J.toString == "J",                s"EL.J.toString = ${EL.J.toString}")
-  assert(EL.J.productPrefix == "J",           s"EL.J.productPrefix = ${EL.J.productPrefix}")
-  assert(EL.J.enumLabel == "J",               s"EL.J.enumLabel = ${EL.J.enumLabel}") // can't override label in simple case
-  assert(EL.valueOf("J") == EL.J,             s"EL.valueOf(J) = ${EL.valueOf("J")}")
-  assert(EL.K(0).toString == "K(0)",          s"EL.K(0).toString = ${EL.K(0).toString}")
-  assert(EL.K(0).productPrefix == "K",        s"EL.K(0).productPrefix = ${EL.K(0).productPrefix}")
-  assert(EL.K(0).enumLabel == "nolabel",      s"EL.K(0).enumLabel = ${EL.K(0).enumLabel}") // enum label overridden in class case
-  assert(EQ.L.toString == "L",                s"EQ.L.toString = ${EQ.L.toString}")
-  assert(EQ.L.productPrefix == "L",           s"EQ.L.productPrefix = ${EQ.L.productPrefix}")
-  assert(EQ.L.enumLabel == "L",               s"EQ.L.enumLabel = ${EQ.L.enumLabel}") // can't override label in value case
-
+  assert(EQ.J.toString == "overridden",       s"EQ.J.toString = ${EQ.J.toString}")
+  assert(EQ.J.productPrefix == "noprefix",    s"EQ.J.productPrefix = ${EQ.J.productPrefix}")
+  assert(EQ.J.enumLabel == "J",               s"EQ.J.enumLabel = ${EQ.J.enumLabel}") // enumLabel override is useless
+  assert(EQ.valueOf("J") == EQ.J,             s"EQ.valueOf(J) = ${EQ.valueOf("J")}")
+  assert(EQ.K(0).toString == "overridden",    s"EQ.K(0).toString = ${EQ.K(0).toString}")
+  assert(EQ.K(0).productPrefix == "noprefix", s"EQ.K(0).productPrefix = ${EQ.K(0).productPrefix}")
+  assert(EQ.K(0).enumLabel == "K",            s"EQ.K(0).enumLabel = ${EQ.K(0).enumLabel}") // enumLabel override is useless
+  assert(Tag.IntTag.productPrefix == "",      s"Tag.IntTag.productPrefix = ${Tag.IntTag.productPrefix}")
+  assert(Tag.IntTag.enumLabel == "IntTag",    s"Tag.IntTag.enumLabel = ${Tag.IntTag.enumLabel}")
   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}")
-  assert(Tag.IntTag.enumLabel     == "IntTag", s"Tag.IntTag.enumLabel = ${Tag.IntTag.enumLabel}")