fix #9873: deprecate scala.Enum, no longer use it as parent of enums

this commit introduces the concept that some desugaring expansion
can occur after parents of the current class are known, i.e. methods
that contain no references like ordinal and enumLabel.

Author: bishabosha

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

@@ -403,6 +403,7 @@ object desugar {
     val isCaseObject = mods.is(Case) && isObject
     val isEnum = mods.isEnumClass && !mods.is(Module)
     def isEnumCase = mods.isEnumCase
+    def isNonEnumCase = !isEnumCase && (isCaseClass || isCaseObject)
     val isValueClass = parents.nonEmpty && isAnyVal(parents.head)
       // This is not watertight, but `extends AnyVal` will be replaced by `inline` later.
 
@@ -483,7 +484,8 @@ object desugar {
         val enumCompanionRef = TermRefTree()
         val enumImport =
           Import(enumCompanionRef, enumCases.flatMap(caseIds).map(ImportSelector(_)))
-        (enumImport :: enumStats, enumCases, enumCompanionRef)
+        val enumSpecMethods = EnumGetters()
+        (enumImport :: enumSpecMethods :: enumStats, enumCases, enumCompanionRef)
       }
       else (stats, Nil, EmptyTree)
     }
@@ -621,10 +623,8 @@ object desugar {
     var parents1 = parents
     if (isEnumCase && parents.isEmpty)
       parents1 = enumClassTypeRef :: Nil
-    if (isCaseClass | isCaseObject)
+    if (isNonEnumCase || isEnum)
       parents1 = parents1 :+ scalaDot(str.Product.toTypeName) :+ scalaDot(nme.Serializable.toTypeName)
-    if (isEnum)
-      parents1 = parents1 :+ ref(defn.EnumClass.typeRef)
 
     // derived type classes of non-module classes go to their companions
     val (clsDerived, companionDerived) =
@@ -890,6 +890,9 @@ object desugar {
     }
   }
 
+  def enumGetters(getters: EnumGetters)(using Context): Tree =
+   flatTree(DesugarEnums.enumBaseMeths).withSpan(getters.span)
+
   /** Transform extension construct to list of extension methods */
   def extMethods(ext: ExtMethods)(using Context): Tree = flatTree {
     for mdef <- ext.methods yield

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

@@ -322,6 +322,13 @@ object DesugarEnums {
       (ordinal, Nil)
   }
 
+  def enumBaseMeths(using Context): List[Tree] =
+    val ordinalDef = DefDef(nme.ordinal, Nil, Nil, ref(defn.IntType), EmptyTree)
+    val enumLabelDef = DefDef(nme.enumLabel, Nil, Nil, ref(defn.StringClass.typeRef), EmptyTree)
+    val base = enumLabelDef :: Nil
+    if isJavaEnum then base
+    else ordinalDef :: base
+
   def param(name: TermName, typ: Type)(using Context): ValDef = param(name, TypeTree(typ))
   def param(name: TermName, tpt: Tree)(using Context): ValDef = ValDef(name, tpt, EmptyTree).withFlags(Param)
 

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

@@ -116,6 +116,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   case class Export(expr: Tree, selectors: List[ImportSelector])(implicit @constructorOnly src: SourceFile) extends Tree
   case class ExtMethods(tparams: List[TypeDef], vparamss: List[List[ValDef]], methods: List[DefDef])(implicit @constructorOnly src: SourceFile) extends Tree
   case class MacroTree(expr: Tree)(implicit @constructorOnly src: SourceFile) extends Tree
+  case class EnumGetters()(implicit @constructorOnly src: SourceFile) extends Tree
 
   case class ImportSelector(imported: Ident, renamed: Tree = EmptyTree, bound: Tree = EmptyTree)(implicit @constructorOnly src: SourceFile) extends Tree {
     // TODO: Make bound a typed tree?
@@ -700,6 +701,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         cpy.Export(tree)(transform(expr), selectors)
       case ExtMethods(tparams, vparamss, methods) =>
         cpy.ExtMethods(tree)(transformSub(tparams), vparamss.mapConserve(transformSub(_)), transformSub(methods))
+      case enums: EnumGetters => enums
       case ImportSelector(imported, renamed, bound) =>
         cpy.ImportSelector(tree)(transformSub(imported), transform(renamed), transform(bound))
       case Number(_, _) | TypedSplice(_) =>
@@ -761,6 +763,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         this(x, expr)
       case ExtMethods(tparams, vparamss, methods) =>
         this(vparamss.foldLeft(this(x, tparams))(apply), methods)
+      case EnumGetters() =>
+        x
       case ImportSelector(imported, renamed, bound) =>
         this(this(this(x, imported), renamed), bound)
       case Number(_, _) =>

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

@@ -168,6 +168,8 @@ object SymUtils {
     self
   }
 
+  def isScalaEnum(using Context): Boolean = self.is(Enum, butNot=JavaDefined)
+
   /** Does this symbol refer to anonymous classes synthesized by enum desugaring? */
   def isEnumAnonymClass(using Context): Boolean =
     self.isAnonymousClass && (self.owner.name.eq(nme.DOLLAR_NEW) || self.owner.is(CaseVal))

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

@@ -94,7 +94,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     lazy val accessors =
       if (isDerivedValueClass(clazz)) clazz.paramAccessors.take(1) // Tail parameters can only be `erased`
       else clazz.caseAccessors
-    val isEnumCase = clazz.derivesFrom(defn.EnumClass) && clazz != defn.EnumClass
+    val isEnumCase = clazz.classParents.exists(_.typeSymbol.isScalaEnum)
     val isEnumValue = isEnumCase && clazz.isAnonymousClass && clazz.classParents.head.classSymbol.is(Enum)
     val isNonJavaEnumValue = isEnumValue && !clazz.derivesFrom(defn.JavaEnumClass)
 

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -343,17 +343,20 @@ class Namer { typer: Typer =>
         tree.pushAttachment(ExpandedTree, expanded)
       }
     tree match {
-      case tree: DefTree    => record(desugar.defTree(tree))
-      case tree: PackageDef => record(desugar.packageDef(tree))
-      case tree: ExtMethods => record(desugar.extMethods(tree))
-      case _                =>
+      case tree: DefTree     => record(desugar.defTree(tree))
+      case tree: PackageDef  => record(desugar.packageDef(tree))
+      case tree: ExtMethods  => record(desugar.extMethods(tree))
+      case tree: EnumGetters => record(desugar.enumGetters(tree))
+      case _                 =>
     }
   }
 
   /** The expanded version of this tree, or tree itself if not expanded */
   def expanded(tree: Tree)(using Context): Tree = tree match {
-    case _: DefTree | _: PackageDef | _: ExtMethods => tree.attachmentOrElse(ExpandedTree, tree)
-    case _ => tree
+    case _: DefTree | _: PackageDef | _: ExtMethods | _: EnumGetters =>
+      tree.attachmentOrElse(ExpandedTree, tree)
+    case _ =>
+      tree
   }
 
   /** For all class definitions `stat` in `xstats`: If the companion class is
@@ -925,11 +928,17 @@ class Namer { typer: Typer =>
 
     val TypeDef(name, impl @ Template(constr, _, self, _)) = original
 
-    private val (params, rest): (List[Tree], List[Tree]) = impl.body.span {
+    private val (params, restOfBody): (List[Tree], List[Tree]) = impl.body.span {
       case td: TypeDef => td.mods.is(Param)
       case vd: ValDef => vd.mods.is(ParamAccessor)
       case _ => false
     }
+    private val (restAfterParents, rest): (List[Tree], List[Tree]) =
+      if original.mods.isEnumClass then
+        val (imports :: getters :: Nil, stats): @unchecked = restOfBody.splitAt(2)
+        (getters :: Nil, imports :: stats) // enum getters desugaring needs to test if a parent is java.lang.Enum
+      else
+        (Nil, restOfBody)
 
     def init(): Context = index(params)
 
@@ -1196,6 +1205,7 @@ class Namer { typer: Typer =>
       cls.setNoInitsFlags(parentsKind(parents), untpd.bodyKind(rest))
       if (cls.isNoInitsClass) cls.primaryConstructor.setFlag(StableRealizable)
       processExports(using localCtx)
+      index(restAfterParents)(using localCtx)
     }
   }
 

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2122,7 +2122,7 @@ class Typer extends Namer
         .withType(dummy.termRef)
       if (!cls.isOneOf(AbstractOrTrait) && !ctx.isAfterTyper)
         checkRealizableBounds(cls, cdef.sourcePos.withSpan(cdef.nameSpan))
-      if cls.derivesFrom(defn.EnumClass) then
+      if cls.isScalaEnum || firstParent.isScalaEnum then
         checkEnum(cdef, cls, firstParent)
       val cdef1 = assignType(cpy.TypeDef(cdef)(name, impl1), cls)
 
@@ -2606,7 +2606,7 @@ class Typer extends Namer
       case (mdef: untpd.DefTree) :: rest =>
         mdef.removeAttachment(ExpandedTree) match {
           case Some(xtree) =>
-            traverse(xtree :: rest)
+            traverse(flatten(xtree :: rest))
           case none =>
             val newCtx = if (ctx.owner.isTerm && adaptCreationContext(mdef)) ctx
               else ctx.withNotNullInfos(initialNotNullInfos)
@@ -2635,6 +2635,9 @@ class Typer extends Namer
       case (stat: untpd.ExtMethods) :: rest =>
         val xtree = stat.removeAttachment(ExpandedTree).get
         traverse(xtree :: rest)
+      case (stat: untpd.EnumGetters) :: rest =>
+        val xtree = stat.removeAttachment(ExpandedTree).get
+        traverse(xtree :: rest)
       case stat :: rest =>
         val stat1 = typed(stat)(using ctx.exprContext(stat, exprOwner))
         checkStatementPurity(stat1)(stat, exprOwner)

library/src-bootstrapped/scala/Enum.scala

@@ -1,6 +1,7 @@
 package scala
 
-/** A base trait of all enum classes */
+/** A Product that also describes a label and ordinal */
+@deprecated("scala.Enum is no longer supported", "3.0.0-M1")
 trait Enum extends Product, Serializable:
 
   /** A string uniquely identifying a case of an enum */

library/src-non-bootstrapped/scala/Enum.scala

@@ -3,5 +3,8 @@ package scala
 /** A base trait of all enum classes */
 trait Enum extends Product, Serializable:
 
+  /** A string uniquely identifying a case of an enum */
+  def enumLabel: String
+
   /** A number uniquely identifying a case of an enum */
   def ordinal: Int

library/src-non-bootstrapped/scala/runtime/EnumValueSerializationProxy.java

@@ -22,4 +22,4 @@ object runtime {
     }
     def values: Iterable[E] = myMap.values
   }
-}
+}