make values and valueOf only available on enumerations

Author: bishabosha

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

@@ -152,7 +152,7 @@ object DesugarEnums {
   }
 
   private def enumLookupMethods(constraints: EnumConstraints)(using Context): List[Tree] =
-    def scaffolding: List[Tree] = if constraints.cached then enumScaffolding(constraints.enumCases.map(_._2)) else Nil
+    def scaffolding: List[Tree] = if constraints.isEnumeration then enumScaffolding(constraints.enumCases.map(_._2)) else Nil
     def valueCtor: List[Tree] = if constraints.requiresCreator then enumValueCreator :: Nil else Nil
     def fromOrdinal: Tree =
       def throwArg(ordinal: Tree) =

tests/neg/enum-values.scala

@@ -0,0 +1,25 @@
+enum Tag[T]:
+  case Int extends Tag[Int]
+  case String extends Tag[String]
+  case OfClass[T]()(using val tag: reflect.ClassTag[T]) extends Tag[T]
+
+enum ListLike[+T]:
+  case Cons[T](head: T, tail: ListLike[T]) extends ListLike[T]
+  case EmptyListLike
+
+enum TypeCtorsK[F[_]]:
+  case List       extends TypeCtorsK[List]
+  case Option     extends TypeCtorsK[Option]
+  case Const[T]() extends TypeCtorsK[[U] =>> T]
+
+def Test: Unit =
+  import Tag._, ListLike._, TypeCtorsK._
+  import reflect.Selectable.reflectiveSelectable
+
+  val tags: Array[Tag[?]]              = Tag.values // error: value values is not a member of object Tag
+  val listlikes: Array[ListLike[?]]    = ListLike.values // error: value values is not a member of object ListLike
+  val typeCtorsK: Array[TypeCtorsK[?]] = TypeCtorsK.values // error: value values is not a member of object TypeCtorsK
+
+  Tag.valueOf("Int") // error: value valueOf is not a member of object Tag
+  ListLike.valueOf("EmptyListLike") // error: value valueOf is not a member of object ListLike
+  TypeCtorsK.valueOf("Option") // error: value valueOf is not a member of object TypeCtorsK

tests/run/enum-custom-toString.scala

@@ -59,17 +59,14 @@ object Tag:
   assert(EZ.E(0).productPrefix == "E",        s"EZ.E(0).productPrefix = ${EZ.E(0).productPrefix}")
   assert(EC.F.toString == "F",                s"EC.F.toString = ${EC.F.toString}")
   assert(EC.F.productPrefix == "F",           s"EC.F.productPrefix = ${EC.F.productPrefix}")
-  assert(EC.valueOf("F") == EC.F,             s"EC.valueOf(F) = ${EC.valueOf("F")}")
   assert(EC.G(0).toString == "G(0)",          s"EC.G(0).toString = ${EC.G(0).toString}")
   assert(EC.G(0).productPrefix == "G",        s"EC.G(0).productPrefix = ${EC.G(0).productPrefix}")
   assert(EO.H.toString == "overridden",       s"EO.H.toString = ${EO.H.toString}")
   assert(EO.H.productPrefix == "noprefix",    s"EO.H.productPrefix = ${EO.H.productPrefix}")
-  assert(EO.valueOf("H") == EO.H,             s"EO.valueOf(H) = ${EO.valueOf("H")}")
   assert(EO.I(0).toString == "overridden",    s"EO.I(0).toString = ${EO.I(0).toString}")
   assert(EO.I(0).productPrefix == "noprefix", s"EO.I(0).productPrefix = ${EO.I(0).productPrefix}")
   assert(EQ.J.toString == "overridden",       s"EQ.J.toString = ${EQ.J.toString}")
   assert(EQ.J.productPrefix == "noprefix",    s"EQ.J.productPrefix = ${EQ.J.productPrefix}")
-  assert(EQ.valueOf("J") == EQ.J,             s"EQ.valueOf(J) = ${EQ.valueOf("J")}")
   assert(EQ.K(0).toString == "overridden",    s"EQ.K(0).toString = ${EQ.K(0).toString}")
   assert(EQ.K(0).productPrefix == "noprefix", s"EQ.K(0).productPrefix = ${EQ.K(0).productPrefix}")
   assert(Tag.IntTag.productPrefix == "",      s"Tag.IntTag.productPrefix = ${Tag.IntTag.productPrefix}")

tests/run/enum-values.scala

@@ -80,31 +80,21 @@ enum ClassOnly: // this should still generate the `ordinal` and `fromOrdinal` co
 
   assert(summon[Mirror.SumOf[ClassOnly]].ordinal(BranchProd(1)) == 0)
 
-  val colors: Array[Color]             = Color.values
-  val tags: Array[Tag[?]]              = Tag.values
-  val exprs: Array[Expr[? >: Null]]    = Expr.values
-  val listlikes: Array[ListLike[?]]    = ListLike.values
-  val typeCtorsK: Array[TypeCtorsK[?]] = TypeCtorsK.values
-
+  val colors: Array[Color] = Color.values
+  val exprs: Array[Expr[? >: Null]] = Expr.values
   val mixedParams: Array[MixedParams[?, ? <: [X, Y] =>> collection.Map[X, Y], ?]] = MixedParams.values
 
   def sameAs[T](arr: Array[T], compare: T*): Unit =
     assert(arr sameElements compare, s"${arr.show} does not correspond to ${compare.show}")
 
   sameAs(colors,      Red, Green, Blue)
-  sameAs(tags,        Int, String)
   sameAs(exprs,       EmptyTree, AnyTree)
-  sameAs(listlikes,   EmptyListLike)
-  sameAs(typeCtorsK,  List, Option)
   sameAs(mixedParams, Foo)
 
   def singleton[E <: AnyRef](value: E, name: String, companion: ValueOf[E]) =
     val lookup = companion.valueOf(name)
     assert(value eq lookup, s"${value.show} is not identical to ${lookup.show}")
 
   singleton(Green, "Green", Color)
-  singleton(String, "String", Tag)
   singleton(AnyTree, "AnyTree", Expr)
-  singleton(EmptyListLike, "EmptyListLike", ListLike)
-  singleton(Option, "Option", TypeCtorsK)
   singleton(Foo, "Foo", MixedParams)

tests/run/enums-java-compat.scala

@@ -1,14 +1,19 @@
-class JEnum {
-  def name: String = "Foo"
-  def action = "fofofo"
+trait JEnum[E <: JEnum[E]] { self: reflect.Enum =>
+  final def name: String = productPrefix
 }
 
-enum A extends JEnum {
+trait JEnumCompanion[E <: JEnum[E]] {
+  def valueOf(name: String): E
+  def values: Array[E]
+}
+
+enum A extends JEnum[A] {
   case MONDAY, TUESDAY, SATURDAY
   case Stuff
-  case Someday(x: String)
+  // case Someday(x: String) // uncommenting this line will prevent `object A` from compiling
   def report = "Reported"
 }
+object A extends JEnumCompanion[A]
 
 trait Foo1
 trait Bar
@@ -37,4 +42,4 @@ object Test {
       println("Correctly failed to retrieve illegal name, message: " + e.getMessage)
     }
   }
-}
+}

tests/semanticdb/metac.expect

@@ -641,7 +641,7 @@ Schema => SemanticDB v4
 Uri => Enums.scala
 Text => empty
 Language => Scala
-Symbols => 185 entries
+Symbols => 181 entries
 Occurrences => 203 entries
 
 Symbols:
@@ -697,7 +697,6 @@ _empty_/Enums.Maybe# => abstract sealed enum class Maybe
 _empty_/Enums.Maybe#[A] => covariant typeparam A
 _empty_/Enums.Maybe#`<init>`(). => primary ctor <init>
 _empty_/Enums.Maybe. => final object Maybe
-_empty_/Enums.Maybe.$values. => val method $values
 _empty_/Enums.Maybe.Just# => final case enum class Just
 _empty_/Enums.Maybe.Just#[A] => covariant typeparam A
 _empty_/Enums.Maybe.Just#_1(). => method _1
@@ -721,9 +720,6 @@ _empty_/Enums.Maybe.Just.unapply().[A] => typeparam A
 _empty_/Enums.Maybe.None. => case val static enum method None
 _empty_/Enums.Maybe.fromOrdinal(). => method fromOrdinal
 _empty_/Enums.Maybe.fromOrdinal().(ordinal) => param ordinal
-_empty_/Enums.Maybe.valueOf(). => method valueOf
-_empty_/Enums.Maybe.valueOf().($name) => param $name
-_empty_/Enums.Maybe.values(). => method values
 _empty_/Enums.Planet# => abstract sealed enum class Planet
 _empty_/Enums.Planet#G. => final val method G
 _empty_/Enums.Planet#`<init>`(). => primary ctor <init>

tests/sjs-junit/test/org/scalajs/testsuite/compiler/EnumTestScala3.scala

@@ -135,8 +135,6 @@ class EnumTestScala3:
     assert(Opt.Nn.ordinal == 1)
     assert(Opt.Sm(1).productPrefix == "Sm")
     assert(Opt.Nn.productPrefix == "Nn")
-    assert(Opt.valueOf("Nn") == Opt.Nn)
-    assert(Opt.values(0) == Opt.Nn)
     assert(Opt.Sm("hello").value == "hello")
     assert(encode(Opt.Sm(23)) == 23)
     assert(encode(Opt.Nn)     == null)