make fromOrdinal public and always available

Author: bishabosha

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

@@ -154,22 +154,24 @@ object DesugarEnums {
   private def enumLookupMethods(constraints: EnumConstraints)(using Context): List[Tree] =
     def scaffolding: List[Tree] = if constraints.cached then enumScaffolding(constraints.enumCases.map(_._2)) else Nil
     def valueCtor: List[Tree] = if constraints.requiresCreator then enumValueCreator :: Nil else Nil
-    def byOrdinal: List[Tree] =
-      if isJavaEnum || !constraints.cached then Nil
+    def fromOrdinal: Tree =
+      def throwArg(ordinal: Tree) =
+        Throw(New(TypeTree(defn.NoSuchElementExceptionType), List(Select(ordinal, nme.toString_) :: Nil)))
+      if !constraints.cached then
+        fromOrdinalMeth(throwArg)
       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.enumCases.map((i, enumValue) =>
-          CaseDef(Literal(Constant(i)), EmptyTree, enumValue)
-        ) ::: 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
+        def default(ordinal: Tree) =
+          CaseDef(Ident(nme.x_0), EmptyTree, throwArg(ordinal))
+        if constraints.isEnumeration then
+          fromOrdinalMeth(ordinal =>
+            Try(Apply(valuesDot(nme.apply), ordinal), default(ordinal) :: Nil, EmptyTree))
+        else
+          fromOrdinalMeth(ordinal =>
+            Match(ordinal,
+              constraints.enumCases.map((i, enumValue) => CaseDef(Literal(Constant(i)), EmptyTree, enumValue))
+              :+ default(ordinal)))
+
+    scaffolding ::: valueCtor ::: fromOrdinal :: Nil
   end enumLookupMethods
 
   /** A creation method for a value of enum type `E`, which is defined as follows:
@@ -278,6 +280,10 @@ object DesugarEnums {
   def ordinalMethLit(ord: Int)(using Context): DefDef =
     ordinalMeth(Literal(Constant(ord)))
 
+  def fromOrdinalMeth(body: Tree => Tree)(using Context): DefDef =
+    DefDef(nme.fromOrdinal, Nil, List(param(nme.ordinalDollar_, defn.IntType) :: Nil),
+      rawRef(enumClass.typeRef), body(Ident(nme.ordinalDollar_))).withFlags(Synthetic)
+
   /** Expand a module definition representing a parameterless enum case */
   def expandEnumModule(name: TermName, impl: Template, mods: Modifiers, definesLookups: Boolean, span: Span)(using Context): Tree = {
     assert(impl.body.isEmpty)

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

@@ -617,7 +617,7 @@ object StdNames {
     val using: N                = "using"
     val value: N                = "value"
     val valueOf : N             = "valueOf"
-    val fromOrdinalDollar: N    = "$fromOrdinal"
+    val fromOrdinal: N          = "fromOrdinal"
     val values: N               = "values"
     val view_ : N               = "view"
     val wait_ : N               = "wait"

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

@@ -429,7 +429,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
    *  and not deriving from `java.lang.Enum` add the method:
    *
    *      private def readResolve(): AnyRef =
-   *        MyEnum.$fromOrdinal(this.ordinal)
+   *        MyEnum.fromOrdinal(this.ordinal)
    *
    *  unless an implementation already exists, otherwise do nothing.
    */
@@ -443,7 +443,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
       List(
         DefDef(readResolveDef(clazz),
           _ => ref(clazz.owner.owner.sourceModule)
-                .select(nme.fromOrdinalDollar)
+                .select(nme.fromOrdinal)
                 .appliedTo(This(clazz).select(nme.ordinal).ensureApplied))
           .withSpan(ctx.owner.span.focus))
     else

tests/run/enum-values.scala

@@ -1,10 +1,13 @@
+import reflect.Selectable.reflectiveSelectable
+import deriving.Mirror
+
 enum Color:
   case Red, Green, Blue
 
 enum Tag[T]:
   case Int extends Tag[Int]
+  case OfClass[T]()(using val tag: reflect.ClassTag[T]) extends Tag[T] // mix order of class and value
   case String extends Tag[String]
-  case OfClass[T]()(using val tag: reflect.ClassTag[T]) extends Tag[T]
 
 enum Expr[-T >: Null]:
   case EmptyTree extends Expr[Null]
@@ -16,18 +19,55 @@ enum ListLike[+T]:
 
 enum TypeCtorsK[F[_]]:
   case List       extends TypeCtorsK[List]
+  case Const[T]() extends TypeCtorsK[[U] =>> T] // mix order of class and value
   case Option     extends TypeCtorsK[Option]
-  case Const[T]() extends TypeCtorsK[[U] =>> T]
 
 enum MixedParams[F[_], G[X,Y] <: collection.Map[X,Y], T]:
   case Foo extends MixedParams[List, collection.mutable.LinkedHashMap, Unit]
 
+enum ClassOnly: // this should still generate the `ordinal` and `fromOrdinal` companion methods
+  case BranchProd(i: Int)
+
 @main def Test: Unit =
-  import Color._, Tag._, Expr._, ListLike._, TypeCtorsK._, MixedParams._
-  import reflect.Selectable.reflectiveSelectable
+  import Color._, Tag._, Expr._, ListLike._, TypeCtorsK._, MixedParams._, ClassOnly._
+
+  type FromOrdinal[T <: AnyRef] = {
+    def fromOrdinal(ordinal: Int): T
+  }
+
+  type ValueOf[T <: AnyRef] = {
+    def valueOf(s: String): T
+  }
 
   extension [A](t: A) def show = runtime.ScalaRunTime.stringOf(t)
 
+  def fetchFromOrdinal[T <: AnyRef & reflect.Enum](companion: FromOrdinal[T], compare: T*): Unit =
+    for c <- compare do
+      assert(companion.fromOrdinal(c.ordinal) eq c,
+        s"$c does not `eq` companion.fromOrdinal(${c.ordinal}), got ${companion.fromOrdinal(c.ordinal)}")
+
+  def notFromOrdinal[T <: AnyRef & reflect.Enum](companion: FromOrdinal[T], compare: T): Unit =
+    try
+      companion.fromOrdinal(compare.ordinal)
+      assertFail(s"$companion.fromOrdinal(${compare.ordinal}) did not fail")
+    catch
+      case e: java.lang.reflect.InvocationTargetException => // TODO: maybe reflect.Selectable should catch this?
+        assert(e.getCause.isInstanceOf[java.util.NoSuchElementException]
+          && e.getCause.getMessage == compare.ordinal.toString)
+
+  fetchFromOrdinal(companion = Color,       compare = Red, Green, Blue)
+  fetchFromOrdinal(companion = Tag,         compare = Int, String)
+  fetchFromOrdinal(companion = Expr,        compare = EmptyTree, AnyTree)
+  fetchFromOrdinal(companion = ListLike,    compare = EmptyListLike)
+  fetchFromOrdinal(companion = TypeCtorsK,  compare = List, Option)
+  fetchFromOrdinal(companion = MixedParams, compare = Foo)
+
+  notFromOrdinal(companion = Tag,        compare = OfClass[String]())
+  notFromOrdinal(companion = TypeCtorsK, compare = Const[String]())
+  notFromOrdinal(companion = ClassOnly,  compare = BranchProd(1)) // ClassOnly has the `fromOrdinal` method
+
+  assert(summon[Mirror.SumOf[ClassOnly]].ordinal(BranchProd(1)) == 0)
+
   val colors: Array[Color]             = Color.values
   val tags: Array[Tag[?]]              = Tag.values
   val exprs: Array[Expr[? >: Null]]    = Expr.values
@@ -46,7 +86,7 @@ enum MixedParams[F[_], G[X,Y] <: collection.Map[X,Y], T]:
   sameAs(typeCtorsK,  List, Option)
   sameAs(mixedParams, Foo)
 
-  def singleton[E <: AnyRef](value: E, name: String, companion: { def valueOf(s: String): E}) =
+  def singleton[E <: AnyRef](value: E, name: String, companion: ValueOf[E]) =
     val lookup = companion.valueOf(name)
     assert(value eq lookup, s"${value.show} is not identical to ${lookup.show}")