Synthesize mirrors also for Scala 2 defined classes and objects

odersky · odersky · commit 01da2ff72dba · 2019-05-22T21:19:36.000+02:00
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -703,6 +703,9 @@ class Definitions {
   lazy val Mirror_SingletonType: TypeRef = ctx.requiredClassRef("scala.deriving.Mirror.Singleton")
   def Mirror_SingletonClass(implicit ctx: Context): ClassSymbol = Mirror_SingletonType.symbol.asClass
 
+  lazy val Mirror_SingletonProxyType: TypeRef = ctx.requiredClassRef("scala.deriving.Mirror.SingletonProxy")
+  def Mirror_SingletonProxyClass(implicit ctx: Context): ClassSymbol = Mirror_SingletonProxyType.symbol.asClass
+
   lazy val GenericType: TypeRef                = ctx.requiredClassRef("scala.reflect.Generic")
   def GenericClass(implicit ctx: Context): ClassSymbol    = GenericType.symbol.asClass
   lazy val ShapeType: TypeRef                  = ctx.requiredClassRef("scala.compiletime.Shape")
diff --git a/compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala b/compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala
@@ -17,10 +17,13 @@ import config.Printers.derive
 
 object SyntheticMembers {
 
-  /** Attachment marking an anonymous class as a singleton case that will extend from Mirror.Singleton. */
+  /** Attachment marking an anonymous class as a singleton case that will extend from Mirror.Singleton */
   val ExtendsSingletonMirror: Property.StickyKey[Unit] = new Property.StickyKey
 
-  /** Attachment marking an anonymous class as a sum mirror that will extends from Mirror.Sum. */
+  /** Attachment recording that an anonymous class should extend Mirror.Product */
+  val ExtendsProductMirror: Property.StickyKey[Unit] = new Property.StickyKey
+
+  /** Attachment recording that an anonymous class should extend Mirror.Sum */
   val ExtendsSumMirror: Property.StickyKey[Unit] = new Property.StickyKey
 }
 
@@ -423,32 +426,28 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     }
     def makeSingletonMirror() =
       addParent(defn.Mirror_SingletonType)
-    def makeProductMirror() = {
+    def makeProductMirror(cls: Symbol) = {
       addParent(defn.Mirror_ProductType)
-      addMethod(
-        nme.fromProduct,
-        MethodType(defn.ProductType :: Nil, monoType.typeRef),
-        linked,
+      addMethod(nme.fromProduct, MethodType(defn.ProductType :: Nil, monoType.typeRef), cls,
         fromProductBody(_, _)(_).ensureConforms(monoType.typeRef))  // t4758.scala or i3381.scala are examples where a cast is needed
     }
     def makeSumMirror(cls: Symbol) = {
       addParent(defn.Mirror_SumType)
-      addMethod(
-        nme.ordinal,
-        MethodType(monoType.typeRef :: Nil, defn.IntType),
-        cls,
+      addMethod(nme.ordinal, MethodType(monoType.typeRef :: Nil, defn.IntType), cls,
         ordinalBody(_, _)(_))
     }
 
     if (clazz.is(Module)) {
       if (clazz.is(Case)) makeSingletonMirror()
-      else if (linked.isGenericProduct) makeProductMirror()
+      else if (linked.isGenericProduct) makeProductMirror(linked)
       else if (linked.isGenericSum) makeSumMirror(linked)
       else if (linked.is(Sealed))
         derive.println(i"$linked is not a sum because ${linked.whyNotGenericSum}")
     }
     else if (impl.removeAttachment(ExtendsSingletonMirror).isDefined)
       makeSingletonMirror()
+    else if (impl.removeAttachment(ExtendsProductMirror).isDefined)
+      makeProductMirror(monoType.typeRef.dealias.classSymbol)
     else if (impl.removeAttachment(ExtendsSumMirror).isDefined)
       makeSumMirror(monoType.typeRef.dealias.classSymbol)
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -29,7 +29,7 @@ import Inferencing.fullyDefinedType
 import Trees._
 import transform.SymUtils._
 import transform.TypeUtils._
-import transform.SyntheticMembers.ExtendsSumMirror
+import transform.SyntheticMembers._
 import Hashable._
 import util.{Property, SourceFile, NoSource}
 import config.Config
@@ -815,35 +815,69 @@ trait Implicits { self: Typer =>
           EmptyTree
       }
 
+  /** Create an anonymous class `new Object { type MonoType = ... }`
+   *  and mark it with given attachment so that it is made into a mirror at PostTyper.
+   */
+  def anonymousMirror(monoType: Type, attachment: Property.StickyKey[Unit], span: Span)(implicit ctx: Context) = {
+    val monoTypeDef = untpd.TypeDef(tpnme.MonoType, untpd.TypeTree(monoType))
+    val newImpl = untpd.Template(
+      constr = untpd.emptyConstructor,
+      parents = untpd.TypeTree(defn.ObjectType) :: Nil,
+      derived = Nil,
+      self = EmptyValDef,
+      body = monoTypeDef :: Nil
+    ).withAttachment(attachment, ())
+    typed(untpd.New(newImpl).withSpan(span))
+  }
+
   lazy val synthesizedProductMirror: SpecialHandler =
     (formal: Type, span: Span) => implicit (ctx: Context) => {
-      formal.member(tpnme.MonoType).info match {
-        case monoAlias @ TypeAlias(monoType) =>
+      def mirrorFor(monoType: Type): Tree = monoType match {
+        case AndType(tp1, tp2) =>
+          mirrorFor(tp1).orElse(mirrorFor(tp2))
+        case _ =>
           if (monoType.termSymbol.is(CaseVal)) {
             val modul = monoType.termSymbol
             val label = ConstantType(Constant(modul.name.toString))
-            val mirrorType = defn.Mirror_SingletonType
-              .refinedWith(tpnme.MonoType, monoAlias)
-              .refinedWith(tpnme.Label, TypeAlias(label))
-            ref(modul).withSpan(span).cast(mirrorType)
+            if (modul.info.classSymbol.is(Scala2x)) {
+              val mirrorType =
+                defn.Mirror_SingletonProxyType
+                  .refinedWith(tpnme.MonoType, TypeAlias(monoType))
+                  .refinedWith(tpnme.Label, TypeAlias(label))
+              val mirrorRef = New(defn.Mirror_SingletonProxyType, ref(modul).withSpan(span) :: Nil)
+              mirrorRef.cast(mirrorType)
+            }
+            else {
+              val mirrorType = defn.Mirror_SingletonType
+                .refinedWith(tpnme.MonoType, TypeAlias(monoType))
+                .refinedWith(tpnme.Label, TypeAlias(label))
+              val mirrorRef = ref(modul).withSpan(span)
+              mirrorRef.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 elemTypes = accessors.map(monoType.memberInfo(_).widenExpr)
             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.MonoType, TypeAlias(monoType))
                 .refinedWith(tpnme.ElemTypes, TypeAlias(TypeOps.nestedPairs(elemTypes)))
                 .refinedWith(tpnme.Label, TypeAlias(label))
                 .refinedWith(tpnme.ElemLabels, TypeAlias(TypeOps.nestedPairs(elemLabels)))
             val modul = cls.linkedClass.sourceModule
             assert(modul.is(Module))
-            ref(modul).withSpan(span).cast(mirrorType)
+            val mirrorRef =
+              if (cls.is(Scala2x)) anonymousMirror(monoType, ExtendsProductMirror, span)
+              else ref(modul).withSpan(span)
+            mirrorRef.cast(mirrorType)
           }
           else EmptyTree
+      }
+      formal.member(tpnme.MonoType).info match {
+        case monoAlias @ TypeAlias(monoType) => mirrorFor(monoType)
         case _ => EmptyTree
       }
     }
@@ -863,9 +897,8 @@ trait Implicits { self: Typer =>
                 case info: PolyType =>
                   def instantiate(implicit ctx: Context) = {
                     val poly = constrained(info, untpd.EmptyTree)._1
-                    val mono @ MethodType(_) = poly.resultType
-                    val resType = mono.finalResultType
-                    resType <:< cls.appliedRef
+                    val resType = poly.finalResultType
+                    resType <:< monoType
                     val tparams = poly.paramRefs
                     val variances = caseClass.typeParams.map(_.paramVariance)
                     val instanceTypes = (tparams, variances).zipped.map((tparam, variance) =>
@@ -885,20 +918,8 @@ trait Implicits { self: Typer =>
               .refinedWith(tpnme.ElemTypes, TypeAlias(TypeOps.nestedPairs(elemTypes)))
           var modul = cls.linkedClass.sourceModule
           val mirrorRef =
-            if (modul.exists) ref(modul).withSpan(span)
-            else {
-              // create an anonymous class `new Object { type MonoType = ... }`
-              // and mark it so that it is made into a `Mirror.Sum` at PostTyper.
-              val monoTypeDef = untpd.TypeDef(tpnme.MonoType, untpd.TypeTree(monoType))
-              val newImpl = untpd.Template(
-                constr = untpd.emptyConstructor,
-                parents = untpd.TypeTree(defn.ObjectType) :: Nil,
-                derived = Nil,
-                self = EmptyValDef,
-                body = monoTypeDef :: Nil
-              ).withAttachment(ExtendsSumMirror, ())
-              typed(untpd.New(newImpl).withSpan(span))
-            }
+            if (modul.exists && !cls.is(Scala2x)) ref(modul).withSpan(span)
+            else anonymousMirror(monoType, ExtendsSumMirror, span)
           mirrorRef.cast(mirrorType)
         case _ =>
           EmptyTree
diff --git a/library/src/scala/deriving.scala b/library/src/scala/deriving.scala
@@ -42,11 +42,15 @@ object deriving {
       type MonoType = this.type
       type ElemTypes = Unit
       type ElemLabels = Unit
-
       def fromProduct(p: scala.Product) = this
+    }
 
-      def productElement(n: Int): Any = throw new IndexOutOfBoundsException(n.toString)
-      def productArity: Int = 0
+    /** 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
+      def fromProduct(p: scala.Product) = value
     }
 
     type Of[T]        = Mirror { type MonoType = T }
diff --git a/tests/run/typeclass-derivation3.check b/tests/run/typeclass-derivation3.check
@@ -4,10 +4,10 @@ ListBuffer(0, 0, 11, 0, 22, 0, 33, 1, 0, 0, 11, 0, 22, 1, 1)
 Cons(Cons(11,Cons(22,Cons(33,Nil))),Cons(Cons(11,Cons(22,Nil)),Nil))
 ListBuffer(1, 2)
 Pair(1,2)
-Cons(hd = 11, tl = Cons(hd = 22, tl = Cons(hd = 33, tl = Nil())))
-Cons(hd = Cons(hd = 11, tl = Cons(hd = 22, tl = Cons(hd = 33, tl = Nil()))), tl = Cons(hd = Cons(hd = 11, tl = Cons(hd = 22, tl = Nil())), tl = Nil()))
-Cons(hd = Left(x = 1), tl = Cons(hd = Right(x = Pair(x = 2, y = 3)), tl = Nil()))
-Cons(hd = Left(x = 1), tl = Cons(hd = Right(x = Pair(x = 2, y = 3)), tl = Nil()))
+Cons(hd = 11, tl = Cons(hd = 22, tl = Cons(hd = 33, tl = Nil)))
+Cons(hd = Cons(hd = 11, tl = Cons(hd = 22, tl = Cons(hd = 33, tl = Nil))), tl = Cons(hd = Cons(hd = 11, tl = Cons(hd = 22, tl = Nil)), tl = Nil))
+Cons(hd = Left(x = 1), tl = Cons(hd = Right(x = Pair(x = 2, y = 3)), tl = Nil))
+Cons(hd = Left(x = 1), tl = Cons(hd = Right(x = Pair(x = 2, y = 3)), tl = Nil))
 true
 ::(head = 1, tl$access$1 = ::(head = 2, tl$access$1 = ::(head = 3, tl$access$1 = Nil())))
 ::(head = ::(head = 1, tl$access$1 = Nil()), tl$access$1 = ::(head = ::(head = 2, tl$access$1 = ::(head = 3, tl$access$1 = Nil())), tl$access$1 = Nil()))
diff --git a/tests/run/typeclass-derivation3.scala b/tests/run/typeclass-derivation3.scala
