fix #9873: move scala.Enum to scala.reflect.Enum

bishabosha · bishabosha · commit 8f21d244a6ae · 2020-10-05T14:27:57.000+02:00
scala.reflect.Enum is now a universal super trait.

Also avoid using derivesFrom(defn.EnumClass) and
instead look for enum flag.
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/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.
 
@@ -621,10 +622,10 @@ object desugar {
     var parents1 = parents
     if (isEnumCase && parents.isEmpty)
       parents1 = enumClassTypeRef :: Nil
-    if (isCaseClass | isCaseObject)
+    if (isNonEnumCase)
       parents1 = parents1 :+ scalaDot(str.Product.toTypeName) :+ scalaDot(nme.Serializable.toTypeName)
     if (isEnum)
-      parents1 = parents1 :+ ref(defn.EnumClass.typeRef)
+      parents1 = parents1 :+ ref(defn.EnumClass)
 
     // derived type classes of non-module classes go to their companions
     val (clsDerived, companionDerived) =
diff --git a/compiler/src/dotty/tools/dotc/ast/DesugarEnums.scala b/compiler/src/dotty/tools/dotc/ast/DesugarEnums.scala
@@ -282,10 +282,10 @@ object DesugarEnums {
   private def isJavaEnum(using Context): Boolean = enumClass.derivesFrom(defn.JavaEnumClass)
 
   def ordinalMeth(body: Tree)(using Context): DefDef =
-    DefDef(nme.ordinal, Nil, Nil, TypeTree(defn.IntType), body)
+    DefDef(nme.ordinal, Nil, Nil, TypeTree(defn.IntType), body).withAddedFlags(Synthetic)
 
   def enumLabelMeth(body: Tree)(using Context): DefDef =
-    DefDef(nme.enumLabel, Nil, Nil, TypeTree(defn.StringType), body)
+    DefDef(nme.enumLabel, Nil, Nil, TypeTree(defn.StringType), body).withAddedFlags(Synthetic)
 
   def ordinalMethLit(ord: Int)(using Context): DefDef =
     ordinalMeth(Literal(Constant(ord)))
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -754,7 +754,7 @@ class Definitions {
   @tu lazy val SomeClass: ClassSymbol = requiredClass("scala.Some")
   @tu lazy val NoneModule: Symbol = requiredModule("scala.None")
 
-  @tu lazy val EnumClass: ClassSymbol = requiredClass("scala.Enum")
+  @tu lazy val EnumClass: ClassSymbol = requiredClass("scala.reflect.Enum")
 
   @tu lazy val EnumValueSerializationProxyClass: ClassSymbol = requiredClass("scala.runtime.EnumValueSerializationProxy")
     @tu lazy val EnumValueSerializationProxyConstructor: TermSymbol =
diff --git a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
@@ -171,6 +171,9 @@ object SymUtils {
     self
   }
 
+  def isEnum(using Context): Boolean = self.is(Enum, butNot=JavaDefined)
+  def isEnumClass(using Context): Boolean = isEnum && !self.is(Case)
+
   /** 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))
diff --git a/compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala b/compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala
@@ -94,8 +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 isEnumValue = isEnumCase && clazz.isAnonymousClass && clazz.classParents.head.classSymbol.is(Enum)
+    val isEnumValue = clazz.isAnonymousClass && clazz.classParents.head.classSymbol.is(Enum)
     val isNonJavaEnumValue = isEnumValue && !clazz.derivesFrom(defn.JavaEnumClass)
 
     val symbolsToSynthesize: List[Symbol] =
diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -1094,7 +1094,7 @@ trait Checking {
         // Since enums are classes and Namer checks that classes don't extend multiple classes, we only check the class
         // parent.
         //
-        // Unlike firstParent.derivesFrom(defn.EnumClass), this test allows inheriting from `Enum` by hand;
+        // this test allows inheriting from `Enum` by hand;
         // see enum-List-control.scala.
         report.error(ClassCannotExtendEnum(cls, firstParent), cdef.srcPos)
   }
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2106,7 +2106,8 @@ class Typer extends Namer
     val constr1 = typed(constr).asInstanceOf[DefDef]
     val parentsWithClass = ensureFirstTreeIsClass(parents.mapconserve(typedParent).filterConserve(!_.isEmpty), cdef.nameSpan)
     val parents1 = ensureConstrCall(cls, parentsWithClass)(using superCtx)
-    val firstParent = parents1.head.tpe.dealias.typeSymbol
+    val firstParentTpe = parents1.head.tpe.dealias
+    val firstParent = firstParentTpe.typeSymbol
 
     checkEnumParent(cls, firstParent)
 
@@ -2123,7 +2124,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.isEnum || firstParentTpe.classSymbol.isEnum then
         checkEnum(cdef, cls, firstParent)
       val cdef1 = assignType(cpy.TypeDef(cdef)(name, impl1), cls)
 
diff --git a/library/src-bootstrapped/scala/Enum.scala b/library/src-bootstrapped/scala/Enum.scala
@@ -1,10 +1,5 @@
 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
+@deprecated("scala.Enum has moved to scala.reflect.Enum", "3.0.0-M1")
+type Enum = scala.reflect.Enum
diff --git a/library/src-bootstrapped/scala/reflect/Enum.scala b/library/src-bootstrapped/scala/reflect/Enum.scala
@@ -0,0 +1,10 @@
+package scala.reflect
+
+/** A base trait of all enum classes */
+super trait Enum extends Any, 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
diff --git a/library/src-non-bootstrapped/scala/Enum.scala b/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
diff --git a/library/src-non-bootstrapped/scala/runtime/EnumValueSerializationProxy.java b/library/src-non-bootstrapped/scala/runtime/EnumValueSerializationProxy.java
diff --git a/library/src-non-bootstrapped/scala/runtime/EnumValues.scala b/library/src-non-bootstrapped/scala/runtime/EnumValues.scala
diff --git a/tests/neg/enumsLabel-overrides.scala b/tests/neg/enumsLabel-overrides.scala
@@ -0,0 +1,15 @@
+trait Mixin { def enumLabel: String = "mixin" }
+
+enum Mixed extends Mixin {
+  case B // error: overriding method enumLabel in trait Mixin of type => String;
+}
+
+enum MixedAlso {
+  case C extends MixedAlso with Mixin // error: overriding method enumLabel in trait Mixin of type => String;
+}
+
+trait HasEnumLabel { def enumLabel: String }
+
+enum MyEnum extends HasEnumLabel {
+  case D // ok
+}
diff --git a/tests/neg/enumsLabel-singleimpl.scala b/tests/neg/enumsLabel-singleimpl.scala
@@ -0,0 +1,15 @@
+enum Labelled {
+
+  case A // error: method enumLabel of type => String needs `override` modifier
+
+  def enumLabel: String = "nolabel"
+
+}
+
+enum Ordinalled {
+
+  case A // error: method ordinal of type => Int needs `override` modifier
+
+  def ordinal: Int = -1
+
+}
diff --git a/tests/neg/enumsLabelDef.scala b/tests/neg/enumsLabelDef.scala
diff --git a/tests/neg/supertraits.scala b/tests/neg/supertraits.scala
@@ -11,3 +11,14 @@ case object b
 val y = if ??? then a else b
 val y1: Product = y      // error
 val y2: Serializable = y // error
+
+enum Color {
+  case Red, Green, Blue
+}
+
+enum Nucleobase {
+  case A, C, G, T
+}
+
+val z = if ??? then Color.Red else Nucleobase.G
+val z1: reflect.Enum = z // error: Found: (z : Object) Required: reflect.Enum
diff --git a/tests/patmat/i7186.scala b/tests/patmat/i7186.scala
@@ -1,5 +1,7 @@
 import MIPS._
 
+import deriving.Mirror.SumOf
+
 object MIPS {
   type Labels     = Label | ControlLabel
   type Src        = Register | Constant
@@ -233,8 +235,8 @@ object printMips {
     def getScopedLabel(s: Scoped): String =
       "L" + getScopedId(s)
 
-    def printEnum[E](e: String => Enum, t: E, code: String) = {
-      val num = e(t.toString).ordinal
+    def printEnum[E: SumOf](e: String => E, t: E, code: String) = {
+      val num = summon[SumOf[E]].ordinal(e(t.toString))
         s"$code$num"
     }
   }
diff --git a/tests/pos/enum-List-control.scala b/tests/pos/enum-List-control.scala
@@ -1,4 +1,4 @@
-abstract sealed class List[T] extends Enum
+abstract sealed class List[T] extends reflect.Enum
 object List {
   final class Cons[T](x: T, xs: List[T]) extends List[T] {
     def ordinal = 0
diff --git a/tests/run/generic/Enum.scala b/tests/run/generic/Enum.scala
@@ -22,4 +22,4 @@ object runtime {
     }
     def values: Iterable[E] = myMap.values
   }
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -171,6 +171,9 @@ object SymUtils {`
`171`	`171`	`self`
`172`	`172`	`}`
`173`	`173`
	`174`	`+ def isEnum(using Context): Boolean = self.is(Enum, butNot=JavaDefined)`
	`175`	`+ def isEnumClass(using Context): Boolean = isEnum && !self.is(Case)`
	`176`	`+`
`174`	`177`	`/** Does this symbol refer to anonymous classes synthesized by enum desugaring? */`
`175`	`178`	`def isEnumAnonymClass(using Context): Boolean =`
`176`	`179`	`self.isAnonymousClass && (self.owner.name.eq(nme.DOLLAR_NEW) \|\| self.owner.is(CaseVal))`
Original file line number	Diff line number	Diff line change
`@@ -1094,7 +1094,7 @@ trait Checking {`
`1094`	`1094`	`// Since enums are classes and Namer checks that classes don't extend multiple classes, we only check the class`
`1095`	`1095`	`// parent.`
`1096`	`1096`	`//`
`1097`		- // Unlike firstParent.derivesFrom(defn.EnumClass), this test allows inheriting from `Enum` by hand;
	`1097`	+ // this test allows inheriting from `Enum` by hand;
`1098`	`1098`	`// see enum-List-control.scala.`
`1099`	`1099`	`report.error(ClassCannotExtendEnum(cls, firstParent), cdef.srcPos)`
`1100`	`1100`	`}`