enum values array is constructed from field references

This patches a regression introduced in #9628 where
defining an enum local to a method can cause an infinite loop
at initialisation of its companion.

Instead, we select enum values from "this" and not the companion,
which avoids forcing initialisation of the companion. We then
ascribe the values array with unchecked annotation to avoid
complaints from the init checker.

Author: bishabosha

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

@@ -104,7 +104,7 @@ object DesugarEnums {
 
   /**  The following lists of definitions for an enum type E and known value cases e_0, ..., e_n:
    *
-   *   private val $values = Array[E](e_0,...,e_n)(ClassTag[E](classOf[E]))
+   *   private val $values = Array[E](e_0,...,e_n)(ClassTag[E](classOf[E])): @unchecked
    *   def values = $values.clone
    *   def valueOf($name: String) = $name match {
    *     case "e_0" => e_0
@@ -117,9 +117,11 @@ object DesugarEnums {
     val rawEnumClassRef = rawRef(enumClass.typeRef)
     extension (tpe: NamedType) def ofRawEnum = AppliedTypeTree(ref(tpe), rawEnumClassRef)
 
-    val lazyFlagOpt = if enumCompanion.owner.isStatic then EmptyFlags else Lazy
-    val privateValuesDef = ValDef(nme.DOLLAR_VALUES, TypeTree(), ArrayLiteral(enumValues, rawEnumClassRef))
-      .withFlags(Private | Synthetic | lazyFlagOpt)
+    val privateValuesDef =
+      val uncheckedValues =
+        Annotated(ArrayLiteral(enumValues, rawEnumClassRef), New(ref(defn.UncheckedAnnot.typeRef)))
+      ValDef(nme.DOLLAR_VALUES, TypeTree(), uncheckedValues)
+        .withFlags(Private | Synthetic)
 
     val valuesDef =
       DefDef(nme.values, Nil, Nil, defn.ArrayType.ofRawEnum, valuesDot(nme.clone_))
@@ -170,7 +172,6 @@ object DesugarEnums {
    *     def ordinal = _$ordinal   // if `E` does not derive from `java.lang.Enum`
    *     def enumLabel = $name     // if `E` does not derive from `java.lang.Enum`
    *     def enumLabel = this.name // if `E` derives from `java.lang.Enum`
-   *     $values.register(this)
    *   }
    */
   private def enumValueCreator(using Context) = {
@@ -307,8 +308,8 @@ object DesugarEnums {
       case name: TermName => (ordinal, name) :: seenCases
       case _              => seenCases
     if definesLookups then
-      val companionRef = ref(enumCompanion.termRef)
-      val cachedValues = cases.reverse.map((i, name) => (i, Select(companionRef, name)))
+      val thisRef = This(EmptyTypeIdent)
+      val cachedValues = cases.reverse.map((i, name) => (i, Select(thisRef, name)))
       (ordinal, enumLookupMethods(EnumConstraints(minKind, maxKind, cachedValues)))
     else
       ctx.tree.pushAttachment(EnumCaseCount, (ordinal + 1, minKind, maxKind, cases))

tests/run/enums-thunk.scala

@@ -20,8 +20,22 @@ object Outer2 {
   }
 }
 
+object Outer3 {
+  def thunk() = {
+    enum E { case C1 }
+    E.C1
+  }
+  def thunk2() = {
+    enum E { case C2 }
+    E.values
+  }
+}
+
+
 @main def Test =
   assert(Outer().thunk().toString == "A1")
   assert(Outer().thunk2()(0).toString == "A2")
   assert(Outer2.thunk().toString == "B1")
   assert(Outer2.thunk2()(0).toString == "B2")
+  assert(Outer3.thunk().toString == "C1")
+  assert(Outer3.thunk2()(0).toString == "C2")