remove EnumValueSerializationProxy

Author: bishabosha

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

@@ -554,6 +554,7 @@ object StdNames {
     val productIterator: N      = "productIterator"
     val productPrefix: N        = "productPrefix"
     val raw_ : N                = "raw"
+    val readResolve: N          = "readResolve"
     val refl: N                 = "refl"
     val reflect: N              = "reflect"
     val reflectiveSelectable: N = "reflectiveSelectable"

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

@@ -356,14 +356,26 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
   }
 
   private def hasWriteReplace(clazz: ClassSymbol)(using Context): Boolean =
-    clazz.membersNamed(nme.writeReplace)
-      .filterWithPredicate(s => s.signature == Signature(defn.AnyRefType, isJava = false))
-      .exists
+    hasAnyRefDef(clazz, nme.writeReplace)
 
   private def writeReplaceDef(clazz: ClassSymbol)(using Context): TermSymbol =
-    newSymbol(clazz, nme.writeReplace, Method | Private | Synthetic,
+    privateAnyRefDef(clazz, nme.writeReplace)
+
+  private def readResolveDef(clazz: ClassSymbol)(using Context): TermSymbol =
+    privateAnyRefDef(clazz, nme.readResolve)
+
+  private def hasReadResolve(clazz: ClassSymbol)(using Context): Boolean =
+    hasAnyRefDef(clazz, nme.readResolve)
+
+  private def privateAnyRefDef(clazz: ClassSymbol, name: TermName)(using Context): TermSymbol =
+    newSymbol(clazz, name, Method | Private | Synthetic,
         MethodType(Nil, defn.AnyRefType), coord = clazz.coord).entered.asTerm
 
+  private def hasAnyRefDef(clazz: ClassSymbol, name: TermName)(using Context): Boolean =
+    clazz.membersNamed(name)
+      .filterWithPredicate(s => s.signature == Signature(defn.AnyRefType, isJava = false))
+      .exists
+
   /** If this is a serializable static object `Foo`, add the method:
    *
    *      private def writeReplace(): AnyRef =
@@ -389,23 +401,24 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
   /** If this the class backing a serializable singleton enum value with base class `MyEnum`,
    *  and not deriving from `java.lang.Enum` add the method:
    *
-   *      private def writeReplace(): AnyRef =
-   *        new scala.runtime.EnumValueSerializationProxy(classOf[MyEnum], this.ordinal)
+   *      private def readResolve(): AnyRef =
+   *        MyEnum.values(this.ordinal)
    *
    *  unless an implementation already exists, otherwise do nothing.
    */
    def serializableEnumValueMethod(clazz: ClassSymbol)(using Context): List[Tree] =
     if clazz.isEnumValueImplementation
       && !clazz.derivesFrom(defn.JavaEnumClass)
       && clazz.isSerializable
-      && !hasWriteReplace(clazz)
+      && !hasReadResolve(clazz)
     then
       List(
-        DefDef(writeReplaceDef(clazz),
-          _ => New(defn.EnumValueSerializationProxyClass.typeRef,
-                   defn.EnumValueSerializationProxyConstructor,
-                   List(Literal(Constant(clazz.classParents.head)), This(clazz).select(nme.ordinal).ensureApplied)))
-          .withSpan(ctx.owner.span.focus))
+        DefDef(readResolveDef(clazz),
+          _ => ref(clazz.classParents.head.typeSymbol.companionModule)
+                .select(nme.values).ensureApplied // `.values` must exist if `isEnumValueImplementation` is true
+                .select(nme.apply).appliedTo(This(clazz).select(nme.ordinal).ensureApplied)
+        ).withSpan(ctx.owner.span.focus)
+      )
     else
       Nil