Use Label field for sum and product mirrors

Author: odersky

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

@@ -326,7 +326,6 @@ object StdNames {
     val AnnotatedType: N        = "AnnotatedType"
     val AppliedTypeTree: N      = "AppliedTypeTree"
     val ArrayAnnotArg: N        = "ArrayAnnotArg"
-    val CaseLabel: N            = "CaseLabel"
     val CAP: N                  = "CAP"
     val Constant: N             = "Constant"
     val ConstantType: N         = "ConstantType"
@@ -338,6 +337,7 @@ object StdNames {
     val floatHash: N            = "floatHash"
     val Ident: N                = "Ident"
     val Import: N               = "Import"
+    val Label: N                = "Label"
     val Literal: N              = "Literal"
     val LiteralAnnotArg: N      = "LiteralAnnotArg"
     val longHash: N             = "longHash"

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

@@ -367,6 +367,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
    *        case _: C_1 => 0
    *        ...
    *        case _: C_n => n - 1
+   *     }
    *
    *  Here, the normalized type of a class C is C[_, ...., _] with
    *  a wildcard for each type parameter. The normalized type of an object

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -821,23 +821,23 @@ trait Implicits { self: Typer =>
         case monoAlias @ TypeAlias(monoType) =>
           if (monoType.termSymbol.is(CaseVal)) {
             val modul = monoType.termSymbol
-            val caseLabel = ConstantType(Constant(modul.name.toString))
+            val label = ConstantType(Constant(modul.name.toString))
             val mirrorType = defn.Mirror_SingletonType
               .refinedWith(tpnme.MonoType, monoAlias)
-              .refinedWith(tpnme.CaseLabel, TypeAlias(caseLabel))
+              .refinedWith(tpnme.Label, TypeAlias(label))
             ref(modul).withSpan(span).cast(mirrorType)
           }
           else if (monoType.classSymbol.isGenericProduct) {
             val cls = monoType.classSymbol
             val accessors = cls.caseAccessors.filterNot(_.is(PrivateLocal))
             val elemTypes = accessors.map(monoType.memberInfo(_))
-            val caseLabel = ConstantType(Constant(cls.name.toString))
+            val label = ConstantType(Constant(cls.name.toString))
             val elemLabels = accessors.map(acc => ConstantType(Constant(acc.name.toString)))
             val mirrorType =
               defn.Mirror_ProductType
                 .refinedWith(tpnme.MonoType, monoAlias)
                 .refinedWith(tpnme.ElemTypes, TypeAlias(TypeOps.nestedPairs(elemTypes)))
-                .refinedWith(tpnme.CaseLabel, TypeAlias(caseLabel))
+                .refinedWith(tpnme.Label, TypeAlias(label))
                 .refinedWith(tpnme.ElemLabels, TypeAlias(TypeOps.nestedPairs(elemLabels)))
             val modul = cls.linkedClass.sourceModule
             assert(modul.is(Module))
@@ -853,6 +853,7 @@ trait Implicits { self: Typer =>
       formal.member(tpnme.MonoType).info match {
         case monoAlias @ TypeAlias(monoType) if monoType.classSymbol.isGenericSum =>
           val cls = monoType.classSymbol
+          val label = ConstantType(Constant(cls.name.toString))
           val elemTypes = cls.children.map {
             case caseClass: ClassSymbol =>
               assert(caseClass.is(Case))
@@ -880,6 +881,7 @@ trait Implicits { self: Typer =>
           val mirrorType =
             defn.Mirror_SumType
               .refinedWith(tpnme.MonoType, monoAlias)
+              .refinedWith(tpnme.Label, TypeAlias(label))
               .refinedWith(tpnme.ElemTypes, TypeAlias(TypeOps.nestedPairs(elemTypes)))
           var modul = cls.linkedClass.sourceModule
           val mirrorRef =

library/src/scala/deriving.scala

@@ -8,13 +8,17 @@ object deriving {
 
     /** The mirrored *-type */
     type MonoType
+
+    /** The name of the type */
+    type Label <: String
   }
 
   object Mirror {
 
     /** The Mirror for a sum type */
     trait Sum extends Mirror { self =>
 
+      /** The types of the alternatives */
       type ElemTypes <: Tuple
 
       /** The ordinal number of the case class of `x`. For enums, `ordinal(x) == x.ordinal` */
@@ -24,12 +28,9 @@ object deriving {
     /** The Mirror for a product type */
     trait Product extends Mirror {
 
-      /** The types of the elements */
+      /** The types of the product elements */
       type ElemTypes <: Tuple
 
-      /** The name of the whole product type */
-      type CaseLabel <: String
-
       /** The names of the product elements */
       type ElemLabels <: Tuple