remove scala.runtime.EnumValues

Author: bishabosha

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

@@ -20,10 +20,18 @@ object DesugarEnums {
     val Simple, Object, Class: Value = Value
   }
 
+  final class EnumConstraints(minKind: CaseKind.Value, maxKind: CaseKind.Value, cases: List[(Int, TermName)]):
+    require(minKind <= maxKind && !(cached && cachedValues.isEmpty))
+    def requiresCreator = minKind == CaseKind.Simple
+    def isEnumeration   = maxKind < CaseKind.Class
+    def cached          = minKind < CaseKind.Class
+    def cachedValues    = cases
+  end EnumConstraints
+
   /** Attachment containing the number of enum cases, the smallest kind that was seen so far,
    *  and a list of all the value cases with their ordinals.
    */
-  val EnumCaseCount: Property.Key[(Int, CaseKind.Value, List[(Int, TermName)])] = Property.Key()
+  val EnumCaseCount: Property.Key[(Int, CaseKind.Value, CaseKind.Value, List[(Int, TermName)])] = Property.Key()
 
   /** Attachment signalling that when this definition is desugared, it should add any additional
    *  lookup methods for enums.
@@ -84,35 +92,55 @@ object DesugarEnums {
   private def valuesDot(name: PreName)(implicit src: SourceFile) =
     Select(Ident(nme.DOLLAR_VALUES), name.toTermName)
 
-  private def registerCall(using Context): Tree =
-    Apply(valuesDot("register"), This(EmptyTypeIdent) :: Nil)
+  private def ArrayLiteral(values: List[Tree], tpt: Tree)(using Context): Tree =
+    val clazzOf = TypeApply(ref(defn.Predef_classOf.termRef), tpt :: Nil)
+    val ctag    = Apply(TypeApply(ref(defn.ClassTagModule_apply.termRef), tpt :: Nil), clazzOf :: Nil)
+    val apply   = Select(ref(defn.ArrayModule.termRef), nme.apply)
+    Apply(Apply(TypeApply(apply, tpt :: Nil), values), ctag :: Nil)
 
-  /**  The following lists of definitions for an enum type E:
+  /**  The following lists of definitions for an enum type E and known value cases e_0, ..., e_n:
    *
-   *   private val $values = new EnumValues[E]
-   *   def values = $values.values.toArray
+   *   private val $values = Array[E](e_0,...,e_n)(ClassTag[E](classOf[E]))
+   *   @annotation.threadUnsafe private lazy val $valuesReverse =
+   *     scala.runtime.ScalaRuntime.wrapRefArray($values).map((x_0: E) => (x_0.enumLabel, x_0)).toMap
+   *   def values = $values.clone
    *   def valueOf($name: String) =
-   *     try $values.fromName($name) catch
+   *     try $valuesReverse($name) catch
    *       {
-   *         case ex$:NoSuchElementException =>
-   *           throw new IllegalArgumentException("key not found: ".concat(name))
+   *         case ex$: NoSuchElementException =>
+   *           throw new IllegalArgumentException("enum case not found: " + $name)
    *       }
    */
-  private def enumScaffolding(using Context): List[Tree] = {
+  private def enumScaffolding(enumCases: List[(Int, TermName)])(using Context): List[Tree] = {
+    import dotty.tools.dotc.transform.SymUtils.rawTypeRef
     val rawEnumClassRef = rawRef(enumClass.typeRef)
     extension (tpe: NamedType) def ofRawEnum = AppliedTypeTree(ref(tpe), rawEnumClassRef)
+
+    val privateValuesDef =
+      ValDef(nme.DOLLAR_VALUES, TypeTree(),
+        ArrayLiteral(enumCases.map((_, name) => Ident(name)), rawEnumClassRef))
+          .withFlags(Private | Synthetic)
+
+    val privateReverseValuesDef =
+      val wrapped = Apply(Select(ref(defn.ScalaRuntimeModule.termRef), nme.wrapRefArray), Ident(nme.DOLLAR_VALUES))
+      val mapper =
+        val paramName = nme.syntheticParamName(0)
+        val paramDef = param(paramName, rawEnumClassRef)
+        Function(paramDef :: Nil, Tuple(Select(Ident(paramName), nme.enumLabel) :: Ident(paramName) :: Nil))
+      val mapBody = Select(Apply(Select(wrapped, nme.map), mapper), nme.toMap)
+      val annot = New(ref(defn.ThreadUnsafeAnnot.typeRef), Nil).withSpan(ctx.tree.span)
+      ValDef(nme.DOLLAR_VALUES_REVERSE, TypeTree(), mapBody)
+          .withFlags(Private | Synthetic | Lazy).withAnnotations(annot :: Nil)
+
     val valuesDef =
-      DefDef(nme.values, Nil, Nil, defn.ArrayType.ofRawEnum, Select(valuesDot(nme.values), nme.toArray))
+      DefDef(nme.values, Nil, Nil, defn.ArrayType.ofRawEnum, valuesDot(nme.clone_))
         .withFlags(Synthetic)
-    val privateValuesDef =
-      ValDef(nme.DOLLAR_VALUES, TypeTree(), New(defn.EnumValuesClass.typeRef.ofRawEnum, ListOfNil))
-        .withFlags(Private | Synthetic)
 
     val valuesOfExnMessage = Apply(
-      Select(Literal(Constant("key not found: ")), "concat".toTermName),
-      Ident(nme.nameDollar) :: Nil)
+      Select(Literal(Constant("enum case not found: ")), nme.PLUS), Ident(nme.nameDollar))
+
     val valuesOfBody = Try(
-      expr = Apply(valuesDot("fromName"), Ident(nme.nameDollar) :: Nil),
+      expr = Apply(Ident(nme.DOLLAR_VALUES_REVERSE), Ident(nme.nameDollar) :: Nil),
       cases = CaseDef(
         pat = Typed(Ident(nme.DEFAULT_EXCEPTION_NAME), TypeTree(defn.NoSuchElementExceptionType)),
         guard = EmptyTree,
@@ -124,25 +152,32 @@ object DesugarEnums {
       TypeTree(), valuesOfBody)
         .withFlags(Synthetic)
 
-    valuesDef ::
     privateValuesDef ::
+    privateReverseValuesDef ::
+    valuesDef ::
     valueOfDef :: Nil
   }
 
-  private def enumLookupMethods(cases: List[(Int, TermName)])(using Context): List[Tree] =
-    if isJavaEnum || cases.isEmpty then Nil
-    else
-      val defaultCase =
-        val ord = Ident(nme.ordinal)
-        val err = Throw(New(TypeTree(defn.IndexOutOfBoundsException.typeRef), List(Select(ord, nme.toString_) :: Nil)))
-        CaseDef(ord, EmptyTree, err)
-      val valueCases = cases.map((i, name) =>
-        CaseDef(Literal(Constant(i)), EmptyTree, Ident(name))
-      ) ::: defaultCase :: Nil
-      val fromOrdinalDef = DefDef(nme.fromOrdinalDollar, Nil, List(param(nme.ordinalDollar_, defn.IntType) :: Nil),
-        rawRef(enumClass.typeRef), Match(Ident(nme.ordinalDollar_), valueCases))
-          .withFlags(Synthetic | Private)
-      fromOrdinalDef :: Nil
+  private def enumLookupMethods(constraints: EnumConstraints)(using Context): List[Tree] =
+    def scaffolding: List[Tree] = if constraints.cached then enumScaffolding(constraints.cachedValues) else Nil
+    def valueCtor: List[Tree] = if constraints.requiresCreator then enumValueCreator :: Nil else Nil
+    def byOrdinal: List[Tree] =
+      if isJavaEnum || !constraints.cached then Nil
+      else
+        val defaultCase =
+          val ord = Ident(nme.ordinal)
+          val err = Throw(New(TypeTree(defn.IndexOutOfBoundsException.typeRef), List(Select(ord, nme.toString_) :: Nil)))
+          CaseDef(ord, EmptyTree, err)
+        val valueCases = constraints.cachedValues.map((i, name) =>
+          CaseDef(Literal(Constant(i)), EmptyTree, Ident(name))
+        ) ::: defaultCase :: Nil
+        val fromOrdinalDef = DefDef(nme.fromOrdinalDollar, Nil, List(param(nme.ordinalDollar_, defn.IntType) :: Nil),
+          rawRef(enumClass.typeRef), Match(Ident(nme.ordinalDollar_), valueCases))
+            .withFlags(Synthetic | Private)
+        fromOrdinalDef :: Nil
+
+    scaffolding ::: valueCtor ::: byOrdinal
+  end enumLookupMethods
 
   /** A creation method for a value of enum type `E`, which is defined as follows:
    *
@@ -167,7 +202,7 @@ object DesugarEnums {
       parents = enumClassRef :: scalaRuntimeDot(tpnme.EnumValue) :: Nil,
       derived = Nil,
       self = EmptyValDef,
-      body = fieldMethods ::: registerCall :: Nil
+      body = fieldMethods
     ).withAttachment(ExtendsSingletonMirror, ()))
     DefDef(nme.DOLLAR_NEW, Nil,
         List(List(param(nme.ordinalDollar_, defn.IntType), param(nme.nameDollar, defn.StringType))),
@@ -279,25 +314,22 @@ object DesugarEnums {
    *     unless that scaffolding was already generated by a previous call to `nextEnumKind`.
    */
   def nextOrdinal(name: Name, kind: CaseKind.Value, definesLookups: Boolean)(using Context): (Int, List[Tree]) = {
-    val (ordinal, seenKind, seenCases) = ctx.tree.removeAttachment(EnumCaseCount).getOrElse((0, CaseKind.Class, Nil))
-    val minKind = if kind < seenKind then kind else seenKind
+    val (ordinal, seenMinKind, seenMaxKind, seenCases) =
+      ctx.tree.removeAttachment(EnumCaseCount).getOrElse((0, CaseKind.Class, CaseKind.Simple, Nil))
+    val minKind = if kind < seenMinKind then kind else seenMinKind
+    val maxKind = if kind > seenMaxKind then kind else seenMaxKind
     val cases = name match
       case name: TermName => (ordinal, name) :: seenCases
       case _              => seenCases
-    ctx.tree.pushAttachment(EnumCaseCount, (ordinal + 1, minKind, cases))
-    val scaffolding0 =
-      if (kind >= seenKind) Nil
-      else if (kind == CaseKind.Object) enumScaffolding
-      else if (seenKind == CaseKind.Object) enumValueCreator :: Nil
-      else enumScaffolding :+ enumValueCreator
-    val scaffolding =
-      if definesLookups then scaffolding0 ::: enumLookupMethods(cases.reverse)
-      else scaffolding0
-    (ordinal, scaffolding)
+    if definesLookups then
+      (ordinal, enumLookupMethods(EnumConstraints(minKind, maxKind, cases.reverse)))
+    else
+      ctx.tree.pushAttachment(EnumCaseCount, (ordinal + 1, minKind, maxKind, cases))
+      (ordinal, Nil)
   }
 
-  def param(name: TermName, typ: Type)(using Context) =
-    ValDef(name, TypeTree(typ), EmptyTree).withFlags(Param)
+  def param(name: TermName, typ: Type)(using Context): ValDef = param(name, TypeTree(typ))
+  def param(name: TermName, tpt: Tree)(using Context): ValDef = ValDef(name, tpt, EmptyTree).withFlags(Param)
 
   private def isJavaEnum(using Context): Boolean = ctx.owner.linkedClass.derivesFrom(defn.JavaEnumClass)
 
@@ -325,10 +357,10 @@ object DesugarEnums {
       val enumLabelDef = enumLabelLit(name.toString)
       val impl1 = cpy.Template(impl)(
         parents = impl.parents :+ scalaRuntimeDot(tpnme.EnumValue),
-        body = ordinalDef ::: enumLabelDef :: registerCall :: Nil
+        body = ordinalDef ::: enumLabelDef :: Nil
       ).withAttachment(ExtendsSingletonMirror, ())
       val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods.withAddedFlags(EnumValue, span))
-      flatTree(scaffolding ::: vdef :: Nil).withSpan(span)
+      flatTree(vdef :: scaffolding).withSpan(span)
     }
   }
 
@@ -344,6 +376,6 @@ object DesugarEnums {
       val (tag, scaffolding) = nextOrdinal(name, CaseKind.Simple, definesLookups)
       val creator = Apply(Ident(nme.DOLLAR_NEW), List(Literal(Constant(tag)), Literal(Constant(name.toString))))
       val vdef = ValDef(name, enumClassRef, creator).withMods(mods.withAddedFlags(EnumValue, span))
-      flatTree(scaffolding ::: vdef :: Nil).withSpan(span)
+      flatTree(vdef :: scaffolding).withSpan(span)
     }
 }

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

@@ -749,8 +749,6 @@ class Definitions {
 
   @tu lazy val EnumClass: ClassSymbol = requiredClass("scala.Enum")
 
-  @tu lazy val EnumValuesClass: ClassSymbol = requiredClass("scala.runtime.EnumValues")
-
   @tu lazy val EnumValueSerializationProxyClass: ClassSymbol = requiredClass("scala.runtime.EnumValueSerializationProxy")
     @tu lazy val EnumValueSerializationProxyConstructor: TermSymbol =
       EnumValueSerializationProxyClass.requiredMethod(nme.CONSTRUCTOR, List(ClassType(TypeBounds.empty), IntType))

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

@@ -123,6 +123,7 @@ object StdNames {
     val DEFAULT_GETTER_INIT: N        = "$lessinit$greater"
     val DO_WHILE_PREFIX: N            = "doWhile$"
     val DOLLAR_VALUES: N              = "$values"
+    val DOLLAR_VALUES_REVERSE: N      = "$valuesReverse"
     val DOLLAR_NEW: N                 = "$new"
     val EMPTY: N                      = ""
     val EMPTY_PACKAGE: N              = "<empty>"
@@ -598,6 +599,7 @@ object StdNames {
     val toArray: N              = "toArray"
     val toExpr: N               = "toExpr"
     val toList: N               = "toList"
+    val toMap: N                = "toMap"
     val toObjectArray : N       = "toObjectArray"
     val toSeq: N                = "toSeq"
     val toString_ : N           = "toString"

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

@@ -46,12 +46,9 @@ class CheckReentrant extends MiniPhase {
   def isIgnored(sym: Symbol)(using Context): Boolean =
     sym.hasAnnotation(sharableAnnot()) ||
     sym.hasAnnotation(unsharedAnnot()) ||
-    sym.topLevelClass.owner == scalaJSIRPackageClass() ||
+    sym.topLevelClass.owner == scalaJSIRPackageClass()
       // We would add @sharable annotations on ScalaJSVersions and
       // VersionChecks but we do not have control over that code
-    sym.owner == defn.EnumValuesClass
-      // enum values are initialized eagerly before use
-      // in the long run, we should make them vals
 
   def scanning(sym: Symbol)(op: => Unit)(using Context): Unit = {
     report.log(i"${"  " * indent}scanning $sym")

compiler/src/dotty/tools/dotc/transform/init/Env.scala

@@ -25,7 +25,6 @@ case class Env(ctx: Context) {
 
   // Methods that should be ignored in the checking
   lazy val ignoredMethods: Set[Symbol] = Set(
-    requiredClass("scala.runtime.EnumValues").requiredMethod("register"),
     defn.Any_getClass,
     defn.Any_isInstanceOf,
     defn.Object_eq,

docs/docs/reference/enums/desugarEnums.md

@@ -121,12 +121,10 @@ map into `case class`es or `val`s.
    ```
    expands to a value definition in `E`'s companion object:
    ```scala
-   val C = new <parents> { <body>; def ordinal = n; $values.register(this) }
+   val C = new <parents> { <body>; def ordinal = n }
    ```
    where `n` is the ordinal number of the case in the companion object,
-   starting from 0.  The statement `$values.register(this)` registers the value
-   as one of the `values` of the enumeration (see below). `$values` is a
-   compiler-defined private value in the companion object. The anonymous class also
+   starting from 0. The anonymous class also
    implements the abstract `Product` methods that it inherits from `Enum`.
 
 
@@ -162,8 +160,7 @@ An enum `E` (possibly generic) that defines one or more singleton cases
 will define the following additional synthetic members in its companion object (where `E'` denotes `E` with
 any type parameters replaced by wildcards):
 
-   - A method `valueOf(name: String): E'`. It returns the singleton case value whose
-     `toString` representation is `name`.
+   - A method `valueOf(name: String): E'`. It returns the singleton case value whose `enumLabel` is `name`.
    - A method `values` which returns an `Array[E']` of all singleton case
      values defined by `E`, in the order of their definitions.
 
@@ -178,7 +175,6 @@ If `E` contains at least one simple case, its companion object will define in ad
        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

@@ -136,7 +136,6 @@ val Venus: Planet =
     def enumLabel: String = "Venus"
     override def productPrefix: String = enumLabel
     override def toString: String = enumLabel
-    // internal code to register value
   }
 ```
 

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

@@ -1,15 +1,18 @@
 enum Labelled {
 
   case A // error overriding method enumLabel in class Labelled of type => String;
-  case B(arg: Int) // error overriding method enumLabel in class Labelled of type => String;
 
   def enumLabel: String = "nolabel"
 }
 
 trait Mixin { def enumLabel: String = "mixin" }
 
 enum Mixed extends Mixin {
-  case C // error overriding method enumLabel in trait Mixin of type => String;
+  case B // error overriding method enumLabel in trait Mixin of type => String;
+}
+
+enum MixedAlso {
+  case C extends MixedAlso with Mixin // error overriding method enumLabel in trait Mixin of type => String;
 }
 
 trait HasEnumLabel { def enumLabel: String }

tests/neg/enumsLabelDef.scala

@@ -26,7 +26,7 @@ MONDAY : 0
 TUESDAY : 1
 SATURDAY : 2
 By-name value: MONDAY
-Correctly failed to retrieve illegal name, message: key not found: stuff
+Correctly failed to retrieve illegal name, message: enum case not found: stuff
 
 Collections Test
 Retrieving Monday: workday