Inner enum declarations cause initialization-checker error

[Xavientois]

Compiler version

3.1.2-RC1

Minimized code

class Outer:
    enum MyEnum {
        case Case
    }

Output

-- Error: tests/init/pos/inner-enum.scala:3:8 --------------------------------------------------------------------------
3 |        case Case
  |        ^
  |        Cannot prove that the value is fully initialized. May only use initialized value as method arguments.
  |
  |        The unsafe promotion may cause the following problem:
  |        Access non-initialized value $values. Calling trace:
  |         -> case Case	[ inner-enum.scala:3 ]

Expectation

When compiling with the -Ysafe-init flag this declaration should pass.

[Xavientois]

This error appears to originate from the de-sugared code where the $values field of the enum's companion object is accessed

[Xavientois]

I plan to try to find a fix for this

[Xavientois]

Here is the de-sugared code for the above example:

package dotty.tools.dotc {
  @SourceFile("compiler/src/dotty/tools/dotc/MyOuter.scala") class MyOuter()
     extends
   Object() {
    @Child[(dotty.tools.dotc.MyOuter.MyEnum.Case : MyOuter.this.MyEnum)] sealed
      abstract
     class MyEnum() extends Object(), scala.reflect.Enum {}
    final lazy module val MyEnum: MyOuter.this.MyEnum =
      new MyOuter.this.MyEnum()
    final module class MyEnum() extends AnyRef(), scala.deriving.Mirror.Sum {
      case val Case: MyOuter.this.MyEnum = this.$new(0, "Case")
      private[this] val $values: Array[MyOuter.this.MyEnum] =
        Array.apply[MyOuter.this.MyEnum]([this.Case : MyOuter.this.MyEnum])(
          scala.reflect.ClassTag.apply[MyOuter.this.MyEnum](
            classOf[MyOuter.this.MyEnum]
          )
        )
      def values: Array[MyOuter.this.MyEnum] = this.$values.clone()
      def valueOf($name: String): MyOuter.this.MyEnum =
        $name match
          {
            case "Case" => this.Case
            case _ =>
              throw
                new IllegalArgumentException("enum case not found: ".+($name))
          }
      private[this] def $new(_$ordinal: Int, $name: String): MyOuter.this.MyEnum
         =
      {
        final class $anon() extends MyOuter.this.MyEnum(), runtime.EnumValue,
          scala.deriving.Mirror.Singleton
         {
          private def readResolve(): AnyRef =
            MyOuter.this.MyEnum.this.fromOrdinal(this.ordinal)
          override def productPrefix: String = $name
          override def toString(): String = $name
          override def ordinal: Int = _$ordinal
        }
        new
          MyOuter.this.MyEnum with runtime.EnumValue with
            scala.deriving.Mirror.Singleton
           {...}
        ():MyOuter.this.MyEnum & runtime.EnumValue
      }
      def fromOrdinal(ordinal: Int): MyOuter.this.MyEnum =
        try this.$values.apply(ordinal) catch
          {
            case _ => throw new NoSuchElementException(ordinal.toString())
          }
      type MirroredMonoType = MyOuter.this.MyEnum
      def ordinal(x$0: dotty.tools.dotc.MyOuter.MyEnum.MirroredMonoType): Int =
        x$0.ordinal
    }
  }
}

Further investigation indicates that this error comes from the definition of readResolve in the class $anon defined within $new. This method is not explicitly called anywhere in the generated code, but readResolve is used for serialization.

[liufengyun]

enum Color:
  case Red, Blue

Desugars to:

  @SourceFile("examples/Enum.scala") @Child[(Color.Blue : Color)] @Child[
    (Color.Red : Color)
  ] sealed abstract class Color() extends Object(), scala.reflect.Enum {}
  final lazy module val Color: Color = new Color()
  @SourceFile("examples/Enum.scala") final module class Color() extends Object()
    ,
  scala.deriving.Mirror.Sum {
    private def writeReplace(): Object =
      new scala.runtime.ModuleSerializationProxy(classOf[Color])
    case <static> val Red: Color = Color.$new(0, "Red")
    case <static> val Blue: Color = Color.$new(1, "Blue")
    private val $values: Color[] =
      Array.apply(
        scala.runtime.ScalaRunTime.wrapRefArray([this.Red,this.Blue : Color])
      , scala.reflect.ClassTag.apply(classOf[Color])).asInstanceOf[Color[]]
    def values(): Color[] = Color.$values.clone().asInstanceOf[Color[]]
    def valueOf($name: String): Color =
      matchResult1[Color]:
        {
          case val x1: String = $name
          if "Red".==(x1) then return[matchResult1] this.Red else ()
          if "Blue".==(x1) then return[matchResult1] this.Blue else ()
          throw new IllegalArgumentException("enum case not found: ".+($name))
        }
    private def $new(_$ordinal: Int, $name: String): Color =
      {
        final class $anon() extends Color(), scala.runtime.EnumValue,
          scala.deriving.Mirror.Singleton
         {
          private def readResolve(): Object = Color.fromOrdinal(this.ordinal())
          override def productPrefix(): String = $name
          override def toString(): String = $name
          override def ordinal(): Int = _$ordinal
          def fromProduct(p: Product): Object = this.fromProduct(p)
        }
        new
          Color with scala.runtime.EnumValue with
            scala.deriving.Mirror.Singleton
           {...}
        ():Color
      }
    def fromOrdinal(ordinal: Int): Color =
      try Color.$values.[]apply(ordinal) catch
        {
          case _ =>
            throw
              new java.util.NoSuchElementException(
                scala.Int.box(ordinal).toString()
              )
        }
    def ordinal(x$0: Color): Int = x$0.ordinal()
    def ordinal(x: Object): Int = this.ordinal(x.asInstanceOf[Color])
  }