Add enum companion reflection to scala.reflect

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

@@ -736,7 +736,19 @@ object desugar {
 
         companionDefs(anyRef, applyMeths ::: unapplyMeth :: toStringMeth :: companionMembers)
       }
-      else if (companionMembers.nonEmpty || companionDerived.nonEmpty || isEnum)
+      else if (isEnum)
+        val isSingletonEnum = companionMembers.forall {
+          case _ : PatDef => true
+          case _ : ModuleDef => true
+          case _ => false
+        }
+        val enumCompClass =
+          if (isSingletonEnum) defn.SingletonEnumCompanionClass.typeRef
+          else defn.EnumCompanionClass.typeRef
+        val clsWithArgs = appliedTypeTree(Ident(className), impliedTparams.map(_ => WildcardTypeBoundsTree()))
+        val parent = appliedTypeTree(ref(enumCompClass), clsWithArgs :: Nil)
+        companionDefs(parent, companionMembers)
+      else if (companionMembers.nonEmpty || companionDerived.nonEmpty)
         companionDefs(anyRef, companionMembers)
       else if (isValueClass)
         companionDefs(anyRef, Nil)

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -740,6 +740,8 @@ class Definitions {
 
   @tu lazy val EnumClass: ClassSymbol = requiredClass("scala.reflect.Enum")
     @tu lazy val Enum_ordinal: Symbol = EnumClass.requiredMethod(nme.ordinal)
+  @tu lazy val EnumCompanionClass: ClassSymbol = requiredClass("scala.reflect.EnumCompanion")
+  @tu lazy val SingletonEnumCompanionClass: ClassSymbol = requiredClass("scala.reflect.SingletonEnumCompanion")
 
   @tu lazy val EnumValueSerializationProxyClass: ClassSymbol = requiredClass("scala.runtime.EnumValueSerializationProxy")
     @tu lazy val EnumValueSerializationProxyConstructor: TermSymbol =

library/src/scala/reflect/Enum.scala

@@ -5,3 +5,11 @@ package scala.reflect
 
   /** A number uniquely identifying a case of an enum */
   def ordinal: Int
+
+/** A base trait of all Scala enum companion definitions */
+@annotation.transparentTrait trait EnumCompanion[E <: Enum] extends AnyRef
+
+/** A base trait of all Scala singleton enum companion definitions */
+@annotation.transparentTrait trait SingletonEnumCompanion[E <: Enum] extends EnumCompanion[E]:
+  def values : Array[E]
+  def valueOf(name : String) : E

tests/init/neg/enum-desugared.scala

@@ -8,7 +8,7 @@ sealed abstract class ErrorMessageID($name: String, _$ordinal: Int)
   def errorNumber: Int = this.ordinal() - 2
 }
 
-object ErrorMessageID {
+object ErrorMessageID extends scala.reflect.EnumCompanion[ErrorMessageID]{
 
   final val LazyErrorId = $new(0, "LazyErrorId")
   final val NoExplanationID = $new(1, "NoExplanationID")

tests/run/enum-reflect-companion.scala

@@ -0,0 +1,48 @@
+import scala.reflect.{EnumCompanion, SingletonEnumCompanion}
+enum Foo1:
+  case Baz, Bar
+
+val check1 = summon[Foo1.type <:< SingletonEnumCompanion[Foo1]]
+
+enum Foo2[T]:
+  case Baz extends Foo2[1]
+  case Bar extends Foo2[2]
+
+val check2 = summon[Foo2.type <:< SingletonEnumCompanion[Foo2[?]]]
+
+enum Foo3[A, B[_]]:
+  case Baz extends Foo3[Int, List]
+  case Bar extends Foo3[Int, List]
+
+val check3 = summon[Foo3.type <:< SingletonEnumCompanion[Foo3[?, ?]]]
+
+extension [T <: reflect.Enum](enumCompanion : SingletonEnumCompanion[T])
+  def check(arg : T) : Unit = assert(enumCompanion.values.contains(arg))
+
+enum Foo4:
+  case Yes
+  case No(whyNot: String)
+  case Skip
+
+val check4 = summon[Foo4.type <:< EnumCompanion[Foo4]]
+
+@main def Test : Unit =
+  Foo3.check(Foo3.Bar)
+  (Foo3 : AnyRef) match
+    case _ : SingletonEnumCompanion[?] =>
+    case _ : EnumCompanion[?] => assert(false)
+    case _  => assert(false)
+
+  (Foo4 : AnyRef) match
+    case _ : SingletonEnumCompanion[?] => assert(false)
+    case _ : EnumCompanion[?] =>
+    case _  => assert(false)
+
+enum Foo5:
+  case Baz, Bar
+
+trait Hello
+object Foo5 extends Hello
+
+//TODO: fix implementation so this would work
+//val check5 = summon[Foo5.type <:< scala.reflect.EnumCompanion[Foo5] with Hello]