add enumLabel to Mirror.Sum

Author: bishabosha

compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala

@@ -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)) {

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/scala/deriving.scala renamed to library/src-non-bootstrapped/scala/deriving.scala

@@ -0,0 +1,27 @@
+import Nat._, Lst._
+
+def enumLabelOf[E](e: E)(using s: deriving.Mirror.SumOf[E]): String = s.enumLabel(e)
+def ordinalOf[E](e: E)(using s: deriving.Mirror.SumOf[E]): Int = s.ordinal(e)
+
+enum Nat:
+  case S(pred: Nat)
+  case Z
+
+sealed abstract class Lst[+T]
+object Lst:
+  final case class Cdr[+T](t: T, ts: Lst[T]) extends Lst[T]
+  case object NIL                            extends Lst[Nothing]
+
+@main def Test =
+
+  // labels
+  assert(enumLabelOf(S(Z))                  == "S")
+  assert(enumLabelOf(Z)                     == "Z")
+  assert(enumLabelOf(Cdr(1, NIL): Lst[Int]) == "Cdr")
+  assert(enumLabelOf(NIL: Lst[Int])         == "NIL")
+
+  // ordinals
+  assert(ordinalOf(S(Z))                    == 0)
+  assert(ordinalOf(Z)                       == 1)
+  assert(ordinalOf(Cdr(1, NIL): Lst[Int])   == 0)
+  assert(ordinalOf(NIL: Lst[Int])           == 1)