fix #9873: no longer use scala.Enum as parents of enums

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,12 @@ object DesugarEnums {
  (ordinal, Nil)
  }
 
+ def enumBaseMeths(using Context): List[Tree] =
+ if isJavaEnum then
+ enumLabelMeth(EmptyTree) :: Nil
+ else
+ ordinalMeth(EmptyTree) :: enumLabelMeth(EmptyTree) :: Nil
+
  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/reporting/ErrorMessageID.scala

@@ -167,7 +167,8 @@ enum ErrorMessageID extends java.lang.Enum[ErrorMessageID] {
  ModifierNotAllowedForDefinitionID,
  CannotExtendJavaEnumID,
  InvalidReferenceInImplicitNotFoundAnnotationID,
- TraitMayNotDefineNativeMethodID
+ TraitMayNotDefineNativeMethodID,
+ EnumGettersRedefinitionID
 
  def errorNumber = ordinal - 2
 }

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -2031,6 +2031,10 @@ import ast.tpd
  def explain = ""
  }
 
+ class EnumGettersRedefinition(decl: Symbol)(using Context) extends NamingMsg(EnumGettersRedefinitionID):
+ def msg = em"redefinition of $decl: ${decl.info} in an ${hl("enum")}"
+ def explain = em"users may not supply their own definition for $decl when inside an ${hl("enum")}"
+
  class DoubleDefinition(decl: Symbol, previousDecl: Symbol, base: Symbol)(using Context) extends NamingMsg(DoubleDefinitionID) {
  def msg = {
  def nameAnd = if (decl.name != previousDecl.name) " name and" else ""

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)
 
@@ -513,6 +513,34 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
  Match(param, cases)
  }
 
+ /** For an enum T:
+ *
+ * def enumLabel(x: MirroredMonoType) = x.enumLabel
+ *
+ * For sealed trait with children of normalized types C_1, ..., C_n:
+ *
+ * def enumLabel(x: MirroredMonoType) = x match {
+ * case _: C_1 => "C_1"
+ * ...
+ * case _: C_n => "C_n"
+ * }
+ *
+ * Here, the normalized type of a class C is C[?, ...., ?] with
+ * a wildcard for each type parameter. The normalized type of an object
+ * O is O.type.
+ */
+ def enumLabelBody(cls: Symbol, param: Tree)(using Context): Tree =
+ if (cls.is(Enum)) param.select(nme.enumLabel).ensureApplied
+ else {
+ val cases =
+ for ((child, idx) <- cls.children.zipWithIndex) yield {
+ val patType = if (child.isTerm) child.termRef else child.rawTypeRef
+ val pat = Typed(untpd.Ident(nme.WILDCARD).withType(patType), TypeTree(patType))
+ CaseDef(pat, EmptyTree, Literal(Constant(child.name.toString)))
+ }
+ Match(param, cases)
+ }
+
  /** - If `impl` is the companion of a generic sum, add `deriving.Mirror.Sum` parent
  * and `MirroredMonoType` and `ordinal` members.
  * - If `impl` is the companion of a generic product, add `deriving.Mirror.Product` parent
@@ -564,6 +592,8 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
  addParent(defn.Mirror_SumClass.typeRef)
  addMethod(nme.ordinal, MethodType(monoType.typeRef :: Nil, defn.IntType), cls,
  ordinalBody(_, _))
+ addMethod(nme.enumLabel, MethodType(monoType.typeRef :: Nil, defn.StringType), cls,
+ enumLabelBody(_, _))
  }
 
  if (clazz.is(Module)) {

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

@@ -889,7 +889,12 @@ trait Checking {
  if (decl.matches(other) && !javaFieldMethodPair) {
  def doubleDefError(decl: Symbol, other: Symbol): Unit =
  if (!decl.info.isErroneous && !other.info.isErroneous)
- report.error(DoubleDefinition(decl, other, cls), decl.srcPos)
+ if decl.owner.is(Enum, butNot=JavaDefined|Case) && decl.span.isSynthetic && (
+ decl.name == nme.ordinal || decl.name == nme.enumLabel)
+ then
+ report.error(EnumGettersRedefinition(decl), other.srcPos)
+ else
+ report.error(DoubleDefinition(decl, other, cls), decl.srcPos)
  if (decl is Synthetic) doubleDefError(other, decl)
  else doubleDefError(decl, other)
  }

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)
 
@@ -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-bootstrapped/scala/deriving.scala

@@ -0,0 +1,76 @@
+package scala
+
+import quoted._
+
+object deriving {
+
+ /** Mirrors allows typelevel access to enums, case classes and objects, and their sealed parents.
+ */
+ sealed trait Mirror {
+
+ /** The mirrored *-type */
+ type MirroredMonoType
+
+ /** The name of the type */
+ type MirroredLabel <: String
+
+ /** The names of the product elements */
+ type MirroredElemLabels <: Tuple
+ }
+
+ object Mirror {
+
+ /** The Mirror for a sum type */
+ trait Sum extends Mirror { self =>
+ /** The ordinal number of the case class of `x`. For enums, `ordinal(x) == x.ordinal` */
+ def ordinal(x: MirroredMonoType): Int
+ /** The case label of the case class of `x`. For enums, `enumLabel(x) == x.enumLabel` */
+ def enumLabel(x: MirroredMonoType): String
+ }
+
+ /** The Mirror for a product type */
+ trait Product extends Mirror {
+
+ /** Create a new instance of type `T` with elements taken from product `p`. */
+ def fromProduct(p: scala.Product): MirroredMonoType
+ }
+
+ trait Singleton extends Product {
+ type MirroredMonoType = this.type
+ type MirroredType = this.type
+ type MirroredElemTypes = EmptyTuple
+ type MirroredElemLabels = EmptyTuple
+ def fromProduct(p: scala.Product) = this
+ }
+
+ /** A proxy for Scala 2 singletons, which do not inherit `Singleton` directly */
+ class SingletonProxy(val value: AnyRef) extends Product {
+ type MirroredMonoType = value.type
+ type MirroredType = value.type
+ type MirroredElemTypes = EmptyTuple
+ type MirroredElemLabels = EmptyTuple
+ def fromProduct(p: scala.Product) = value
+ }
+
+ type Of[T] = Mirror { type MirroredType = T; type MirroredMonoType = T ; type MirroredElemTypes <: Tuple }
+ type ProductOf[T] = Mirror.Product { type MirroredType = T; type MirroredMonoType = T ; type MirroredElemTypes <: Tuple }
+ type SumOf[T] = Mirror.Sum { type MirroredType = T; type MirroredMonoType = T; type MirroredElemTypes <: Tuple }
+ }
+
+ /** Helper class to turn arrays into products */
+ class ArrayProduct(val elems: Array[AnyRef]) extends Product {
+ def this(size: Int) = this(new Array[AnyRef](size))
+ def canEqual(that: Any): Boolean = true
+ def productElement(n: Int) = elems(n)
+ def productArity = elems.length
+ override def productIterator: Iterator[Any] = elems.iterator
+ def update(n: Int, x: Any) = elems(n) = x.asInstanceOf[AnyRef]
+ }
+
+ /** The empty product */
+ object EmptyProduct extends ArrayProduct(Array.emptyObjectArray)
+
+ /** Helper method to select a product element */
+ def productElement[T](x: Any, idx: Int) =
+ x.asInstanceOf[Product].productElement(idx).asInstanceOf[T]
+}

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