Enum[Nothing] is allowed but has a sharp edge

[som-snytt]

Compiler version

➜  snips ~/projects/dotty/bin/scala -version
Starting scala3 REPL...
Scala compiler version 3.0.0-RC1-bin-SNAPSHOT-git-ce684de -- Copyright 2002-2021, LAMP/EPFL

Minimized code

Starting scala3 REPL...
scala> enum E extends Enum[Nothing] { case X }
// defined class E

scala> E.values
val res0: Array[E] = Array(X)

scala> E.X.getDeclaringClass.getEnumConstants
java.lang.ClassCastException: class [Lrs$line$1$E; cannot be cast to class [Lscala.runtime.Nothing$; ([Lrs$line$1$E; is in unnamed module of loader dotty.tools.repl.AbstractFileClassLoader @d180961; [Lscala.runtime.Nothing$; is in unnamed module of loader java.net.URLClassLoader @4de158ca)
  ... 27 elided

Output

java.lang.ClassCastException

Expectation

I expect an error at compile time for the bad type arg. Or maybe values is Array[Nothing] and throws if non-empty. (I see that Enumerations must contain at least one case.)

Alternatively, maybe it is allowed in Scala but the implementation is tweaked so that Java reflection sees a different (lower bound of) the enum type.

[bishabosha]

I would say the problem here can be summarised in the type returned from getDeclaringClass

scala> E.X.getDeclaringClass                                                                                            
val res0: Class[Nothing] = class rs$line$6$E

which can be safely cast to Class[E]

scala> res0.asInstanceOf[Class[E]].getEnumConstants
val res1: Array[E] = Array(X)

scala> res1(0)                                                                                                         
val res2: E = X

linking comment #11253 (comment) which suggests a fix

[bishabosha]

noting as a test case:

enum E[T](val inner: T) extends Enum[E[Int]] {
  case A extends E[String]("hello")
}

// causes `ClassCastException: java.lang.String cannot be cast to java.lang.Integer`
val res = E.A.getDeclaringClass.getEnumConstants()(0).inner

which suggests that we should check that E[T] <:< j.l.Enum[E[T]], or perhaps that each enum case is a subtype of j.l.Enum applied to its own widened type.

However, there are existing test cases such as enum E[+T] extends java.lang.Enum[E[_]] { ... },

• this fails the check of E[T] <:< java.lang.Enum[E[T]]
• enum E[+T] extends java.lang.Enum[E[T]] { ... } is
  illegal due to the covariant T appearing in invariant position.

[bishabosha]

Short of banning any type arguments for java style enums (would match Java semantics) I am unsure of what to do here.

enum E[+T] extends java.lang.Enum[E[?]] is definitely safe at least, because E.values also has type Array[E[?]]