Avoid name clashes by prefixing all type members with Mirrored

odersky · odersky · commit 5edbe579c79d · 2019-05-22T23:24:43.000+02:00
We got a community build failure since a companion object acquired
a `Label` type member by auto-generating a `Mirror` parent. To avoid
name clashes (or at least make thme very unlikely), we now systematically
prefix all type fields with  `Mirrored`.

We probably should do something similar to the auto-generated `ordinal`
and `fromProduct` methods.
diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala
@@ -330,20 +330,20 @@ object StdNames {
     val Constant: N             = "Constant"
     val ConstantType: N         = "ConstantType"
     val doubleHash: N           = "doubleHash"
-    val ElemLabels: N           = "ElemLabels"
-    val ElemTypes: N            = "ElemTypes"
     val ExistentialTypeTree: N  = "ExistentialTypeTree"
     val Flag : N                = "Flag"
     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"
     val MatchCase: N            = "MatchCase"
+    val MirroredElemTypes: N    = "MirroredElemTypes"
+    val MirroredElemLabels: N   = "MirroredElemLabels"
+    val MirroredLabel: N        = "MirroredLabel"
+    val MirroredMonoType: N     = "MirroredMonoType"
     val Modifiers: N            = "Modifiers"
-    val MonoType: N             = "MonoType"
     val NestedAnnotArg: N       = "NestedAnnotArg"
     val NoFlags: N              = "NoFlags"
     val NoPrefix: N             = "NoPrefix"
diff --git a/compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala b/compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala
@@ -323,14 +323,14 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
      *  gets the `fromProduct` method:
      *
      *  ```
-     *  def fromProduct(x$0: Product): MonoType =
+     *  def fromProduct(x$0: Product): MirroredMonoType =
      *    new C[U](
      *      x$0.productElement(0).asInstanceOf[U],
      *      x$0.productElement(1).asInstanceOf[Seq[String]]: _*)
      *  ```
      *  where
      *  ```
-     *  type MonoType = C[_]
+     *  type MirroredMonoType = C[_]
      *  ```
      */
     def fromProductBody(caseClass: Symbol, param: Tree)(implicit ctx: Context): Tree = {
@@ -362,11 +362,11 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
 
   /** For an enum T:
    *
-   *     def ordinal(x: MonoType) = x.enumTag
+   *     def ordinal(x: MirroredMonoType) = x.enumTag
    *
    *  For  sealed trait with children of normalized types C_1, ..., C_n:
    *
-   *     def ordinal(x: MonoType) = x match {
+   *     def ordinal(x: MirroredMonoType) = x match {
    *        case _: C_1 => 0
    *        ...
    *        case _: C_n => n - 1
@@ -389,9 +389,13 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     }
 
   /** - If `impl` is the companion of a generic sum, add `deriving.Mirror.Sum` parent
-   *    and `MonoType` and `ordinal` members.
+   *    and `MirroredMonoType` and `ordinal` members.
    *  - If `impl` is the companion of a generic product, add `deriving.Mirror.Product` parent
-   *    and `MonoType` and `fromProduct` members.
+   *    and `MirroredMonoType` and `fromProduct` members.
+   *  - If `impl` is marked with one of the attachments ExtendsSingletonMirror, ExtendsProductMirror,
+   *    or ExtendsSumMirror, remove the attachment and generate the corresponding mirror support,
+   *    On this case the represented class or object is referred to in a pre-existing `MirroredMonoType`
+   *    member of the template.
    */
   def addMirrorSupport(impl: Template)(implicit ctx: Context): Template = {
     val clazz = ctx.owner.asClass
@@ -415,11 +419,11 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     }
     val linked = clazz.linkedClass
     lazy val monoType = {
-      val existing = clazz.info.member(tpnme.MonoType).symbol
+      val existing = clazz.info.member(tpnme.MirroredMonoType).symbol
       if (existing.exists && !existing.is(Deferred)) existing
       else {
         val monoType =
-          ctx.newSymbol(clazz, tpnme.MonoType, Synthetic, TypeAlias(linked.rawTypeRef), coord = clazz.coord)
+          ctx.newSymbol(clazz, tpnme.MirroredMonoType, Synthetic, TypeAlias(linked.rawTypeRef), coord = clazz.coord)
         newBody = newBody :+ TypeDef(monoType).withSpan(ctx.owner.span.focus)
         monoType.entered
       }
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -815,11 +815,11 @@ trait Implicits { self: Typer =>
           EmptyTree
       }
 
-  /** Create an anonymous class `new Object { type MonoType = ... }`
+  /** Create an anonymous class `new Object { type MirroredMonoType = ... }`
    *  and mark it with given attachment so that it is made into a mirror at PostTyper.
    */
   private def anonymousMirror(monoType: Type, attachment: Property.StickyKey[Unit], span: Span)(implicit ctx: Context) = {
-    val monoTypeDef = untpd.TypeDef(tpnme.MonoType, untpd.TypeTree(monoType))
+    val monoTypeDef = untpd.TypeDef(tpnme.MirroredMonoType, untpd.TypeTree(monoType))
     val newImpl = untpd.Template(
       constr = untpd.emptyConstructor,
       parents = untpd.TypeTree(defn.ObjectType) :: Nil,
@@ -832,14 +832,14 @@ trait Implicits { self: Typer =>
 
   /** The mirror type
    *
-   *     <parent> { MonoType = <monoType; Label = <label> }
+   *     <parent> { MirroredMonoType = <monoType; MirroredLabel = <label> }
    */
   private def mirrorCore(parent: Type, monoType: Type, label: Name)(implicit ctx: Context) =
     parent
-      .refinedWith(tpnme.MonoType, TypeAlias(monoType))
-      .refinedWith(tpnme.Label, TypeAlias(ConstantType(Constant(label.toString))))
+      .refinedWith(tpnme.MirroredMonoType, TypeAlias(monoType))
+      .refinedWith(tpnme.MirroredLabel, TypeAlias(ConstantType(Constant(label.toString))))
 
-  /** An implied instance for a type of the form `Mirror.Product { type MonoType = T }`
+  /** An implied instance for a type of the form `Mirror.Product { type MirroredMonoType = T }`
    *  where `T` is a generic product type or a case object or an enum case.
    */
   lazy val synthesizedProductMirror: SpecialHandler =
@@ -868,8 +868,8 @@ trait Implicits { self: Typer =>
             val elemLabels = accessors.map(acc => ConstantType(Constant(acc.name.toString)))
             val mirrorType =
               mirrorCore(defn.Mirror_ProductType, monoType, cls.name)
-                .refinedWith(tpnme.ElemTypes, TypeAlias(TypeOps.nestedPairs(elemTypes)))
-                .refinedWith(tpnme.ElemLabels, TypeAlias(TypeOps.nestedPairs(elemLabels)))
+                .refinedWith(tpnme.MirroredElemTypes, TypeAlias(TypeOps.nestedPairs(elemTypes)))
+                .refinedWith(tpnme.MirroredElemLabels, TypeAlias(TypeOps.nestedPairs(elemLabels)))
             val modul = cls.linkedClass.sourceModule
             assert(modul.is(Module))
             val mirrorRef =
@@ -879,18 +879,18 @@ trait Implicits { self: Typer =>
           }
           else EmptyTree
       }
-      formal.member(tpnme.MonoType).info match {
+      formal.member(tpnme.MirroredMonoType).info match {
         case monoAlias @ TypeAlias(monoType) => mirrorFor(monoType)
         case _ => EmptyTree
       }
     }
 
-  /** An implied instance for a type of the form `Mirror.Sum { type MonoType = T }`
+  /** An implied instance for a type of the form `Mirror.Sum { type MirroredMonoType = T }`
    *  where `T` is a generic sum type.
    */
   lazy val synthesizedSumMirror: SpecialHandler =
     (formal: Type, span: Span) => implicit (ctx: Context) =>
-      formal.member(tpnme.MonoType).info match {
+      formal.member(tpnme.MirroredMonoType).info match {
         case TypeAlias(monoType) if monoType.classSymbol.isGenericSum =>
           val cls = monoType.classSymbol
           val elemTypes = cls.children.map {
@@ -925,7 +925,7 @@ trait Implicits { self: Typer =>
           }
           val mirrorType =
              mirrorCore(defn.Mirror_SumType, monoType, cls.name)
-              .refinedWith(tpnme.ElemTypes, TypeAlias(TypeOps.nestedPairs(elemTypes)))
+              .refinedWith(tpnme.MirroredElemTypes, TypeAlias(TypeOps.nestedPairs(elemTypes)))
           val modul = cls.linkedClass.sourceModule
           val mirrorRef =
             if (modul.exists && !cls.is(Scala2x)) ref(modul).withSpan(span)
@@ -935,12 +935,12 @@ trait Implicits { self: Typer =>
           EmptyTree
       }
 
-  /** An implied instance for a type of the form `Mirror { type MonoType = T }`
+  /** An implied instance for a type of the form `Mirror { type MirroredMonoType = T }`
    *  where `T` is a generic sum or product or singleton type.
    */
   lazy val synthesizedMirror: SpecialHandler =
     (formal: Type, span: Span) => implicit (ctx: Context) =>
-      formal.member(tpnme.MonoType).info match {
+      formal.member(tpnme.MirroredMonoType).info match {
         case monoAlias @ TypeAlias(monoType) =>
           if (monoType.termSymbol.is(CaseVal) || monoType.classSymbol.isGenericProduct)
             synthesizedProductMirror(formal, span)(ctx)
diff --git a/library/src/scala/deriving.scala b/library/src/scala/deriving.scala
@@ -7,10 +7,10 @@ object deriving {
   sealed trait Mirror {
 
     /** The mirrored *-type */
-    type MonoType
+    type MirroredMonoType
 
     /** The name of the type */
-    type Label <: String
+    type MirroredLabel <: String
   }
 
   object Mirror {
@@ -19,43 +19,43 @@ object deriving {
     trait Sum extends Mirror { self =>
 
       /** The types of the alternatives */
-      type ElemTypes <: Tuple
+      type MirroredElemTypes <: Tuple
 
       /** The ordinal number of the case class of `x`. For enums, `ordinal(x) == x.ordinal` */
-      def ordinal(x: MonoType): Int
+      def ordinal(x: MirroredMonoType): Int
     }
 
     /** The Mirror for a product type */
     trait Product extends Mirror {
 
       /** The types of the product elements */
-      type ElemTypes <: Tuple
+      type MirroredElemTypes <: Tuple
 
       /** The names of the product elements */
-      type ElemLabels <: Tuple
+      type MirroredElemLabels <: Tuple
 
       /** Create a new instance of type `T` with elements taken from product `p`. */
-      def fromProduct(p: scala.Product): MonoType
+      def fromProduct(p: scala.Product): MirroredMonoType
     }
 
     trait Singleton extends Product {
-      type MonoType = this.type
-      type ElemTypes = Unit
-      type ElemLabels = Unit
+      type MirroredMonoType = this.type
+      type MirroredElemTypes = Unit
+      type MirroredElemLabels = Unit
       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 MonoType = value.type
-      type ElemTypes = Unit
-      type ElemLabels = Unit
+      type MirroredMonoType = value.type
+      type MirroredElemTypes = Unit
+      type MirroredElemLabels = Unit
       def fromProduct(p: scala.Product) = value
     }
 
-    type Of[T]        = Mirror { type MonoType = T }
-    type ProductOf[T] = Mirror.Product { type MonoType = T }
-    type SumOf[T]     = Mirror.Sum { type MonoType = T }
+    type Of[T]        = Mirror { type MirroredMonoType = T }
+    type ProductOf[T] = Mirror.Product { type MirroredMonoType = T }
+    type SumOf[T]     = Mirror.Sum { type MirroredMonoType = T }
   }
 
   /** Helper class to turn arrays into products */
diff --git a/tests/run/deriving.scala b/tests/run/deriving.scala
@@ -14,7 +14,7 @@ object Test extends App {
 
   println(the[Mirror.ProductOf[A]].fromProduct(A(1, 2)))
   assert(the[Mirror.SumOf[T]].ordinal(A(1, 2)) == 0)
-  assert(the[Mirror.Sum { type MonoType = T }].ordinal(B) == 1)
+  assert(the[Mirror.Sum { type MirroredMonoType = T }].ordinal(B) == 1)
   the[Mirror.Of[A]] match {
     case m: Mirror.Product =>
       println(m.fromProduct(A(1, 2)))
diff --git a/tests/run/ordinal-innerclass.scala b/tests/run/ordinal-innerclass.scala
@@ -15,7 +15,7 @@ object Test extends App {
   val a = new A
   val b = new a.B
   val o = b.O
-  val sum: deriving.Mirror.Sum { type MonoType = o.T }= o.T.asInstanceOf
+  val sum: deriving.Mirror.Sum { type MirroredMonoType = o.T }= o.T.asInstanceOf
   assert(sum.ordinal(new o.C(1)) == 0)
   assert(sum.ordinal(new o.T.D()) == 1)
 
diff --git a/tests/run/typeclass-derivation3.scala b/tests/run/typeclass-derivation3.scala
@@ -46,14 +46,14 @@ object typeclasses {
       }
 
     inline def eqlProduct[T](m: Mirror.ProductOf[T])(x: Any, y: Any): Boolean =
-      eqlElems[m.ElemTypes](0)(x, y)
+      eqlElems[m.MirroredElemTypes](0)(x, y)
 
     inline def eqlCases[Alts](n: Int)(x: Any, y: Any, ord: Int): Boolean =
       inline erasedValue[Alts] match {
         case _: (alt *: alts1) =>
           if (ord == n)
             implicit match {
-              case m: Mirror.ProductOf[`alt`] => eqlElems[m.ElemTypes](0)(x, y)
+              case m: Mirror.ProductOf[`alt`] => eqlElems[m.MirroredElemTypes](0)(x, y)
             }
           else eqlCases[alts1](n + 1)(x, y, ord)
         case _: Unit =>
@@ -65,9 +65,9 @@ object typeclasses {
         inline ev match {
           case m: Mirror.SumOf[T] =>
             val ord = m.ordinal(x)
-            ord == m.ordinal(y) && eqlCases[m.ElemTypes](0)(x, y, ord)
+            ord == m.ordinal(y) && eqlCases[m.MirroredElemTypes](0)(x, y, ord)
           case m: Mirror.ProductOf[T] =>
-            eqlElems[m.ElemTypes](0)(x, y)
+            eqlElems[m.MirroredElemTypes](0)(x, y)
         }
     }
 
@@ -106,7 +106,7 @@ object typeclasses {
         case _: (alt *: alts1) =>
           if (ord == n)
             implicit match {
-              case m: Mirror.ProductOf[`alt`] => pickleElems[m.ElemTypes](0)(buf, x)
+              case m: Mirror.ProductOf[`alt`] => pickleElems[m.MirroredElemTypes](0)(buf, x)
             }
           else pickleCases[alts1](n + 1)(buf, x, ord)
         case _: Unit =>
@@ -141,7 +141,7 @@ object typeclasses {
           if (ord == n)
             implicit match {
               case m: Mirror.ProductOf[`alt` & T] =>
-                unpickleCase[`alt` & T, m.ElemTypes](buf, m)
+                unpickleCase[`alt` & T, m.MirroredElemTypes](buf, m)
             }
           else unpickleCases[T, alts1](n + 1)(buf, ord)
         case _: Unit =>
@@ -154,17 +154,17 @@ object typeclasses {
           case m: Mirror.SumOf[T] =>
             val ord = m.ordinal(x)
             buf += ord
-            pickleCases[m.ElemTypes](0)(buf, x, ord)
+            pickleCases[m.MirroredElemTypes](0)(buf, x, ord)
           case m: Mirror.ProductOf[T] =>
-            pickleElems[m.ElemTypes](0)(buf, x)
+            pickleElems[m.MirroredElemTypes](0)(buf, x)
         }
       def unpickle(buf: mutable.ListBuffer[Int]): T =
         inline ev match {
           case m: Mirror.SumOf[T] =>
             val ord = nextInt(buf)
-            unpickleCases[T, m.ElemTypes](0)(buf, ord)
+            unpickleCases[T, m.MirroredElemTypes](0)(buf, ord)
           case m: Mirror.ProductOf[T] =>
-            unpickleCase[T, m.ElemTypes](buf, m)
+            unpickleCase[T, m.MirroredElemTypes](buf, m)
         }
     }
 
@@ -201,10 +201,10 @@ object typeclasses {
     }
 
     inline def showCase(x: Any, m: Mirror.ProductOf[_]): String = {
-      val label = constValue[m.Label]
+      val label = constValue[m.MirroredLabel]
       inline m match {
         case m: Mirror.Singleton => label
-        case _ => showElems[m.ElemTypes, m.ElemLabels](0)(x).mkString(s"$label(", ", ", ")")
+        case _ => showElems[m.MirroredElemTypes, m.MirroredElemLabels](0)(x).mkString(s"$label(", ", ", ")")
       }
     }
 
@@ -226,7 +226,7 @@ object typeclasses {
         inline ev match {
           case m: Mirror.SumOf[T] =>
             val ord = m.ordinal(x)
-            showCases[m.ElemTypes](0)(x, ord)
+            showCases[m.MirroredElemTypes](0)(x, ord)
           case m: Mirror.ProductOf[T] =>
             showCase(x, m)
         }
