fast switch on string for valueOf

Author: bishabosha

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

@@ -95,58 +95,79 @@ object DesugarEnums {
   /**  The following lists of definitions for an enum type E and known value cases e_0, ..., e_n:
    *
    *   private val $values = [e_0, ..., e_n : 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 $valuesReverse($name) catch
-   *       {
-   *         case ex$: NoSuchElementException =>
-   *           throw new IllegalArgumentException("enum case not found: " + $name)
-   *       }
+   *     val nameHash = if $name == null then 0 else $name.hashCode
+   *     var ordinal = -1
+   *     nameHash match {
+   *       case 100054 =>
+   *         if "e_0" equals $name then
+   *           ordinal = 0
+   *       ...
+   *       case 100116 =>
+   *         if "e_n" equals $name then
+   *           ordinal = n
+   *       case _ =>
+   *     }
+   *     ordinal match {
+   *       case 0 => e_0
+   *       ...
+   *       case n => e_n
+   *       case _ => throw new IllegalArgumentException("case not found: " + $name)
+   *     }
    */
   private def enumScaffolding(enumCases: List[(Int, TermName)])(using Context): List[Tree] = {
     import dotty.tools.dotc.transform.SymUtils.rawTypeRef
+
+    def const(arg: String | Int | Null | Unit) = Literal(Constant(arg))
+
     val rawEnumClassRef = rawRef(enumClass.typeRef)
     extension (tpe: NamedType) def ofRawEnum = AppliedTypeTree(ref(tpe), rawEnumClassRef)
 
     val privateValuesDef =
       ValDef(nme.DOLLAR_VALUES, TypeTree(), JavaSeqLiteral(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, valuesDot(nme.clone_))
         .withFlags(Synthetic)
 
-    val valuesOfExnMessage = Apply(
-      Select(Literal(Constant("enum case not found: ")), nme.PLUS), Ident(nme.nameDollar))
-
-    val valuesOfBody = Try(
-      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,
-        body = Throw(New(TypeTree(defn.IllegalArgumentExceptionType), List(valuesOfExnMessage :: Nil)))
-      ) :: Nil,
-      finalizer = EmptyTree
-    )
+    val valuesOfBody: Tree =
+      val nameHash = nme.syntheticParamName(0)
+      val ordinal = nme.syntheticParamName(1)
+      val nameHashDef =
+        ValDef(nameHash, TypeTree(defn.IntType), If(
+          cond = Apply(Select(Ident(nme.nameDollar), nme.eq), const(null)),
+          thenp = const(0),
+          elsep = Select(Ident(nme.nameDollar), nme.hashCode_))).withFlags(Local)
+      val ordinalDef = ValDef(ordinal, TypeTree(defn.IntType), const(-1)).withFlags(Local | Mutable)
+      val hashCases = enumCases.map { (ord, name) =>
+        val condAssign = If(
+          cond = Apply(Select(const(name.toString), nme.equals_), Ident(nme.nameDollar)),
+          thenp = Assign(Ident(ordinal), const(ord)),
+          elsep = const(()))
+        CaseDef(const(name.toString.hashCode), EmptyTree, condAssign)
+      } ::: CaseDef(Ident(nme.WILDCARD), EmptyTree, const(())) :: Nil
+      val finalDefault =
+        val msg = Apply(Select(const("enum case not found: "), nme.PLUS), Ident(nme.nameDollar))
+          CaseDef(
+          pat = Ident(nme.WILDCARD),
+          guard = EmptyTree,
+          body = Throw(New(TypeTree(defn.IllegalArgumentExceptionType), List(msg :: Nil))))
+      val intermediateCases = enumCases.map((ordinal, name) =>
+        CaseDef(const(ordinal), EmptyTree, Ident(name))
+      ) ::: finalDefault :: Nil
+      Block(
+        nameHashDef ::
+        ordinalDef ::
+        Match(Ident(nameHash), hashCases) :: Nil,
+        Match(Ident(ordinal), intermediateCases)
+      )
     val valueOfDef = DefDef(nme.valueOf, Nil, List(param(nme.nameDollar, defn.StringType) :: Nil),
       TypeTree(), valuesOfBody)
         .withFlags(Synthetic)
 
     privateValuesDef ::
-    privateReverseValuesDef ::
     valuesDef ::
     valueOfDef :: Nil
   }

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

@@ -123,7 +123,6 @@ 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>"